‫ﺗﻘﺪﯾﻢ‪ :‬ﻟﻤﺎذا ﻧﺒﺮﻣﺞ؟‬

‫اﻟﺤﻤﺪ ﷲ ﻣﻌﺰ اﻟﺤﻖ وﻧﺎﺻﺮه‪ ،‬وﻣﺬل اﻟﺒﺎﻃﻞ وﻗﺎﺻﺮه‪ ،‬ﻋﻼم اﻟﻐﯿﻮب‪ ،‬وﻣﻦ ﺑﯿﺪه أزﻣﺔ اﻟﻘﻠﻮب‪،‬‬

‫اﻟﺨﺒﯿﺮ ﺑﻤﺎ ﺗﺨﻔﻲ اﻟﻀﻤﺎﺋﺮ‪ ،‬وﺗﻜﻦ اﻟﺴﺮاﺋﺮ‪ ،‬اﻟﻌﺎﻟﻢ ﺑﻤﺎ ﺗﻔﻀﻲ إﻟﯿﮫ اﻷﻣﻮر‪ ،‬وﺑﺨﺎﺋﻨﺔ اﻷﻋﯿﻦ وﻣﺎ‬

‫ﺗﺨﻔﻲ اﻟﺼﺪور‪ ،‬واﻟﺼﻼة واﻟﺴﻼم ﻋﻠﻰ ﺣﺒﯿﺒﻨﺎ ﻣﺤﻤﺪ ﻛﺎﺷﻒ اﻟﻐﻤﺔ ﻋﻦ اﻷﻣﺔ‪ ،‬اﻟﻨﺎﻃﻖ ﻓﯿﮭﻢ‬

‫ﺑﺎﻟﺤﻜﻤﺔ‪ ،‬اﻟﺼﺎدع ﺑﺎﻟﺤﻖ‪ ،‬اﻟﺪاﻋﻲ إﻟﻰ اﻟﺼﺪق‪.‬‬

‫ﺛﻢ أﻣﺎ ﺑﻌﺪ‪:‬‬

‫ﻛﻞ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﺴﺘﺨﺪﻣﮭﺎ ﻋﻠﻰ ﺣﺎﺳﻮﺑﻚ ﻟﻢ ﺗﺄت ﻣﻦ ﻓﺮاغ‪ ،‬ﺑﻞ ھﻲ ﻧﺘﺎج ﻟﻠﺘﺮﻛﯿﺒﺔ اﻟﺒﺸﺮﯾﺔ‬

‫اﻟﺘﻲ ﻓﻄﺮ اﷲ ﻋﺰ وﺟﻞ اﻟﻨﺎس ﻋﻠﯿﮭﺎ‪ ،‬واﻟﺘﻲ ﺗﺪﻓﻌﮭﻢ ﺑﺎﺳﺘﻤﺮار إﻟﻰ إﯾﺠﺎد ﺣﻠﻮل ﻟﻮﺿﻌﯿﺎت‬

‫ﻣﻌﯿﻨﺔ أو اﺑﺘﻜﺎر وﺳﺎﺋﻞ ﻟﻠﻮﺻﻮل إﻟﻰ ﻏﺎﯾﺎت ﻣﻨﺸﻮدة ﻛﻠﻤﺎ أﻟﻤﺖ ﺑﮭﻢ ﺣﺎﺟﺔ‪ ،‬وھﺬا دأب اﻹﻧﺴﺎن‬

‫وﺣﺎﻟﮫ ﻣﺬ أوﺟﺪه اﷲ ﺟﻞ وﻋﻼ‪ ،‬ﻓﻜﻤﺎ أن اﻹﻧﺴﺎن ﻓﻲ أول ﻋﮭﺪه ﻋﺎﻧﻰ ﻣﻦ ﻗﺴﻮة اﻷﺟﻮاء‬

‫واﻟﻄﻘﻮس وﺗﻘﻠﺒﺎﺗﮭﺎ ﺑﯿﻦ ﻗﺮ وﺣﺮ‪ ،‬ﻓﺪﻓﻌﺘﮫ اﻟﺤﺎﺟﺔ إﻟﻰ أن ﯾﺘﺨﺬ ﻣﻦ اﻟﻜﮭﻮف واﻟﻐﯿﺮان ﻣﺴﺎﻛﻨﺎ ﻟﮫ‬

‫ﻟﯿﺤﺘﻤﻲ ﺑﮭﺎ وﯾﻠﺠﺄ إﻟﯿﮭ ﺎ‪ ،‬ودﻓﻌﺘﮫ ﺻﻌﻮﺑﺔ ﺻﯿﺪ اﻟﻮﺣﻮش ﺑﺎﻟﯿﺪ ﻓﺎﺗﺨﺬ ﻣﻦ ﺟﺬع اﻟﺸﺠﺮ ﺳﻼﺣﺎ ﻟﮫ‬

‫ﯾﮭﻮي ﺑﮫ ﻋﻠﻰ اﻟﻄﺮاﺋﺪ‪ ،‬ودﻓﻌﮫ ﺣﯿﺎؤه ﻣﻦ اﻟﺠﻨﺲ اﻵﺧﺮ ﻓﺎﺗﺨﺬ ﻣﻦ ﺟﻠﺪ اﻷﻧﻌﺎم ﻟﺒﺎﺳﺎ ﻟﮫ ﯾﻮاري‬

‫ﺳﻮأﺗﮫ‪ ،‬ودﻓﻌﺘﮫ اﻟﺤﺎﺟﺔ إﻟﻰ ﺻﻨﻊ ﻣﺮاﻛﺐ ﯾﻤﺸﻲ ﺑﮭﺎ ﻓﻲ اﻟﺒﺤﺮ ﻓﺼﻨﻊ اﻟﻤﻄﺮﻗﺔ وﺑﺎﻗﻲ اﻷدوات‪،‬‬

‫ﻓﻜﺬﻟﻚ ﺷﺄن اﻹﻧﺴﺎن اﻟﯿﻮم‪ ،‬ﻓﺈﻧﮫ ﻛﻠﻤﺎ أﻟﻤﺖ ﺑﮫ ﺣﺎﺟﺔ أو أﺻﺎﺑﺘﮫ داھﯿﺔ‪ ،‬ﻓﻜﺮ ﻣﻠﯿﺎ ﻛﯿﻒ ﯾﺴﻠﻢ ﻣﻨﮭﺎ‬

‫ﻓﻲ اﻟﻤﺮة اﻟﻘﺎدﻣﺔ ﻋﺒﺮ اﺑﺘﻜﺎر ﺣﻠﻮل ﺟﺪﯾﺪة ﻟﻢ ﯾﻌﺮﻓﮭﺎ أﺳﻼﻓﮫ‪.‬‬

‫ﻓﻲ ﺑﺮﯾﻄﺎﻧﯿﺎ‪ ،‬ﻓﻲ ﻋﺸﺮﯾﻨﯿﺎت اﻟﻘﺮن اﻟﺘﺎﺳﻊ ﻋﺸﺮ اﺣﺘﺎج اﻟﺘﺠﺎر إﻟﻰ وﺳﺎﺋﻞ ﻟﻨﻘﻞ اﻟﺒﻀﺎﻋﺔ‬

‫واﻟﺴﻠﻊ اﻟﻜﺜﯿﺮة ﺑﯿﻦ اﻟﻤﻨﺎﻃﻖ اﻟﻤﺘﺒﺎﻋﺪة‪ ،‬ﻓﺪﻓﻌﺖ ھﺬه اﻟﺤﺎﺟﺔ إﻟﻰ اﺧﺘﺮاع أول ﺧﻂ ﻟﻠﺴﻜﻚ‬

‫اﻟﺤﺪﯾﺪﯾﺔ ﺑﻤﺤﺮﻛﺎت ﺑﺨﺎرﯾﺔ‪ ،‬ﻓﺘﻄﻮرت اﻟﻔﻜﺮة ﻟﺘﺼﺒﺢ اﻟﻘﻄﺎرات ﺑﺎﻟﺸﻜﻞ اﻟﺬي ﻧﺮاھﺎ ﻋﻠﯿﮫ اﻟﯿﻮم‪.‬‬

‫‪2‬‬
‫وﺣﯿﻨﻤﺎ اﺣﺘﺎج اﻟﻨﺎس إﻟﻰ ﻧﻘﻞ اﻷﻧﺒﺎء واﻷﺧﺒﺎر‪ ،‬ﻗﺎﻣﻮا ﺑﻨﺸﺮ اﻟﺼﺤﻒ‪ ،‬ﺛﻢ اﺧﺘﺮاع اﻟﻤﺬﯾﺎع‪ ،‬ﺛﻢ‬

‫اﻟﺘﻠﻔﺎز‪ ،‬ﺛﻢ اﻻﻧﺘﺮﻧﺖ‪.‬‬

‫وﺣﯿﻨﻤﺎ اﺣﺘﺎج اﻟﻨﺎس ﻟﻠﺘﻮاﺻﻞ ﻓﯿﻤﺎ ﺑﯿﻨﮭﻢ‪ ،‬ﺑﺪؤوا ﺑﺎﺳﺘﻌﻤﺎل اﻟﺤﻤﺎم اﻟﺰاﺟﻞ‪ ،‬ﺛﻢ اﺳﺘﺨﺪام اﻟﺒﺮﯾﺪ‬

‫اﻟﻮرﻗﻲ‪ ،‬ﺛﻢ اﺳﺘﺨﺪام اﻟﺘﻠﻐﺮاف‪ ،‬ﺛﻢ اﻷﻗﻤﺎر اﻟﺼﻨﺎﻋﯿﺔ وﻏﯿﺮھﺎ‪.‬‬

‫ﻛﻠﻨﺎ ﺷﺎھﺪﻧﺎ ﻛﯿﻒ ﺗﺘﺎﻟﺖ اﻷﻣﻮاج اﻟﺒﺤﺮﯾﺔ اﻟﺰﻟﺰاﻟﯿﺔ "ﺗﺴﻮﻧﺎﻣﻲ" ﻋﻠﻰ ﺷﺮق آﺳﯿﺎ‪ ،‬ﻓﺪﻓﻊ ذﻟﻚ‬

‫اﻟﯿﺎﺑﺎﻧﯿﯿﻦ إﻟﻰ إﻧﺸﺎء ﻣﺒﺎﻧﻲ ﻣﻀﺎدة ﻟﻠﺰﻻزل‪ ،‬وﻛﻠﻨﺎ ﺷﺎھﺪ ﻛﯿﻒ ﻋﺎﻧﺖ اﻟﯿﺎﺑﺎن ﻣﻦ ﻣﺸﻜﻞ اﺳﺘﯿﺮاد‬

‫اﻟﻤﻨﺘﺠﺎت اﻟﺰراﻋﯿﺔ ﺑﺴﺒﺐ اﻧﻌﺪام اﻟﺴﮭﻮل ﻓﻲ أراﺿﯿﮭﺎ‪ ،‬ﻓﺪﻓﻌﮭﺎ ذﻟﻚ إﻟﻰ إﻧﺸﺎء ﻣﺪرﺟﺎت‬

‫ﻓﻼﺣﯿﺔ ﻋﻠﻰ اﻟﺠﺒﺎل‪.‬‬

‫اﻟﺤﺎﺟﺔ أم اﻻﺧﺘﺮاع‪ ،‬ﻓﻠﻮﻻ ﺣﺎﺟﺔ اﻹﻧﺴﺎن إﻟﻰ اﻟﺸﻲء ﻟﻤﺎ ﺷﻐﻞ ﺑﺎﻟﮫ ﺑﮫ‪ ،‬وﺣﺎﺟﺎت اﻹﻧﺴﺎن‬

‫ﻣﺘﻐﯿﺮة وﺗﺘﺰاﯾﺪ ﺑﺎﺳﺘﻤﺮار‪ ،‬واﻟﺤﺎﺟﺔ ھﻲ اﻟﺘﻲ ﺗﺪﻓﻊ اﻟﻨﺎس إﻟﻰ إﻧﺸﺎء ﺑﺮاﻣﺞ‪.‬‬

‫اﺳﺄل ﻧﻔﺴﻚ ﻋﻦ ﻛﻞ ﺑﺮﻧﺎﻣﺞ ﻧﺼﺒﺘﮫ ﻋﻠﻰ ﺣﺎﺳﻮﺑﻚ‪ :‬ﻟﻤﺎذا ﻧﺼﺒﺘﮫ؟ وﺳﯿﻜﻮن ﺟﻮاﺑﻚ ﺣﺘﻤﺎ وﻣﻦ‬

‫ﻏﯿﺮ ﺷﻚ ھﻮ ﺣﺎﺟﺘﻚ ﻟﮫ‪ ،‬ﻓﺄﻧﺖ ﻧﺼﺒﺖ ﻣﻜﺎﻓﺢ اﻟﻔﯿﺮوﺳﺎت ‪ anti-virus‬ﻟﺤﻤﺎﯾﺔ ﺣﺎﺳﻮﺑﻚ ﻣﻦ‬

‫اﻷﺿﺮار اﻟﻤﺤﺘﻤﻠﺔ‪ ،‬وﻧﺼﺒﺖ ﺑﺮﻧﺎﻣﺞ ﻣﯿﻜﺮوﺳﻮﻓﺖ وورد ‪ microsoft word‬ﻷﻧﻚ ﺗﺤﺘﺎج‬

‫إﻟﻰ ﻛﺘﺎﺑﺔ وﻣﻌﺎﻟﺠﺔ اﻟﻨﺼﻮص وﺗﻨﺴﯿﻘﮭﺎ‪ ،‬وﻧﺼﺒﺖ ﺑﺮﻧﺎﻣﺞ ﻗﺎرىء اﻟﻤﯿﺪﯾﺎ‪ ،‬ﻷﻧﻚ ﺗﺤﺘﺎج إﻟﻰ‬

‫ﻣﺸﺎھﺪة ﺗﺴﺠﯿﻼت ﻣﺮﺋﯿﺔ‪ ،‬وﻧﺼﺒﺖ ﻣﺘﺼﻔﺢ اﻟﻮﯾﺐ ﻷﻧﻚ ﺗﺤﺘﺎج إﻟﻰ اﻟﺪﺧﻮل إﻟﻰ اﻟﻤﻮاﻗﻊ‪.‬‬

‫ﻧﻔﺲ اﻟﺤﺎﺟﺔ اﻟﺘﻲ دﻓﻌﺘﻚ إﻟﻰ ﺗﺤﻤﯿﻞ اﻟﺒﺮﻧﺎﻣﺞ وﺗﻨﺼﯿﺒﮫ دﻓﻌﺖ ﻏﯿﺮك ﻣﻦ ﻣﺴﺘﺨﺪﻣﯿﮫ‪ ،‬ودﻓﻌﺖ‬

‫ﻗﺒﻠﻜﻢ ﺟﻤﯿﻌﺎ ﻓﺌﺔ ﻣﻦ اﻟﻨﺎس‪ ،‬ﻓﻘﺎﻟﻮا‪ :‬ﻧﺤﻦ ﻧﺤﺘﺎج إﻟﻰ ﺑﺮﻧﺎﻣﺞ ﯾﻘﻮم ﺑﻜﺬا وﻛﺬا‪ ،‬ﻓﻠﻤﺎ ﺑﺰﻏﺖ اﻟﺤﺎﺟﺔ‬

‫ﺑﺮزت ﺷﺮﻛﺔ ﺑﺮﻣﺠﯿﺔ وﻗﺎﻟﺖ‪:‬أﻧﺎ ﻟﮭﺎ‪.‬‬

‫‪3‬‬
‫ﻟﻜﻦ ﻣﺎ ﯾﮭﻤﻨﺎ ﻧﺤﻦ ﻛﺄﻓﺮاد ﻧﺴﻌﻰ إﻟﻰ ﺗﻌﻠﻢ اﻟﺒﺮﻣﺠﺔ‪ ،‬ھﻮ ﻣﻌﺮﻓﺔ اﻟﻄﺮﯾﻘﺔ اﻟﺼﺤﯿﺤﺔ اﻟﺘﻲ‬

‫ﺑﺎﻧﺘﮭﺎﺟﻨﺎ ﻟﮭﺎ ﺳﻨﻨﺸﻰء ﺑﺮاﻣﺞ ﻗﻮﯾﺔ وﺗﻄﺒﯿﻘﺎت ﺟﯿﺪة ﺑﺎﻟﺸﻜﻞ اﻟﺬي ﻧﻄﻤﺢ إﻟﯿﮫ أو ﺑﺎﻟﺸﻜﻞ‬

‫اﻟﻤﻄﻠﻮب ﻣﻨﺎ‪.‬‬

‫وھﺬا ﻣﺎ ﺳﻨﻌﺮض ﻟﮫ ﺧﻼل ﻛﺘﺎﺑﻨﺎ ھﺬا‪ ،‬وﺳﻨﺤﺎول ﻗﺪر اﻟﻤﺴﺘﻄﺎع أن ﻧﺴﻠﻚ ﺳﺒﯿﻞ اﻟﺒﺴﺎﻃﺔ‬

‫واﻟﺘﻔﻜﯿﻚ‪ ،‬ﺑﻌﯿﺪﯾﻦ ﻛﻞ اﻟﺒﻌﺪ ﻋﻦ اﻟﺼﻌﻮﺑﺔ واﻟﺘﻌﻘﯿﺪ‪ ،‬ﻟﺬﻟﻚ ﻗﺪ أﻃﯿﻞ ﻓﻲ ﻓﺼﻞ ﻣﻌﯿﻦ وأﺳﮭﺐ ﻓﯿﮫ‬

‫ﻓﻼ ﺗﻠﻮﻣﻮﻧﻲ وﺗﻌﺬﻟﻮﻧﻲ ﻓﺈﻧﻲ ﻣﺎ أﺳﮭﺒﺖ ﻓﯿﮫ وأﻃﻠﺖ ﺣﺒﺎ ﻓﻲ ذﻟﻚ أو رﻏﺒﺔ ﻓﻲ اﺳﺘﻌﺮاض‬

‫اﻟﻤﻌﺎرف‪ ،‬ﻛﻼ وأﻟﻒ ﻛﻼ‪ ،‬وإﻧﻤﺎ ﻃﺒﯿﻌﺔ اﻟﻤﺪروس ﺗﺴﺘﻠﺰم ﻣﻨﺎ ﺷﺮﺣﮫ ﻣﻦ ﻛﻞ ﺟﻮاﻧﺒﮫ ﻟﻨﻔﮭﻤﮫ‬

‫ﻓﮭﻤﺎ ﺷﺎﻣﻼ‪ ،‬وﻟﻮ ﻟﺨﺼﻨﺎه أو اﻗﺘﻀﺒﻨﺎه ﻟﺸﻮھﻨﺎه وأﺳﺄﻧﺎ ﺷﺮﺣﮫ‪ ،‬ﻓﺘﺼﻞ إﻟﯿﻜﻢ اﻟﻤﻌﻠﻮﻣﺔ ﻣﻐﻠﻮﻃﺔ‬

‫أو ﻏﯿﺮ ﻛﺎﻣﻠﺔ‪.‬‬

‫ﯾﺘﻜﻮن ھﺬا اﻟﻜﺘﺎب ﻣﻦ ﺛﻼﺛﺔ أﺟﺰاء ﯾﻜﻤﻞ ﺑﻌﻀﮭﺎ اﻟﺒﻌﺾ‪ ،‬ﻓﺎﻟﺠﺰء اﻷول ﯾﺘﻨﺎول ﻣﻔﮭﻮم أﻧﻈﻤﺔ‬

‫اﻟﺘﺮﻣﯿﺰ واﻟﻄﺮق اﻟﺘﻲ ﯾﻌﺎﻟﺞ ﺑﮭﺎ ﺟﮭﺎز اﻟﺤﺎﺳﻮب اﻟﺒﯿﺎﻧﺎت واﻟﻤﻜﻮﻧﺎت اﻟﻤﺎدﯾﺔ اﻟﻤﺘﺪﺧﻠﺔ ﻓﻲ‬

‫اﻟﻌﻤﻠﯿﺔ ﻟﻜﻲ ﯾﻜﻮن اﻟﻤﺘﻌﻠﻢ ﻋﻠﻰ دارﯾﺔ ﺑﻤﺎ ﯾﺤﺼﻞ ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﺠﮭﺎز ﺣﯿﻨﻤﺎ ﯾﺨﺎﻃﺒﮫ ﺑﺄواﻣﺮ‬

‫ﺑﺮﻣﺠﯿﺔ‪ ،‬واﻟﺠﺰء اﻟﺜﺎﻧﻲ ﯾﻌﺮض ﺑﺎﺧﺘﺼﺎر ﻛﯿﻔﯿﺔ اﻟﻘﯿﺎم ﺑﺎﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ اﻷﺳﺎﺳﯿﺔ ﻋﻠﻰ‬

‫اﻟﺒﯿﺎﻧﺎت اﻟﺜﻨﺎﺋﯿﺔ‪ ،‬أﻣﺎ اﻟﺠﺰء اﻟﺜﺎﻟﺚ ﻓﮭﻮ ﯾﺘﻨﺎول اﻟﺨﻮارزﻣﯿﺎت ﻣﻦ اﻟﺒﺪاﯾﺔ ﺑﺄﺳﻠﻮب ﻣﺘﺪرج‬

‫وﺑﺄﻣﺜﻠﺔ ﺗﻄﺒﯿﻘﯿﺔ‪.‬‬

‫ﺧﺎﻟﺪ اﻟﺴﻌﺪاﻧﻲ ‪2013/10/16‬‬

‫‪4‬‬
 ‫ﻣﺎ اﻟﺬي ﺳﺄﺳﺘﻔﯿﺪه إن ﻗﺮأت ھﺬا اﻟﻜﺘﺎب؟‬
‫إذا ﻗﺮأت ھﺬا اﻟﻜﺘﺎب ﻛﺎﻣﻼ وﺑﺘﻤﻌﻦ ﻓﺈﻧﻲ أﺿﻤﻦ ﻟﻚ ﺑﻌﻮن اﷲ ﻣﺎ ﯾﻠﻲ‪:‬‬

‫‪ .1‬ﻓﮭﻢ ﺳﻠﯿﻢ ﻷﺳﺎس اﻟﺒﺮﻣﺠﺔ‬

‫‪ .2‬اﻟﻘﺪرة ﻋﻠﻰ ﺗﻌﻠﻢ أﯾﺔ ﻟﻐﺔ ﺑﺮﻣﺠﯿﺔ ﻣﮭﻤﺎ ﺑﻠﻐﺖ ﺻﻌﻮﺑﺘﮭﺎ وﺗﻌﻘﯿﺪاﺗﮭﺎ‬

‫‪ .3‬إﻣﻜﺎﻧﯿﺔ ﺗﻌﻠﻢ أﻛﺜﺮ ﻣﻦ ﻟﻐﺔ ﺑﺮﻣﺠﯿﺔ ﻓﻲ وﻗﺖ وﺟﯿﺰ‬

‫‪ .4‬اﻟﻘﺪرة ﻋﻠﻰ ﺗﺤﻠﯿﻞ اﻟﻤﺸﻜﻞ اﻟﻮاﻗﻌﻲ وﺗﺄوﯾﻠﮫ ﺑﺮﻣﺠﯿﺎ ﻋﺒﺮ اﻟﺨﻮارزﻣﯿﺎت‬

‫‪ .5‬ﺑﺪاﯾﺔ ﻗﻮﯾﺔ وأﺳﺎس ﻣﺘﯿﻦ ﻟﺪﺧﻮل ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﺔ‬

‫ھﻞ أﺳﺘﻄﯿﻊ ﻗﺮاءة ﺟﺰء ﻣﻦ اﻟﻜﺘﺎب ﻓﻘﻂ؟‬

‫ذﻟﻚ ﯾﺘﻮﻗﻒ ﻋﻠﻰ ﻣﻌﺎرﻓﻚ وﻣﺪارﻛﻚ‪ ،‬إن ﻛﻨﺖ ﻋﻠﻰ دراﯾﺔ ﺑﺄﺳﺎﺳﯿﺎت اﻟﺒﺮﻣﺠﺔ‪ ،‬أو ﻟﻚ ﺧﺒﺮة‬

‫ﺳﺎﺑﻘﺔ ﻣﻊ ﻟﻐﺔ ﺑﺮﻣﺠﯿﺔ ﻣﻌﯿﻨﺔ‪ ،‬ﻓﻼ ﻣﺎﻧﻊ ﻣﻦ أن ﺗﻜﺘﻔﻲ ﺑﻘﺮاءة ﺟﺰء دون ﺟﺰء‪.‬‬

‫ﻟﻜﻦ إن ﻛﺎن ھﺬا أول ﻋﮭﺪك ﺑﺎﻟﺒﺮﻣﺠﺔ‪ ،‬ﻓﺄﻧﺖ ﻣﻄﺎﻟﺐ ﺑﻘﺮاءة اﻟﻜﺘﺎب ﻛﺎﻣﻼ‪ ،‬وﺗﻄﺒﯿﻖ ﻣﺎ ﺟﺎء ﻓﯿﮫ‬

‫ﻣﻦ ﺗﻤﺎرﯾﻦ‪ ،‬واﻷﺧﺬ ﺑﻤﺎ ورد ﻓﯿﮫ ﻣﻦ إرﺷﺎدات وﺗﻌﻠﯿﻤﺎت‪.‬‬

‫ھﻞ ﻋﻠﻲ ﺗﻌﻠﻢ اﻻﻧﺠﻠﯿﺰﯾﺔ ﻟﻜﻲ أﺻﺒﺢ ﻣﺒﺮﻣﺠﺎ؟‬

‫ﺗﻌﻠﻢ اﻟﻠﻐﺔ اﻻﻧﺠﻠﯿﺰﯾﺔ ﻓﻲ وﻗﺘﻨﺎ اﻟﺮاھﻦ ﺷﻲء ﻣﮭﻢ ﺟﺪا ﻟﻤﻦ ﯾﺮﯾﺪ أن ﯾﻮاﻛﺐ ﺗﻄﻮرات اﻟﻌﺼﺮ‪،‬‬

‫ﺑﯿﺪ أن ﻣﻌﻈﻢ اﻟﺘﻘﻨﯿﺎت واﻟﻤﻌﺎرف ﺑﺎﺗﺖ ﺗﻌﺮض ﺑﮭﺬه اﻟﻠﻐﺔ‪ ،‬ﻟﻜﻦ دﻋﻨﻲ أﻛﻠﻤﻚ ﺑﺼﺪق‪ ،‬ﻓﻲ ﻋﺎﻟﻢ‬

‫اﻟﺒﺮﻣﺠﺔ ﻟﺴﺖ ﻣﻄﺎﻟﺒﺎ أن ﺗﻜﻮن ﻣﺘﻘﻨﺎ وﻣﺘﻤﻜﻨﺎ ﻣﻦ اﻟﻠﻐﺔ اﻻﻧﺠﻠﯿﺰﯾﺔ‪ ،‬ﻏﯿﺮ ﺻﺤﯿﺢ ﺑﺘﺎﺗﺎ‪ ،‬وﻣﻦ ﻗﺎل‬

‫‪5‬‬
‫ﻟﻚ ذﻟﻚ ﻓﻘﺪ ﻛﺬﺑﻚ اﻟﻘﻮل أو ﺣﺪﺛﻚ ﻋﻦ ﺟﮭﻞ ﻣﻨﮫ ﺑﺎﻟﺒﺮﻣﺠﺔ‪ ،‬أن ﺗﻜﻮن ﻣﺒﺮﻣﺠﺎ ﻻ ﯾﻌﻨﻲ أن ﺗﻜﻮن‬

‫أﻣﺮﯾﻜﯿﺎ أو ﺑﺮﯾﻄﺎﻧﯿﺎ‪ ،‬ﺑﻞ ﯾﻠﺰﻣﻚ ﺷﻲء ﻣﻦ اﻟﺠﮭﺪ وﻛﺜﯿﺮ ﻣﻦ اﻟﺮﻏﺒﺔ واﻟﺤﺐ ﻟﻠﺒﺮﻣﺠﺔ‪ ،‬واﻟﻠﻐﺔ ﻟﻢ‬

‫ﺗﻜﻦ ﻋﺎﺋﻘﺎ ﻓﻲ أﺧﺬ اﻟﻌﻠﻮم وﻟﻦ ﺗﻜﻮن ﻛﺬﻟﻚ ﺑﺈذن اﷲ‪ ،‬ﻟﻜﻨﮭﺎ ﻗﺪ ﺗﻜﻮن ﻣﻔﯿﺪة ﻓﻲ ﺑﻌﺾ اﻟﺠﻮاﻧﺐ‪،‬‬

‫ﻟﺬﻟﻚ اﻧﺲ ﻣﻮﺿﻮع اﻟﻠﻐﺔ اﻻﻧﺠﻠﯿﺰﯾﺔ ﻓﻨﺤﻦ ﺳﻨﺘﻌﻠﻢ اﻟﺒﺮﻣﺠﺔ وﻟﯿﺲ ﻓﻨﻮن اﻟﺘﻮاﺻﻞ ‪(:‬‬

‫أﻧﺎ ﻓﺎﺷﻞ ﻓﻲ اﻟﺮﯾﺎﺿﯿﺎت ھﻞ ذﻟﻚ ﺳﯿﻤﻨﻌﻨﻲ ﻣﻦ ﺗﻌﻠﻢ اﻟﺒﺮﻣﺠﺔ؟‬

‫اﻟﺮﯾﺎﺿﯿﺎت ھﻲ ﺟﺰء ﺑﺴﯿﻂ ﻣﻦ اﻟﺒﺮﻣﺠﺔ وﻟﯿﺴﺖ ﻛﻞ اﻟﺒﺮﻣﺠﺔ‪ ،‬وﺗﺴﺘﻄﯿﻊ أن ﺗﻜﻮن ﻣﺒﺮﻣﺠﺎ‬

‫ﻗﻮﯾﺎ ﺣﺘﻰ وإن ﻛﺎﻧﺖ ﻣﻌﺎرﻓﻚ ﻓﻲ اﻟﺮﯾﺎﺿﯿﺎت ﻣﺘﺪﻧﯿﺔ‪ ،‬ﻟﺬﻟﻚ ﻻ ﺗﺮﺗﺒﻚ وﻻ ﺗﺸﻐﻞ ﺑﺎﻟﻚ ﺑﮭﺬا‪،‬‬

‫ﻷ ﻧﻚ ﻟﻦ ﺗﺤﺘﺎج اﻟﺮﯾﺎﺿﯿﺎت إﻻ ﻓﻲ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﺴﺘﻠﺰم ﻣﻨﻚ اﻟﻘﯿﺎم ﺑﻌﻤﻠﯿﺎت رﯾﺎﺿﯿﺔ وﻋﻤﻮﻣﺎ‬

‫ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﻗﺪ ﺳﮭﻠﺖ ھﺬا اﻟﻤﺠﺎل ﺑﺸﻜﻞ راﺋﻊ‪ ،‬ﻓﻜﻞ ﻣﺎ ﺳﺘﺤﺘﺎﺟﮫ ﻓﻲ ﺑﺮاﻣﺠﻚ ﻣﻦ دوال‬

‫ﺣﺴﺎﺑﯿﺔ )ﺳﯿﻨﯿﺲ‪ ،‬ﻛﻮﺳﯿﻨﯿﺲ‪ (...،‬ﻣﻮﺟﻮدة ﻣﺴﺒﻘﺎ وﺗﻢ ﺗﺠﮭﯿﺰھﺎ ﻣﻦ ﻗﺒﻞ اﻟﻔﺮﯾﻖ اﻟﻤﻄﻮر ﻟﻠﻐﺔ‬

‫اﻟﺒﺮﻣﺠﺔ‪.‬‬

‫‪6‬‬
 





7170

7
 ‫اﻟﻔﮭﺮس‬

2 ................................................ ................................ 

5 ....................................................
5 ................................................... 
5 ........................................... 
6 ........................... 
8 ................................................................ ................................
12 ........................................................... 
13 .................... ................................................................ 
13 .................................................. 

13 ...........RAM(Random Access Memory)

14 ............................... Central Processing Unit

15 ............................................................................ Devices

15 .................................. ................................

17 ................................................... ................................ 

20 .................... ................................................................ 
20 .............................................................................Bit

21 ........................................................................... Byte

21 ...............................................
23 ............................................... 

8
23 ............................................... ................................ 

24 .............................................. ................................ 

27 .................... ................................................................ 

27 ................................
29 ................................. 
30 ............................................................................. 
32 ......................... 
33 ......................... 
33 .......................... 
35 .......................... 
36 .......................... 
36 .......................... 
38 ............................................... 
41 ...................................... 
42 ...................... ................................ 
43 .................... ................................................................ 
44 .................... ................................................................ 
45 ................................................... ................................ 
48 ......................................................... 
49 ..................................... ................................ 
49 .................................. ................................ 

9
50 .............................................. ................................ 
50 .................................... ................................  
52 ..................................... ................................ 
52 ....................................................................... Variables
54 ............................................................................ 
55 ........................................................................... 
58 ................................................... ................................ 
59 ................................................... ................................
60 .............................................. ................................ /
60 ...........................Arithmetic operators

63 ....................... String Concatenation operators

64 ........... Increment and Decrement Operators

65 .............................................. Comparison operators

67 ................................................. Logical operators

70 ................................................. ................................ 

74 ....................................................................... 
76 ....................................................................... Loops 
76 ......... ................................while 

78 ............................................ for 

81 ................................................. ................................ Arrays

85 ..................................... ................................ 

10
87 ............................................
88 .............................Copying Arrays
91 ............................................................. ................................

11






12
 ‫‪ ‬‬
‫ﺗﻌﺮﯾﻒ وﺟﯿﺰ ﻟﺠﮭﺎزاﻟﺤﺎﺳﻮب ‪ /‬اﻟﺤﺎﺳﺐ‬

‫اﻟﺤﺎﺳﻮب ھﻮ ﺟﮭﺎز اﻟﻜﺘﺮوﻧﻲ ﻣﺜﻠﮫ ﻣﺜﻞ ﺑﺎﻗﻲ اﻷﺟﮭﺰة اﻻﻟﻜﺘﺮوﻧﯿﺔ )ﺗﻠﻔﺎز‪ ،‬ھﺎﺗﻒ‪ ،‬ﺟﮭﺎز‬

‫ﺗﺴﺠﯿﻞ‪ (...،‬ﯾﺴﺘﺨﺪم ﻟﺘﺨﺰﯾﻦ وﻣﻌﺎﻟﺠﺔ اﻟﺒﯿﺎﻧﺎت‪ ،‬وھﻮ ﯾﺘﻜﻮن ﻣﻦ ﺟﺰءﯾﻦ ﻻ ﺛﺎﻟﺚ ﻟﮭﻤﺎ‪ ،‬أﺣﺪھﻤﺎ‬

‫آﻟﻲ ‪ Hardware‬وھﻮ اﻟﺠﺎﻧﺐ اﻟﻤﺎدي اﻟﺬي ﯾﻀﻢ ﻣﻜﻮﻧﺎت اﻟﺤﺎﺳﻮب اﻟﺘﻲ ﻧﺮاھﺎ وﻧﻠﻤﺴﮭﺎ‪ ،‬أﻣﺎ‬

‫اﻟﺠﺰء اﻟﺜﺎﻧﻲ ﻓﮭﻮ اﻟﺠﺰء اﻟﺒﺮﻣﺠﻲ ‪ Software‬وھﻮ اﻟﺠﺎﻧﺐ اﻟﺨﻔﻲ اﻟﻤﺴﺆول ﻋﻦ ﺗﺸﻐﯿﻞ‬

‫اﻟﺒﺮاﻣﺞ واﻷﻟﻌﺎب واﻟﻤﻠﺘﯿﻤﯿﺪﯾﺎ ﻣﻦ ﺧﻼل ﺗﺤﻜﻤﮫ ﻓﻲ اﻟﺠﺎﻧﺐ اﻵﻟﻲ ‪.Hardware‬‬

‫ﯾﺘﻜﻮن اﻟﺤﺎﺳﻮب ﻣﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻌﻨﺎﺻﺮ اﻟﻤﺎدﯾﺔ ﻧﺬﻛﺮھﺎ ﻓﯿﻤﺎ ﯾﻠﻲ أھﻤﮭﺎ‪:‬‬

‫اﻟﺬاﻛﺮة اﻟﺮﺋﯿﺴﯿﺔ أو اﻟﺤﯿﺔ )‪:RAM(Random Access Memory‬‬

‫ﯾﻤﻜﻨﻨﺎ ﺗﻌﺮﯾﻒ اﻟﺬ اﻛﺮة ﺑﺄﻧﮭﺎ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺨﺎﻧﺎت اﻟﻤﺘﺘﺎﻟﯿﺔ واﻟﻤﺮﻗﻤﺔ ﻋﺒﺮ ﻋﻨﺎوﯾﻦ‪،‬‬

‫وﻛﻞ ﺧﺎﻧﺔ ﯾﻤﻜﻨﮭﺎ أن ﺗﺤﺘﻮي ﻋﻠﻰ ﺑﯿﺎﻧﺎت‪ ،‬ﺗﺘﻢ ﻣﻌﺎﻟﺠﺘﮭﺎ ﻣﻦ ﻗﺒﻞ وﺣﺪة اﻟﻤﻌﺎﻟﺠﺔ‪ ،‬ﻛﻤﺎ‬

‫ﯾﻤﻜﻦ ﻟﻠﺬاﻛﺮة أن ﺗﻘﻮم ﺑﺘﺨﺰﯾﻦ اﻟﺒﺮاﻣﺞ )اﻟﺒﺮﻧﺎﻣﺞ ھﻮ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷواﻣﺮ اﻟﻤﺘﺴﻠﺴﻠﺔ‬

‫اﻟﺘﻲ ﯾﺘﻢ ﺗﻨﻔﯿﺬھﺎ ﻟﻠﺤﺼﻮل ﻋﻠﻰ ﻧﺘﯿﺠﺔ ﻣﻌﯿﻨﺔ(‪ ،‬وﯾﺘﻢ ﺗﻤﺜﯿﻞ اﻟﺒﯿﺎﻧﺎت ﻓﻲ اﻟﺬاﻛﺮة ﻋﻠﻰ‬

‫ﺷﻜﻞ ﺛﻨﺎﺋﻲ ﻋﺒﺮ ﻣﺘﺘﺎﻟﯿﺎت ﻣﻦ اﻷﺻﻔﺎر واﻵﺣﺎد ﻛﻤﺎ ﺳﻨﺮى ﻓﯿﻤﺎ ﺑﻌﺪ‪.‬‬

‫ﻛﻞ ﺧﺎﻧﺔ ﻓﻲ اﻟﺬاﻛﺮة ﻣﺮﻗﻤﺔ ﻟﻜﻲ ﯾﺴﮭﻞ اﻟﻮﺻﻮل إﻟﻰ ﻣﺤﺘﻮاھﺎ ﻣﻦ ﻗﺒﻞ وﺣﺪة اﻟﻤﻌﺎﻟﺠﺔ‪،‬‬

‫وﯾﺴﻤﻰ ھﺬا اﻟﺘﺮﻗﯿﻢ ﺑﺎﻟﻌﻨﻮﻧﺔ‪ ،‬أي أن ﻛﻞ ﺧﺎﻧﺔ ﻟﮭﺎ ﻋﻨﻮاﻧﮭﺎ اﻟﺨﺎص ‪.Address‬‬

‫وﯾﻤﻜﻨﻨﺎ ﺗﻤﺜﯿﻞ اﻟﺬاﻛﺮة اﻟﺮﺋﯿﺴﯿﺔ ﺑﮭﺬا اﻟﺸﻜﻞ‪:‬‬

‫‪13‬‬
 ‫اﻟﺸﻜﻞ ‪ 1‬اﻟﺘﻤﺜﯿﻞ اﻻﺻﻄﻼﺣﻲ ﻟﻠﺬاﻛﺮة اﻟﺮﺋﯿﺴﯿﺔ‬

‫وﺣﺪة ﻣﻌﺎﻟﺠﺔ اﻟﺒﯿﺎﻧﺎت ‪:Central Processing Unit‬‬

‫وھﻮ اﻟﺠﺰء اﻟﻤﮭﻢ ﻓﻲ اﻟﺤﺎﺳﻮب‪ ،‬وﯾﻌﺪ ﺑﻤﺜﺎﺑﺔ اﻟﺪﻣﺎغ اﻟﻤﺴﺆول ﻋﻦ ﺗﻨﻔﯿﺬ ﻛﻞ ﻋﻤﻠﯿﺎت‬

‫ﻣﻌﺎﻟﺠﺔ اﻟﺒﯿﺎﻧﺎت اﻟﻤﺨﺰﻧﺔ ﻓﻲ اﻟﺬاﻛﺮة‪.‬‬

‫وﯾﻘﻮم ﺑﻜﻞ اﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ )اﻟﺠﻤﻊ‪ ،‬اﻟﻄﺮح‪ ،‬اﻟﻀﺮب‪ ،‬اﻟﻘﺴﻤﺔ( وﯾﻘﻮم أﯾﻀﺎ‬

‫ﺑﺎﻟﻌﻤﻠﯿﺎت اﻟﻤﻨﻄﻘﯿﺔ ﻣﺜﻞ ﻣﻘﺎرﻧﺔ اﻟﺒﯿﺎﻧﺎت‪.‬‬

‫ﺗﻘﻮم وﺣﺪة اﻟﻤﻌﺎﻟﺠﺔ ﺑﺄﺧﺬ اﻷواﻣﺮ اﻟﻤﺨﺰﻧﺔ ﻓﻲ اﻟﺬاﻛﺮة ﻋﻠﻰ ﺷﻜﻞ ﺑﯿﺎﻧﺎت‪ ،‬وﺗﺒﺪأ ﻓﻲ‬

‫ﺗﻨﻔﯿﺬھﺎ ﺑﺪء ﻣﻦ أول أﻣﺮ واﻧﺘﮭﺎء ﺑﺂﺧﺮ أﻣﺮ وﺗﻘﻮم ﺑﺈﺟﺮاء اﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ واﻟﻤﻨﻄﻘﯿﺔ‬

‫اﻟﻮاردة ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻤﺨﺰن‪ ،‬وﻛﻠﻤﺎ اﻗﺘﻀﻰ اﻷﻣﺮ ﺗﻘﻮم ﺑﺘﺨﺰﯾﻦ اﻟﻨﺎﺗﺞ ﻓﻲ اﻟﺬاﻛﺮة‬

‫ﻟﺘﺴﺘﻌﻤﻠﮫ ﻣﻊ أواﻣﺮ أﺧﺮى‪ ،‬وﻓﻲ ﺧﺘﺎم ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺗﻘﻮم وﺣﺪة اﻟﻤﻌﺎﻟﺠﺔ ﺑﺈرﺳﺎل‬

‫اﻟﻨﺘﯿﺠﺔ إﻟﻰ اﻟﺠﮭﺎز اﻟﺨﺎص ﺑﻌﺮﺿﮭﺎ )ﻣﺜﻼ ﻃﺒﺎﻋﺔ ﻧﺘﯿﺠﺔ ﻋﻤﻠﯿﺔ ﺣﺴﺎﺑﯿﺔ ﻓﻲ ﻧﺎﻓﺬة‬

‫اﻟﻜﻮﻧﺴﻮل‪ ،‬ﺳﺘﻘﻮم وﺣﺪة اﻟﻤﻌﺎﻟﺠﺔ ﺑﺈرﺳﺎل اﻟﻨﺘﯿﺠﺔ إﻟﻰ اﻟﺸﺎﺷﺔ(‬

‫‪14‬‬
 ‫اﻷﺟﮭﺰة ‪:Devices‬‬

‫وھﻲ ﻛﻞ اﻷﺟﮭﺰة اﻟﻤﻮﺻﻮﻟﺔ ﺑﺎﻟﺤﺎﺳﻮب وھﻨﺎك ﻣﻦ ﯾﻘﺴﻤﮭﺎ إﻟﻰ أﺟﮭﺰة اﻹدﺧﺎل‬

‫‪ :‬ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﯿﺢ‪ ،‬ﺳﻜﺎﻧﺮ‪ ،‬ﻗﺎرىء اﻷﻗﺮاص‪...،‬إﻟﺦ‪ .‬وأﺟﮭﺰة‬ ‫‪Input devices‬‬

‫إﺧﺮاج ‪ :Output Devices‬اﻟﺸﺎﺷﺔ‪ ،‬اﻟﻄﺎﺑﻌﺔ‪ ،‬ﻣﻜﺒﺮات اﻟﺼﻮت‪...،‬إﻟﺦ‪ .‬وأﺟﮭﺰة‬

‫اﻟﺘﺨﺰﯾﻦ ‪ :Storage Devices‬أﻗﺮاص ﺻﻠﺒﺔ‪ ،‬ﻣﻔﺎﺗﯿﺢ اﻟﯿﻮ أس ﺑﻲ‪ ،‬اﻷﻗﺮاص‪،‬‬

‫اﻟﺪﯾﺴﻜﯿﺖ‪... ،‬إﻟﺦ‪.‬‬

‫اﻟﻠﻐﺔ اﻟﺘﻲ ﯾﻔﮭﻤﮭﺎ اﻟﺤﺎﺳﻮب‬

‫رﻏﻢ ﻋﻈﻢ اﻟﻤﮭﺎم واﻟﻌﻤﻠﯿﺎت اﻟﺘﻲ ﯾﻘﻮم ﺑﮭﺎ اﻟﺤﺎﺳﻮب‪ ،‬إﻻ أﻧﮫ ﻟﯿﺲ ذو ذﻛﺎء ﺧﺎرق ﻗﯿﺎﺳﺎ ﻣﻊ‬

‫اﻟﻌﻘﻞ اﻟﺒﺸﺮي‪ ،‬ﻓﮭﻮ ﻻ ﯾﻔﮭﻢ ﺳﻮى رﻗﻤﯿﻦ ‪ 0‬و ‪) 1‬وھﺬا ﺗﻘﺪﯾﺮ اﺻﻄﻼﺣﻲ ﻓﻘﻂ ﻻ ﻋﻼﻗﺔ ﻟﮫ ﺑﻤﺎ‬

‫ﯾﺘﻢ ﻓﯿﺰﯾﺎﺋﯿﺎ ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﺤﺎﺳﻮب(‪ ،‬ﻛﻞ اﻟﺒﯿﺎﻧﺎت ﺳﻮاء ﻛﺎﻧﺖ ﻋﺒﺎرة ﻋﻦ ﻓﯿﺪﯾﻮ‪ ،‬ﺻﻮرة‪،‬‬

‫ﺻﻮت‪ ،‬أو أي ﻣﻠﻒ آﺧﺮ‪ ،‬ﻓﺈن اﻟﺤﺎﺳﻮب ﻻ ﯾﺮاھﺎ ﺳﻮى ﻋﻠﻰ ﺷﻜﻞ ﺳﻼﺳﻞ ﻣﻦ اﻷﺻﻔﺎر‬

‫واﻵﺣﺎد اﻟﻤﺨﺰﻧﺔ ﻓﻲ اﻟﺬاﻛﺮة واﻟﺘﻲ ﺗﺘﻢ ﻣﻌﺎﻟﺠﺘﮭﺎ وﻗﺮاءﺗﮭﺎ ﺑﻮاﺳﻄﺔ وﺣﺪة اﻟﻤﻌﺎﻟﺠﺔ‪ ،‬ﻟﻜﻲ‬

‫ﺗﺘﺮﺟﻢ إﻟﻰ اﻟﺸﻜﻞ اﻟﺬي ﻧﺮاھﺎ ﻋﻠﯿﮫ‪.‬‬

‫أﺻﻔﺎر وآﺣﺎد ھﻲ ﻟﻐﺔ اﻟﺤﺎﺳﻮب‪ ،‬وﻷﻧﮭﻤﺎ إﺛﻨﺎن "‪ "2‬ﺳﻤﯿﺖ ھﺬه اﻟﻠﻐﺔ ب "اﻟﻠﻐﺔ اﻟﺜﻨﺎﺋﯿﺔ‬

‫‪ ،"Binary Language‬رﻏﻤﺎ أن ھﺬه اﻟﺘﺴﻤﯿﺔ ﻓﻲ اﻟﻤﻌﻠﻮﻣﯿﺎت اﻟﻐﺮض اﻟﻮﺣﯿﺪ ﻣﻨﮭﺎ ھﻮ ﺗﺒﯿﺎن‬

‫أن اﻟﺤﺎﺳﻮب ﯾﻔﮭﻢ ﻗﯿﻤﺘﯿﻦ ﻣﺘﻌﺎرﺿﺘﯿﻦ ﻓﻘﻂ‪ ،‬وﺗﻢ اﺳﺘﺨﺪام اﻷرﻗﺎم ‪ 0‬و ‪ 1‬دﻻﻟﺔ ﻋﻠﻰ ذﻟﻚ‪،‬‬

‫واﻷﺻﻞ أن اﻟﻤﺴﺄﻟﺔ اﻟﻜﺘﺮوﻧﯿﺔ‪ ،‬ﺗﻨﺒﻨﻲ ﻋﻠﻰ اﻟﺘﯿﺎر اﻟﻤﺘﺪﻓﻖ‪ ،‬واﻟﻤﻌﻠﻮﻣﺎت ھﻲ ﺗﺴﻠﺴﻞ ﻟﺤﺎﻟﺔ‬

‫اﻟﺘﯿﺎر‪ ،‬ﻟﺬﻟﻚ ﺗﺠﺪ اﻟﺒﻌﺾ ﯾﻤﺜﻞ اﻟﻠﻐﺔ اﻟﺜﻨﺎﺋﯿﺔ ﺑﺎﻟﻌﺒﺎرة اﻟﺘﺎﻟﯿﺔ "ﺗﯿﺎر ﯾﻤﺮ‪ ،‬ﺗﯿﺎر ﻻ ﯾﻤﺮ" ﻛﻨﺎﯾﺔ ﻋﻠﻰ‬

‫ﻃﺒﯿﻌﺔ اﻟﺒﯿﺎﻧﺎت اﻟﺘﻲ ﯾﻔﮭﻤﮭﺎ اﻟﺤﺎﺳﻮب‪ .‬ھﺬا ﻣﺎ ﯾﻘﻊ ﻓﯿﺰﯾﺎﺋﯿﺎ‪ ،‬ﻟﻜﻦ ﻟﻔﮭﻢ ھﺬه اﻟﻤﺴﺎﺋﻞ ﺗﻘﻨﯿﺎ‪ ،‬ﯾﺘﻢ‬

‫اﺳﺘﺨﺪام اﻟﺜﻨﺎﺋﻲ ‪ 0‬و ‪ 1‬ﻟﺘﻤﺜﯿﻞ اﻟﺒﯿﺎﻧﺎت‪.‬‬

‫‪15‬‬
‫ﺗﺠﺮﻳﺪي‬ ‫ﻫﻮ‬ ‫اﻟﺒﻴﺎﻧﺎت اﻟﺘﻲ ﻳﻔﻬﻤﻬﺎ اﻟﺤﺎﺳﻮب ﻋﱪ اﻟﱰﻣﻴﺰ‬
‫اﻟﺘﻲ ﻳﻔﻬﻤﻬﺎ اﻟﺤﺎﺳﻮب ﺑﺼﻔﺘﻪ ﺟﻬﺎزا‬ ‫واﺻﻄﻼﺣﻲ ﻳﺪل ﻋﲆ‬
‫اﺳﺘﻨﺎدا ﻋﲆ‬ ‫اﻟﻜﱰوﻧﻴﺎ )دارة ﻣﻔﺘﻮﺣﺔ‪ ،‬دارة ﻣﻐﻠﻘﺔ(‪ ،‬وﻧﺴﺘﺨﺪم اﻟﺘﻤﺜﻴﻞ‬
‫‪ ،Binary encoding‬ﻋﲆ ﻏﺮار اﻟﱰﻣﻴﺰ‬ ‫‪ 0‬و ‪ 1‬وﻳﺴﻤﻰ ﺑﺎﻟﱰﻣﻴﺰ‬
‫اﻟﻌﴩي ‪ Decimal encoding‬اﻟﺬي ﻳﺴﺘﺨﺪﻣﻪ اﻹﻧﺴﺎن )اﻷﻋﺪاد اﻟﻌﴩة‬
‫اﻟﻘﻮل‪ :‬ﺑﺄن‬ ‫اﳌﻌﺮوﻓﺔ ﻣﻦ ‪ 0‬إﱃ ‪ (9‬ﻟﺘﻤﺜﻴﻞ اﳌﻌﻠﻮﻣﺎت‪ ،‬وﺑﻌﻴﺪا ﻋﻦ اﻟﻔﻴﺰﻳﺎء‬
‫اﻟﺤﺎﺳﻮب ﻻ ﻳﻔﻬﻢ ﺳﻮى اﻷﺻﻔﺎر واﻵﺣﺎد ﻟﺘﻤﺜﻴﻞ اﻟﺒﻴﺎﻧﺎت‪.‬‬

‫‪ ‬‬
‫‪ ‬‬
‫‪ ‬‬
‫‪ ‬‬

‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ ‬‬

‫‪16‬‬
 ‫‪‬‬
‫وھﻮ اﻟﺘﺮﻣﯿﺰ اﻟﻤﺘﻌﺎرف ﻋﻠﯿﮫ ﻋﻨﺪﻧﺎ ﻧﺤﻦ اﻟﺒﺸﺮ‪ ،‬واﻟﺬي ﯾﻘﻮم ﻋﻠﻰ اﻷﻋﺪاد اﻟﻌﺸﺮة اﻟﻤﻌﺮوﻓﺔ‪،‬‬

‫اﻟﺘﻲ ﺗﺒﺪأ ﺑﺼﻔﺮ وﺗﻨﺘﮭﻲ ﺑﺘﺴﻌﺔ )‪ (9 ،8 ،7 ،6 ،5 ،4 ،3 ،2 ،1 ،0‬وﯾﺘﻢ اﻟﺪﻣﺞ ﺑﯿﻦ ھﺬه‬

‫اﻷﻋﺪاد ﻟﻠﺤﺼﻮل ﻋﻠﻰ ﻗﯿﻤﺔ رﻗﻤﯿﺔ ﻟﮭﺎ دﻻﻟﺘﮭﺎ‪ ،‬وھﻮ أﯾﻀﺎ ﺗﺮﻣﯿﺰ اﺻﻄﻼﺣﻲ وﺗﺠﺮﯾﺪي‪ ،‬اﺗﻔﻖ‬

‫ﻋﻠﯿﮫ اﻟﺒﺸﺮ ﻟﺘﻤﺜﯿﻞ اﻷﺷﯿﺎء ﻋﺪدﯾﺎ‪ ،‬ﻓﻠﻮ أﺗﯿﻨﺎ ﺑﺮﺟﻞ ﻣﻦ ﻋﺼﻮر ﻣﺎ ﻗﺒﻞ اﺧﺘﺮاع اﻷﻋﺪاد‪ ،‬وﻗﻠﻨﺎ‬

‫ﻟﮫ‪ ،3 :‬ﻓﻠﻦ ﯾﻌﻲ ﻣﺎﻟﺬي ﻧﻘﺼﺪه ﺑﻘﻮﻟﻨﺎ ھﺬا‪ ،‬ﻟﻜﻦ إن ﻗﺪﻣﻨﺎ إﻟﯿﮫ ﺛﻼث ﺗﻔﺎﺣﺎت‪ ،‬ﺳﯿﻌﺮف أن ﻋﺪدھﺎ‬

‫ﻣﺨﺘﻠﻒ ﻋﻦ ﺗﻔﺎﺣﺘﯿﻦ‪ ،‬ﻓﺎﻟﺘﺮﻣﯿﺰ ھﻮ ﺗﺠﺮﯾﺪي ﻓﻘﻂ ﻟﺘﺴﮭﯿﻞ ﺗﻤﺜﯿﻞ اﻷﺷﯿﺎء ﻋﺪدﯾﺎ‪.‬‬

‫وﯾﺴﻤﻰ ھﺬا اﻟﻨﻮع ﻣﻦ اﻟﺘﺮﻣﯿﺰ ﺑﺎﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي أو اﻟﺘﻤﺜﯿﻞ اﻟﻌﺸﺮي أو اﻟﻨﻈﺎم اﻟﻌﺸﺮي‪ ،‬ﻷﻧﮫ‬

‫ﯾﺴﺘﺨﺪم اﻟﺮﻗﻢ ‪ 10‬ﻟﺘﺒﺴﯿﻂ وﺗﻔﻜﯿﻚ اﻷﻋﺪاد‪ ،‬ﻓﻤﺜﻼ ﻟﻮ أﺧﺬﻧﺎ اﻟﺮﻗﻢ اﻟﺘﺎﻟﻲ‪ ،2897 :‬ﻓﮭﻮ ﯾﺘﻜﻮن ﻣﻦ‬

‫اﻷﺟﺰاء اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫‪2‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪7‬‬

‫اﻵﻻف‬ ‫اﳌﺌﺎت‬ ‫اﻟﻌﴩات‬ ‫اﻟﻮﺣﺪات‬

‫اﻟﺮﻗﻢ ‪ 2‬ﯾﻤﺜﻞ اﻟﺠﺰء اﻟﺨﺎص ﺑﺎﻵﻻف‪ ،‬وﻛﻤﺎ ھﻮ ﻣﻌﻠﻮم ﻓﺎﻷﻟﻒ اﻟﻮاﺣﺪ ﯾﻀﻢ ﻋﺸﺮ ﻣﺌﺎت‪ ،‬أي‬

‫أن‪:‬‬

‫‪1000 = 10 * 100‬‬
‫‪2 * 1000 = 2 * 10 * 100‬‬
‫‪2000 = 2 * 1000‬‬

‫اﻟﺮﻗﻢ ‪ 8‬ﯾﻤﺜﻞ اﻟﺠﺰء اﻟﺨﺎص ﺑﺎﻟﻤﺌﺎت‪ ،‬واﻟﻤﺌﺔ اﻟﻮاﺣﺪة ﺗﺤﺘﻮي ﻋﻠﻰ ﻋﺸﺮ ﻋﺸﺮات‪ ،‬أي أن‪:‬‬

‫‪17‬‬
 ‫‪100 = 10 * 10‬‬

‫‪8 * 100 = 8 * 10 * 10‬‬

‫‪800 = 8 * 100‬‬

‫اﻟﺮﻗﻢ ‪ 9‬ﯾﻤﺜﻞ اﻟﺠﺰء اﻟﺨﺎص ﺑﺎﻟﻌﺸﺮات‪ ،‬واﻟﻌﺸﺮة اﻟﻮاﺣﺪة ﺗﻀﻢ ﻋﺸﺮ وﺣﺪات‪ ،‬أي أن‪:‬‬

‫‪10 = 10 * 1‬‬

‫‪9 * 10 = 9 * 10 * 1‬‬

‫‪90 = 9 * 10‬‬

‫اﻟﺮﻗﻢ ‪ 7‬ﯾﻤﺜﻞ اﻟﻮﺣﺪات‪ ،‬واﻟﻮﺣﺪة ھﻲ أﺻﻐﺮ ﺟﺰء ﻓﻲ اﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي‪ ،‬وﻻ ﺗﺤﺘﻮي إﻻ ﻋﻠﻰ‬

‫ﻧﻔﺴﮭﺎ‪ ،‬أي أن‪:‬‬

‫‪1=1*1‬‬

‫‪7*1=7*1*1‬‬

‫‪7=7*1‬‬

‫ﺑﺎﻻﻋﺘﻤﺎد ﻋﻠﻰ اﻟﺘﻘﺴﯿﻢ اﻟﺮﯾﺎﺿﻲ أﻋﻼه‪ ،‬ﻓﺈن اﻟﻌﺪد ‪ 2897‬ﯾﺴﺎوي‪:‬‬

‫)‪2897 = (2 * 1000) + (8 * 100) + (9 * 10) + (7 * 1‬‬

‫اﻵن ﺳﻨﺤﻮﻟﮫ إﻟﻰ اﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي ﺑﻜﻞ ﺑﺴﺎﻃﺔ‪:‬‬

‫‪2897 = (2 * 10 * 10 * 10) + (8 * 10 * 10) + (9 * 10) + 7‬‬

‫‪18‬‬
 ‫وﻓﻲ اﻟﺮﯾﺎﺿﯿﺎت ﯾﺘﻢ ﺗﻠﺨﯿﺺ اﻟﺴﻄﺮ أﻋﻼه ﻋﺒﺮ اﺳﺘﻌﻤﺎل اﻟﻘﻮى ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬

‫)‪2897 = (2 * 103) + (8 * 102) + (9 * 101) + (7 * 100‬‬

‫ﻣﻊ اﻟﻌﻠﻢ أن‪:‬‬

‫‪103‬‬ ‫‪10*10*10=1000‬‬
‫‪102‬‬ ‫‪10*10=100‬‬
‫‪101‬‬ ‫‪10‬‬
‫‪100‬‬ ‫‪1‬‬

‫‪19‬‬
 ‫‪‬‬
‫ﻣﻔﮭﻮم اﻟﻮﺣﺪة ‪Bit‬‬

‫اﻟﻮﺣﺪة ‪ Bit‬ھﻲ أﺻﻐﺮ وﺣﺪة ﻟﻘﯿﺎس اﻟﺒﯿﺎﻧﺎت اﻟﻤﻤﻤﺜﻠﺔ ﻓﻲ اﻟﺘﺮﻣﯿﺰ اﻟﺜﻨﺎﺋﻲ اﻟﻤﻔﮭﻮم ﻣﻦ ﻃﺮف‬

‫اﻟﺤﺎﺳﻮب‪ ،‬وھﻲ إﻣﺎ ‪ 0‬أ و ‪.1‬‬

‫‪ .1‬وﺣﺪة واﺣﺪة ﺗﻄﺮح أﻣﺎﻣﻨﺎ اﺣﺘﻤﺎﻟﯿﻦ وھﻤﺎ‪ :‬ﺻﻔﺮ أو واﺣﺪ )‪(0 or 1‬‬

‫‪ .2‬وﺣﺪﺗﺎن ﺗﻄﺮﺣﺎن أﻣﺎﻣﻨﺎ أرﺑﻊ اﺣﺘﻤﺎﻻت ‪ 22‬وھﻢ‪ :‬ﺻﻔﺮ و ﺻﻔﺮ )‪ ،(0 and 0‬ﺻﻔﺮ‬

‫وواﺣﺪ )‪ ،(0 and 1‬واﺣﺪ وﺻﻔﺮ )‪ ،(1 and 0‬واﺣﺪ وواﺣﺪ )‪(1 and 1‬‬

‫‪ .3‬أرﺑﻊ وﺣﺪات ﺗﻄﺮح أﻣﺎﻣﻨﺎ اﺣﺘﻤﺎل ﺑﺎﻟﻌﺪد اﻟﺘﺎﻟﻲ‪ (2*2*2*2) 24 :‬أي ‪ 16‬اﺣﺘﻤﺎل‪:‬‬

‫‪0000‬‬ ‫‪0001‬‬ ‫‪0010‬‬ ‫‪0011‬‬

‫‪0100‬‬ ‫‪0101‬‬ ‫‪0110‬‬ ‫‪0111‬‬
‫‪1000‬‬ ‫‪1001‬‬ ‫‪1010‬‬ ‫‪1011‬‬
‫‪1100‬‬ ‫‪1101‬‬ ‫‪1110‬‬ ‫‪1111‬‬

‫ﺛﻤﺎﻧﻲ وﺣﺪات ﺗﺸﻜﻞ ﻣﺎ ﯾﺴﻤﻰ ﺑﺎﻟﺒﺎﯾﺖ ‪ ،Byte‬أي أن ‪ ،1 Byte = 8 Bits‬وھﺬا اﻟﻌﺪد ﻣﻦ‬

‫اﻟﻮﺣﺪات ﯾﻌﻄﯿﻨﺎ ‪ 28‬اﺣﺘﻤﺎل‪ ،‬أي ‪ 256‬اﺣﺘﻤﺎل ﻣﻤﻜﻦ‪.‬‬

‫وﯾﻤﻜﻦ أن ﻧﻠﺨﺺ ﻣﺎ ﺳﺒﻖ ﻓﻲ اﻟﻌﻼﻗﺔ اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫‪ 2N‬اﺣﺘﻤﺎل ﻣﻤﻜﻦ‪.‬‬ ‫‪ N‬وﺣﺪة )‪(bit‬‬

‫‪20‬‬
 ‫ﻣﻔﮭﻮم اﻟﺒﺎﯾﺖ ‪Byte‬‬

‫اﻟﺒﺎﯾﺖ ﻛﻤﺎ رأﯾﻨﺎ ﻗﺒﻞ ﻗﻠﯿﻞ‪ ،‬ھﻮ وﺣﺪة ﻟﻘﯿﺎس اﻟﺒﯿﺎﻧﺎت وھﻮ ﯾﺘﻜﻮن ﻣﻦ ﺛﻤﺎﻧﻲ وﺣﺪات‪ ،‬ﻟﺬﻟﻚ ﻗﺪ‬

‫ﺗﺴﻤﻊ ﺑﺎﻟﻜﯿﻠﻮ ﺑﺎﯾﺖ ﻓﻲ ﻗﯿﺎس ﺣﺠﻢ اﻟﻤﻠﻔﺎت واﻟﻤﯿﻐﺎ ﺑﺎﯾﺖ‪ ،‬واﻟﺠﯿﻐﺎ ﺑﺎﯾﺖ‪ ،‬وﺑﺎﺳﺘﺨﺪام اﻟﻌﻼﻗﺔ‬

‫اﻟﺘﻲ ﻛﺘﺒﻨﺎھﺎ أﻋﻼه ﻓﺈﻧﻚ ﺗﺴﺘﻄﯿﻊ اﻟﺘﺤﻮﯾﻞ ﺑﯿﻦ اﻟﻮﺣﺪات ﺑﻜﻞ ﺳﮭﻮﻟﺔ ﺑﺎﻻﻋﺘﻤﺎد ﻋﻠﻰ اﻟﺠﺪول‬

‫اﻟﺘﺎﻟﻲ‪:‬‬

‫‪1 KiloByte (KB) = 210 Byte = 1024 Byte‬‬

‫‪1 MegaByte (MB) = 210 KiloByte = 1024 KiloByte‬‬

‫‪1 GegaByte (GB) = 210 MegaByte = 1024 MegaByte‬‬

‫‪1 TeraByte (GB) = 210 GegaByte = 1024 GegaByte‬‬

‫‪‬‬
‫إذن ﻓﺎﻟﺘﺮﻣﯿﺰ اﻟﺜﻨﺎﺋﻲ ﯾﻘﻮم ﻋﻠﻰ اﻟﻘﺎﻋﺪة ‪ ،2‬وﯾﺘﻢ ﺗﻤﺜﯿﻠﮫ داﺋﻤﺎ ﺑﺎﻻﻋﺘﻤﺎد ﻋﻠﻰ اﻟﻘﻮى اﻟﻤﺘﻌﻠﻘﺔ‬

‫ﺑﺎﻟﺮﻗﻢ ‪ ،2‬ﻓﻠﻮ اﻓﺘﺮﺿﻨﺎ أن ﻋﻨﺪﻧﺎ اﻟﺒﺎﯾﺖ اﻟﺘﺎﻟﻲ‪10110010 :‬‬

‫إذا أردﻧﺎ ﻛﺘﺎﺑﺔ ھﺬا اﻟﺒﺎﯾﺖ ﺑﺎﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي ﻓﺈﻧﮫ ﻋﻠﯿﻨﺎ اﻟﻨﻈﺮ إﻟﻰ ﻋﺪد اﻟﻮﺣﺪات اﻟﻤﻜﻮﻧﺔ ﻟﻠﺒﺎﯾﺖ‬

‫وﻧﻨﻘﺺ ﻣﻨﮫ واﺣﺪا‪ ،‬وﻧﺠﻌﻠﮫ أﺳﺎ ﻟﻸﺳﺎس ‪ 2‬وﻧﻀﺮﺑﮫ ﻓﻲ أول وﺣﺪة اﺑﺘﺪاء ﻣﻦ اﻟﺸﻤﺎل‪ ،‬وﻛﻠﻤﺎ‬

‫اﻧﺘﻘﻠﻨﺎ إﻟﻰ وﺣﺪة أﺧﺮى ﻧﻘﺼﻨﺎ ﻗﯿﻤﺔ اﻷس ﺑﻮاﺣﺪ‪ ،‬أي أن اﻟﺒﺎﯾﺖ أﻋﻼه ﯾﺘﻢ ﺗﺤﻮﯾﻠﮫ إﻟﻰ اﻟﺘﺮﻣﯿﺰ‬

‫اﻟﻌﺸﺮي ﺑﺎﻟﻄﺮﯾﻘﺔ اﻵﺗﯿﺔ‪:‬‬

‫‪21‬‬
‫)‪10110010 = (1 * 27)+(0 * 26)+(1 * 25)+(1 * 24)+(0 * 23)+(0 * 22)+(1 * 21)+(0 * 20‬‬
‫أي أن‪:‬‬
‫)‪10110010 = (1 * 128)+(0 * 64)+(1 * 32)+(1 * 16)+(0 * 8)+(0 * 4)+(1 * 2)+(0 * 1‬‬
‫أي أن‪:‬‬
‫)‪10110010 = (128)+(0)+( 32)+( 16)+(0)+(0)+( 2)+(0‬‬
‫أي أن‪:‬‬
‫‪10110010 = 178‬‬

‫ﻟﺘﻮﺿﯿﺢ ﺗﺮﻣﯿﺰ ﻛﻞ ﻗﯿﻤﺔ ﻧﻜﺘﺒﮭﺎ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬

‫‪(10110010)8 = (178)10‬‬

‫وﻟﺘﺪﻋﯿﻢ اﻟﺸﺮح ﺑﻤﺜﺎل آﺧﺮ‪ ،‬ﺳﻨﺄﺧﺬ اﻟﻤﺘﺘﺎﻟﯿﺔ اﻟﺜﻨﺎﺋﯿﺔ اﻟﺘﺎﻟﯿﺔ اﻟﻤﺘﻜﻮﻧﺔ ﻣﻦ ﺳﺖ وﺣﺪات ﻓﻘﻂ‬

‫‪ ،101010‬وﺳﻨﻘﻮم ﺑﺘﺤﻮﯾﻠﮭﺎ إﻟﻰ اﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي ﺑﻨﻔﺲ اﻟﻄﺮﯾﻘﺔ اﻟﺴﺎﺑﻘﺔ‪:‬‬

‫)‪(101010)2 = (1 * 25)+(0 * 24)+(1 * 23)+(0 * 22)+(1 * 21)+(0 * 20‬‬

‫)‪(101010)2 = (32)+(0)+(8)+(0)+(2)+(0‬‬
‫‪(101010)2 = (42)10‬‬

‫‪22‬‬
 ‫‪‬‬
‫اﻟﻄﺮﯾﻘﺔ اﻷوﻟﻰ‪:‬‬

‫ﻟﺘﺤﻮﯾﻞ اﻟﺒﯿﺎﻧﺎت اﻟﻌﺸﺮﯾﺔ إﻟﻰ ﺑﯿﺎﻧﺎت ﺛﻨﺎﺋﯿﺔ ﺗﻮﺟﺪ ﻃﺮق ﻛﺜﯿﺮة‪ ،‬أﺑﺮزھﺎ ﻋﻤﻠﯿﺔ ﻗﺴﻤﺔ اﻟﻌﺪد ﻓﻲ‬

‫اﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي ﻋﻠﻰ اﻟﻌﺪد ‪ 2‬ﺑﺎﻟﻄﺮﯾﻘﺔ اﻟﺘﺎﻟﯿﺔ‪.‬‬

‫ﻟﻨﻔﺮض أن ﻋﻨﺪﻧﺎ اﻟﻌﺪد اﻟﻌﺸﺮي ‪ 423‬وﻧﺮﯾﺪ ﺗﺤﻮﯾﻠﮫ إﻟﻰ ﻗﯿﻤﺔ ﺛﻨﺎﺋﯿﺔ‪:‬‬

‫‪423‬‬ ‫‪2‬‬
‫‪1‬‬ ‫‪21‬‬ ‫‪2‬‬
‫‪11‬‬ ‫‪10‬‬ ‫‪2‬‬
‫‪51‬‬ ‫‪52‬‬ ‫‪2‬‬
‫‪0‬‬ ‫‪26‬‬ ‫‪2‬‬
‫‪0‬‬ ‫‪13‬‬ ‫‪2‬‬
‫‪1‬‬ ‫‪6‬‬ ‫‪2‬‬
‫‪0‬‬ ‫‪3‬‬ ‫‪2‬‬
‫‪1‬‬ ‫‪2‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬

‫ﻣﺴﺎر ﻗﺮاءة اﻟﻮﺣﺪات‬

‫ﺑﻌﺪ أن ﻧﻨﺘﮭﻲ ﻣﻦ ﻋﻤﻠﯿﺔ اﻟﻘﺴﻤﺔ وﯾﻜﻮن اﻟﺤﺎﺻﻞ ھﻮ ﺻﻔﺮ‪ ،‬ﻧﻘﻮم ﺑﺘﺠﻤﯿﻊ اﻟﻮﺣﺪات اﻟﻤﺤﺼﻮل‬

‫ﻋﻠﯿﮭﺎ وﻧﻘﺮأھﺎ ﻣﻦ اﻷﺧﯿﺮ ﻛﻤﺎ ﯾﻌﺮض اﻟﺴﮭﻢ أﻋﻼه ﻟﻜﻲ ﻧﺤﺼﻞ ﻋﻠﻰ اﻟﻘﯿﻤﺔ اﻟﺜﻨﺎﺋﯿﺔ اﻟﻤﺮادﻓﺔ‬

‫ﻟﻠﻌﺪد اﻟﻌﺸﺮي‪ ،‬وﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺣﺼﻠﻨﺎ ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫‪(423) 10 = (110100111) 2‬‬

‫‪23‬‬
‫وھﺬا ﻣﺜﺎل آﺧﺮ ﻟﻜﻲ ﻧﻔﮭﻢ ﻛﯿﻔﯿﺔ ﺗﺤﻮﯾﻞ اﻟﻌﺪد ﻓﻲ اﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي إﻟﻰ ﻋﺪد ﻓﻲ اﻟﺘﺮﻣﯿﺰ اﻟﺜﻨﺎﺋﻲ‬

‫ﻋﺒﺮ ﻋﻤﻠﯿﺔ اﻟﻘﺴﻤﺔ‪:‬‬

‫‪57‬‬ ‫‪2‬‬
‫‪1‬‬ ‫‪28‬‬ ‫‪2‬‬
‫‪0‬‬ ‫‪14‬‬ ‫‪2‬‬
‫‪0‬‬ ‫‪7‬‬ ‫‪2‬‬
‫‪1‬‬ ‫‪3‬‬ ‫‪2‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪2‬‬
‫‪1‬‬ ‫‪0‬‬

‫أي أن اﻟﻨﺘﯿﺠﺔ ﻛﻤﺎ ﯾﻠﻲ‪:‬‬

‫‪(57)10 = (111001)2‬‬

‫اﻟﻄﺮﯾﻘﺔ اﻟﺜﺎﻧﯿﺔ‪:‬‬

‫أﻣﺎ إن ﻛﺎﻧﺖ ﻋﻨﺪك دراﯾﺔ ﺑﺎﻟﺤﺴﺎب‪ ،‬ﻓﮭﻨﺎﻟﻚ ﻃﺮﯾﻘﺔ أﺧﺮى أﺳﮭﻞ ﻣﻦ اﻟﻘﺴﻤﺔ‪ ،‬وﺗﻜﻮن ﻋﺒﺮ أﺧﺬ‬

‫أﻛﺒﺮ ﻗﯿﻤﺔ ﻣﻦ اﻟﻌﺪد ﻓﻲ اﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي ﺷﺮﯾﻄﺔ أن ﯾﻜﻮن أﺳﮭﺎ ھﻮ ‪ ،2‬وﻧﻄﺮﺣﮭﺎ ﻣﻦ اﻟﻌﺪد‪،‬‬

‫وﻧﺄﺧﺬ اﻟﺒﺎﻗﻲ وﻧﻄﺒﻖ ﻋﻠﯿﮫ ﻧﻔﺲ اﻷﻣﺮ‪ ،‬ﻗﺪ ﺗﺤﺘﺎج إﻟﻰ اﻟﺠﺪول اﻟﺘﺎﻟﻲ ﻟﻤﺴﺎﻋﺪﺗﻚ ﻓﻲ ﺣﺴﺎب ﻗﯿﻤﺔ‬

‫ﻛﻞ أس‪:‬‬

‫‪20‬‬ ‫‪1‬‬
‫‪21‬‬ ‫‪2‬‬
‫‪22‬‬ ‫‪4‬‬
‫‪23‬‬ ‫‪8‬‬
‫‪24‬‬ ‫‪16‬‬
‫‪25‬‬ ‫‪32‬‬

‫‪24‬‬
 ‫‪26‬‬ ‫‪64‬‬
‫‪27‬‬ ‫‪128‬‬
‫‪28‬‬ ‫‪256‬‬
‫‪29‬‬ ‫‪512‬‬
‫‪210‬‬ ‫‪1024‬‬

‫ﻟﻮ أﺧﺬﻧﺎ ﻧﻔﺲ اﻟﻤﺜﺎل اﻷول اﻟﺬي اﺳﺘﻌﺮﺿﻨﺎ ﻓﯿﮫ ﻛﯿﻔﯿﺔ ﺗﺤﻮﯾﻞ اﻟﻌﺪد ‪ 423‬إﻟﻰ اﻟﺘﺮﻣﯿﺰ اﻟﺜﻨﺎﺋﻲ‬

‫ﻓﺈﻧﻨﺎ ﺳﻨﻄﺒﻖ ﻋﻠﯿﮫ ﻣﺎ ﯾﻠﻲ‪:‬‬

‫‪28 * 1 = 423‬‬
‫‪167 = 256 – 423‬‬
‫‪27 *1 = 167‬‬
‫‪39 = 128 – 167‬‬
‫‪26 * 0 = 39‬‬
‫‪25 * 1 = 39‬‬
‫‪7 = 32 – 39‬‬
‫‪24 * 0 = 7‬‬
‫‪23 * 0 = 7‬‬
‫‪22 * 1 = 7‬‬
‫‪3=4–7‬‬
‫‪21 * 1 = 3‬‬
‫‪ 1 = 2 - 3‬ﻣﺴﺎر ﻗﺮاءة اﻟﻮﺣﺪات‬
‫‪2 0 * 1 =1‬‬
‫ﺑﻌﺪ ﺗﺠﻤﯿﻊ اﻟﻮﺣﺪات وﻓﻖ ﻣﺴﺎر اﻟﻘﺮاءة اﻟﺬي ﯾﺪل ﻋﻠﯿﮫ اﻟﺴﮭﻢ‪ ،‬ﺳﻨﺤﺼﻞ ﻋﻠﻰ ﻧﻔﺲ اﻟﻨﺘﯿﺠﺔ‬

‫اﻟﺴﺎﺑﻘﺔ وھﻲ‪:‬‬

‫‪(423) 10 = (110100111) 2‬‬

‫‪25‬‬
 ‫اﻵن ﺳﻨﺠﺮب ﻧﻔﺲ اﻟﻄﺮﯾﻘﺔ ﻋﻠﻰ اﻟﻌﺪد ‪ 26‬ﻟﻨﺤﺼﻞ ﻋﻠﻰ ﻣﻘﺎﺑﻠﮫ ﻓﻲ اﻟﺘﺮﻣﯿﺰ اﻟﺜﻨﺎﺋﻲ‪:‬‬

‫‪24 * 1 = 26‬‬
‫‪10 = 16 - 26‬‬
‫‪23 *1 = 10‬‬
‫‪2 = 8 – 10‬‬
‫‪22 * 0 = 2‬‬
‫‪21 * 1 = 2‬‬
‫‪0=2–2‬‬
‫‪2 0 * 0 =0‬‬
‫إذا ﺟﻤﻌﻨﺎ اﻟﻮﺣﺪات ﻓﺴﻮف ﻧﺤﺼﻞ ﻋﻠﻰ ﻣﺎ ﯾﻠﻲ‪:‬‬

‫‪(26)10 = (11010)2‬‬

‫‪26‬‬
 ‫‪‬‬
‫ﻗﻠﻨﺎ ﻓﯿﻤﺎ ﺳﺒﻖ أن اﻟﺤﺎﺳﻮب ﯾﻘﻮم ﺑﻤﻌﺎﻟﺠﺔ اﻟﺒﯿﺎﻧﺎت ﻋﻠﻰ ﺷﻜﻞ وﺣﺪات ‪ ،Bits‬ﻋﻠﻤﺎ أن اﻟﻮﺣﺪة ﻻ‬

‫ﺗﺨﺰن ﻟﻮﺣﺪھﺎ ﻓﻲ اﻟﺬاﻛﺮة وإﻧﻤﺎ ﺗﺨﺰن ﻋﻠﻰ ﺷﻜﻞ ﻣﺠﻤﻮﻋﺔ ﻣﺆﻟﻔﺔ ﻣﻦ ﺛﻤﺎﻧﻲ وﺣﺪات ﯾﺼﻄﻠﺢ‬

‫ﻋﻠﯿﮭﺎ ﺑﺎﻟﺒﺎﯾﺖ ‪ ،Byte‬أي أن اﻟﺒﺎﯾﺖ اﻟﻮاﺣﺪ ﯾﺴﺎوي ﺛﻤﺎﻧﻲ وﺣﺪات ‪.1 Byte=8 Bits‬‬

‫وﯾﺴﻤﺢ ﻟﻨﺎ اﻟﺒﺎﯾﺖ اﻟﻮاﺣﺪ ﺑﺘﺨﺰﯾﻦ ﺣﺮف أو رﻗﻢ‪ ،‬وﯾﺼﻄﻠﺢ ﻋﻠﻰ اﻟﺴﻠﺴﻠﺔ اﻟﻤﻜﻮﻧﺔ ﻣﻦ ‪16‬‬

‫وﺣﺪة )أي ‪ 2‬ﺑﺎﯾﺖ( ب"اﻟﻜﻠﻤﺔ" وﻓﻲ اﻟﻠﻐﺔ اﻻﻧﺠﻠﯿﺰﯾﺔ ‪ ،Word‬وﻋﻠﻰ ھﺬا اﻟﻤﻨﻮال ﺗﺄﺗﻲ اﻟﻜﻠﻤﺔ‬

‫‪ DWord‬اﻟﺘﻲ ﺗﺴﺘﻌﻤﻞ ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ ﺳﻠﺴﻠﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﻛﻠﻤﺘﯿﻦ ‪ Double Word‬أي أرﺑﻊ‬

‫ﺑﺎﯾﺘﺎت ‪ 4 Bytes‬أي ‪ 32‬وﺣﺪة ‪.32 Bits‬‬

‫اﻟﺘﺮﻣﯿﺰ اﻟﺜﻤﺎﻧﻲ ھﻮ ﺗﺮﻣﯿﺰ ﯾﻘﻮم ﻋﻠﻰ ﺗﻤﺜﯿﻞ اﻟﺒﯿﺎﻧﺎت ﻋﺒﺮ أﻋﺪاد ﻗﺎﻋﺪﺗﮭﺎ ﺛﻤﺎﻧﯿﺔ‪ ،‬وﯾﺴﻤﺢ ﻟﻨﺎ‬

‫ﺑﺎﺳﺘﺨﺪام ﺛﻤﺎﻧﯿﺔ أرﻗﺎم ﻓﻘﻂ وھﻲ ‪ .7 ،6 ،5 ،4 ،3 ،2 ،1 ،0‬وﯾﺘﻢ اﺳﺘﺨﺪاﻣﮫ ﻣﻦ ﺑﺎب زﯾﺎدة‬

‫ﺣﺠﻢ اﻟﺒﯿﺎﻧﺎت اﻟﻤﻌﺎﻟﺠﺔ‪ ،‬وﻟﺘﺴﮭﯿﻞ ﻗﺮاءة اﻟﺒﯿﺎﻧﺎت اﻟﺜﻨﺎﺋﯿﺔ‪.‬‬

‫‪ ‬‬
‫‪ ‬‬
‫ﻟﺘﺤﻮﯾﻞ اﻟﺒﯿﺎﻧﺎت ﻣﻦ اﻟﺘﻤﺜﯿﻞ اﻟﻌﺸﺮي إﻟﻰ ﺑﯿﺎﻧﺎت ﻣﻤﺜﻠﺔ ﺛﻤﺎﻧﯿﺎ‪ ،‬ﻓﺎﻟﻄﺮﯾﻘﺔ ﻛﻤﺎ ﻗﻠﻨﺎ ﻗﺒﻞ ﻗﻠﯿﻞ‪،‬‬

‫ﻧﺤﺘﺎج ﻓﻘﻂ إﻟﻰ ﺗﻔﻜﯿﻚ اﻷﻋﺪاد ﻟﻠﺤﺼﻮل ﻋﻠﻰ أﻋﺪاد أﺳﺎﺳﮭﺎ اﻟﺮﻗﻢ ‪ ،8‬وھﺬا ﻣﺜﺎل ﯾﻮﺿﺢ ﻛﯿﻔﯿﺔ‬

‫ﻋﻤﻞ ذﻟﻚ‪:‬‬

‫‪(15)10 = 8 + 7‬‬

‫)‪(15)10 = (1 * 81)+(7 * 80‬‬

‫‪(15)10 = (17)8‬‬
‫‪27‬‬
 ‫ﻟﺪﻋﻢ اﻟﻔﮭﻢ رﻛﺰ ﻓﻲ اﻟﻤﺜﺎل اﻟﺜﺎﻧﻲ‪:‬‬

‫)‪(153)10 = (128) + (24) + (1‬‬

‫)‪(153)10 = (2 * 82) + (3 * 81) + (1 * 80‬‬

‫‪(153)10 = (231)8‬‬

‫وﯾﻤﻜﻨﻨﺎ ﺗﺤﻮﯾﻞ اﻟﺒﯿﺎﻧﺎت ﻓﻲ اﻻﺗﺠﺎه اﻟﻌﻜﺴﻲ‪ ،‬أي ﻣﻦ اﻟﺘﻤﺜﯿﻞ اﻟﺜﻤﺎﻧﻲ إﻟﻰ اﻟﺘﻤﺜﯿﻞ اﻟﻌﺸﺮي ﻋﺒﺮ‬

‫ﻃﺮﯾﻘﺔ ﺳﮭﻠﺔ ﺟﺪا ﺗﻘﻮم ﻋﻠﻰ ﺗﻔﻜﯿﻚ اﻟﻘﯿﻤﺔ إﻟﻰ أﻋﺪاد ﻗﺎﻋﺪﺗﮭﺎ ﺛﻤﺎﻧﯿﺔ‪ ،‬ﻓﻠﻮ أﺧﺬﻧﺎ اﻟﻘﯿﻤﺔ اﻟﺜﻤﺎﻧﯿﺔ‬

‫اﻟﺘﺎﻟﯿﺔ )‪ 8(340‬ﻓﺈن ﺗﺤﻮﯾﻠﮭﺎ إﻟﻰ اﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي ﯾﻜﻮن ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬

‫)‪(340)8 = (3 * 82) + (4 * 81) + (0 * 80‬‬

‫)‪(340)8 = (3 * 64) + (4 * 8) + (0 * 1‬‬

‫)‪(340)8 = (192) + (32) + (0‬‬

‫‪(340)8 = (224)10‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪28‬‬
 ‫‪ ‬‬
‫ﺗﻌﺘﺒﺮ ﻋﻤﻠﯿﺔ ﺗﺤﻮﯾﻞ اﻟﺒﯿﺎﻧﺎت ﻣﻦ ﺻﯿﻐﺘﮭﺎ اﻟﺜﻨﺎﺋﯿﺔ إﻟﻰ اﻟﺼﯿﻐﺔ اﻟﺜﻤﺎﻧﯿﺔ ﻣﻦ أﺳﮭﻞ اﻟﻌﻤﻠﯿﺎت‪ ،‬ﺑﯿﺪ‬

‫أن ﻋﻠﯿﻨﺎ ﺗﻘﺴﯿﻢ اﻟﻘﯿﻤﺔ اﻟﺜﻨﺎﺋﯿﺔ إﻟﻰ أﺟﺰاء ﻣﻜﻮﻧﺔ ﻣﻦ ﺛﻼث وﺣﺪات ﺑﺪء ﻣﻦ اﻟﯿﻤﯿﻦ‪ ،‬وﻧﻘﻮم ﺑﺘﺄوﯾﻞ‬

‫ﻛﻞ ﺟﺰء ﺛﻼﺛﻲ ﻓﻲ اﻟﺼﯿﻐﺔ اﻟﺜﻨﺎﺋﯿﺔ ﺑﻤﺮادﻓﮫ اﻟﺜﻤﺎﻧﻲ ﻋﺒﺮ اﺳﺘﺨﺪام اﻟﺠﺪول اﻟﺘﺎﻟﻲ‪:‬‬

‫اﻟﻘﻴﻤﺔ‬ ‫اﻟﻘﻴﻤﺔ اﻟﺜﻨﺎﺋﻴﺔ‬

‫‪0‬‬ ‫‪000‬‬
‫‪1‬‬ ‫‪001‬‬
‫‪2‬‬ ‫‪010‬‬
‫‪3‬‬ ‫‪011‬‬
‫‪4‬‬ ‫‪100‬‬
‫‪5‬‬ ‫‪101‬‬
‫‪6‬‬ ‫‪110‬‬
‫‪7‬‬ ‫‪111‬‬

‫أي ﻟﻮ أﻧﻨﺎ أﺧﺬﻧﺎ اﻟﺴﻠﺴﻠﺔ اﻟﺜﻨﺎﺋﯿﺔ اﻟﺘﺎﻟﯿﺔ ‪ 1001110:‬ﻓﺈن ﻋﻤﻠﯿﺔ ﺗﺤﻮﯾﻠﮭﺎ إﻟﻰ اﻟﺘﻤﺜﯿﻞ اﻟﺜﻤﺎﻧﻲ‬

‫ﯾﻜﻮن ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬

‫‪:‬‬ ‫ﻧﻘﻮم أوﻻ ﺑﺘﺠﺰيء اﻟﻘﻴﻤﺔ اﻟﺜﻨﺎﺋﻴﺔ إﱃ وﺣﺪات ﺛﻼﺛﻴﺔ ﺑﺪء ﻣﻦ‬
‫‪1001110 = 1‬‬ ‫‪001 110‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪6‬‬

‫‪(1001110)2 = (116)8‬‬

‫‪29‬‬
 ‫وھﺬا ﻣﺜﺎل آﺧﺮ ﻟﺪﻋﻢ اﻟﻔﮭﻢ‪:‬‬

‫= ‪(100111001110)2‬‬ ‫‪100‬‬ ‫‪111‬‬ ‫‪001‬‬ ‫‪110‬‬

‫= ‪(100111001110)2‬‬ ‫‪4‬‬ ‫‪7‬‬ ‫‪1‬‬ ‫‪6‬‬

‫‪(100111001110)2 = (4716)8‬‬

‫أﻣﺎ ﺗﺤﻮﯾﻞ اﻟﺒﯿﺎﻧﺎت اﻟﺜﻤﺎﻧﯿﺔ إﻟﻰ ﺑﯿﺎﻧﺎت ﺛﻨﺎﺋﯿﺔ ﻓﯿﻜﻮن ﻋﺒﺮ إﻋﻄﺎء اﻟﻘﯿﻤﺔ اﻟﺜﻨﺎﺋﯿﺔ ﻟﻜﻞ ﺟﺰء ﻣﻦ‬

‫أﺟﺰاء اﻟﻘﯿﻤﺔ اﻟﺜﻤﺎﻧﯿﺔ‪:‬‬

‫‪(234)8 = 010‬‬ ‫‪011‬‬ ‫‪100‬‬

‫‪(234)8 = (10 011 100)2‬‬

‫‪ ‬‬
‫‪‬‬
‫ﯾﻌﺘﺒﺮ اﻟﺘﺮﻣﯿﺰ اﻟﺴﺖ ﻋﺸﺮي ﻣﻦ أﺑﺮز أﻧﻮاع اﻟﺘﺮﻣﯿﺰ اﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ اﻟﻤﻌﻠﻮﻣﯿﺎت ﻷﻧﮫ ﯾﺴﻤﺢ‬

‫ﺑﻘﺮاءة اﻟﺴﻼﺳﻞ اﻟﺜﻨﺎﺋﯿﺔ اﻟﻄﻮﯾﻠﺔ ﺑﺸﻜﻞ ﻣﺨﺘﺼﺮ‪ ،‬ﻋﺒﺮ اﻋﺘﻤﺎد اﻟﺘﻤﺜﯿﻞ اﻟﺮﻗﻤﻲ اﻟﻤﺴﺘﻨﺪ ﻋﻠﻰ ‪16‬‬

‫ﺣﺮﻓﺎ وھﻲ اﻷرﻗﺎم اﻟﻤﻌﺮوﻓﺔ ﻓﻲ اﻟﻨﻈﺎم اﻟﻌﺸﺮي )‪(9 ،8 ،7 ،6 ،5 ،4 ،3 ،2 ،1 ،0‬‬

‫ﺑﺎﻹﺿﺎﻓﺔ إﻟﻰ اﻟﺤﺮوف اﻟﺴﺘﺔ اﻷوﻟﻰ ﻣﻦ اﻟﺤﺮوف اﻟﮭﺠﺎﺋﯿﺔ اﻟﻼﺗﯿﻨﯿﺔ )‪( f ،e ،d ،c ،b ،a‬اﻟﺘﻲ‬

‫ﯾﺴﺘﻌﺎض ﺑﮭﺎ ﻋﻦ اﻷرﻗﺎم اﻟﺘﺎﻟﯿﺔ‪.16 ،15 ،14 ،13 ،12 ،11:‬‬

‫‪30‬‬
‫ھﺬا اﻟﺘﻤﺜﯿﻞ اﻟﺬي ﯾﻤﻜﻨﻨﺎ ﻣﻦ اﺳﺘﺨﺪام ‪ 16‬ﺣﺮﻓﺎ‪ ،‬ﯾﺠﻌﻞ اﻟﺒﯿﺎﻧﺎت ﺳﮭﻠﺔ اﻟﻘﺮاءة ﻷﻧﮭﺎ ﺗﻜﺘﺐ ﺑﺸﻜﻞ‬

‫ﻣﺨﺘﺼﺮ‪ ،‬وﻟﻚ أن ﺗﻘﺎرن ﺑﯿﻦ اﻟﻘﯿﻢ اﻟﺘﺎﻟﯿﺔ وأﯾﮭﺎ أﺷﺪ اﺳﺘﯿﻌﺎﺑﺎ ﻋﻨﺪ اﻟﻌﻘﻞ اﻟﺒﺸﺮي‪:‬‬

‫‪(10011100)2 = (9C)16‬‬

‫‪(11110100011001011)2 = (1E8CB)16‬‬

‫‪(1100000101011111001110110)2 = (182BE76)16‬‬

‫ﻣﻦ ﻏﯿﺮ ﺷﻚ ﻓﺎﻟﺘﻤﺜﯿﻞ اﻟﺴﺖ ﻋﺸﺮي أﺳﮭﻞ ﻗﺮاءة وأﻛﺜﺮ اﺳﺘﯿﻌﺎﺑﺎ ﻣﻦ اﻟﺘﻤﺜﯿﻞ اﻟﺜﻨﺎﺋﻲ‪ ،‬ﻷﻧﮫ‬

‫ﯾﻌﺮض اﻟﻤﻌﻠﻮﻣﺔ ﻋﺒﺮ ﺣﺮوف ﻗﻠﯿﻠﺔ وﻣﺤﺪودة ﻓﻲ اﻟﻮﻗﺖ اﻟﺬي ﺗﻜﺘﺐ ﻓﯿﮫ ھﺬه اﻟﻤﻌﻠﻮﻣﺔ ﻋﺒﺮ‬

‫ﺳﻼﺳﻞ ﻃﻮﯾﻠﺔ ﻣﻦ اﻷﺻﻔﺎر واﻵﺣﺎد اﻟﺘﻲ ﻣﻦ اﻟﺼﻌﺐ ﻗﺮاءﺗﮭﺎ ﺗﺮﺗﯿﺒﯿﺎ ﻓﻀﻼ ﻋﻦ ﺗﺬﻛﺮھﺎ أو‬

‫ﻣﻌﺎﻟﺠﺘﮭﺎ ﻣﻦ ﻗﺒﻞ اﻟﺪﻣﺎغ اﻟﺒﺸﺮي‪.‬‬

‫ﺟﺪول اﻷﻋﺪاد اﻟﺴﺖ ﻋﴩﻳﺔ‬

‫اﻟﺮﻗﻢ اﻟﺴﺖ ﻋﴩي اﻟﺮﻗﻢ اﻟﻌﴩي‬
‫‪1‬‬ ‫‪1‬‬
‫‪2‬‬ ‫‪2‬‬
‫‪3‬‬ ‫‪3‬‬
‫‪4‬‬ ‫‪4‬‬
‫‪5‬‬ ‫‪5‬‬
‫‪6‬‬ ‫‪6‬‬
‫‪7‬‬ ‫‪7‬‬
‫‪8‬‬ ‫‪8‬‬
‫‪9‬‬ ‫‪9‬‬
‫‪10‬‬ ‫‪A‬‬
‫‪11‬‬ ‫‪B‬‬
‫‪12‬‬ ‫‪C‬‬
‫‪13‬‬ ‫‪D‬‬
‫‪14‬‬ ‫‪E‬‬
‫‪15‬‬ ‫‪F‬‬

‫‪31‬‬
 ‫‪‬‬
‫ﺗﻘﺮﯾﺒﺎ ﻧﻔﺲ اﻟﻜﻼم ﺳﯿﺘﻜﺮر‪ ،‬ﻓﻜﻞ ﻃﺮق اﻟﺘﺤﻮﯾﻞ اﻟﺘﻲ رأﯾﻨﺎھﺎ ﻣﺘﻤﺎﺛﻠﺔ ﻓﻲ ﻋﻤﻠﯿﺔ اﻟﺘﺤﻮﯾﻞ ﻣﻊ‬

‫اﻷﺧﺬ ﺑﻌﯿﻦ اﻻﻋﺘﺒﺎر اﻟﻘﺎﻋﺪة اﻟﺘﻲ ﯾﺴﺘﻨﺪ إﻟﯿﮭﺎ ﻛﻞ ﻧﻈﺎم‪ ،‬ﻓﺎﻟﺘﺮﻣﯿﺰ اﻟﺜﻨﺎﺋﻲ ﯾﺴﺘﻨﺪ إﻟﻰ اﻟﻘﺎﻋﺪة ‪،2‬‬

‫واﻟﺘﺮﻣﯿﺰ اﻟﺜﻤﺎﻧﻲ ﯾﺴﺘﻨﺪ إﻟﻰ اﻟﻘﺎﻋﺪة ‪ ،8‬واﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي ﯾﺴﺘﻨﺪ إﻟﻰ اﻟﻘﺎﻋﺪة اﻟﻌﺸﺮﯾﺔ‪ ،‬وﺑﺎﻟﻤﺜﻞ‬

‫ﯾﺴﺘﻨﺪ اﻟﻨﻈﺎم اﻟﺴﺖ ﻋﺸﺮي إﻟﻰ اﻟﻘﺎﻋﺪة ‪ ،16‬وھﺬا ﻣﺜﺎل ﯾﺒﯿﻦ ﻟﻨﺎ ﻛﯿﻒ ﻧﻘﻮم ﺑﺘﺤﻮﯾﻞ ﺑﯿﺎﻧﺎت‬

‫ﻣﻤﺜﻠﺔ ﻓﻲ اﻟﻨﻈﺎم اﻟﻌﺸﺮي إﻟﻰ ﺑﯿﺎﻧﺎت ﻣﻤﺜﻠﺔ ﻓﻲ اﻟﻨﻈﺎم اﻟﺴﺖ ﻋﺸﺮي‪:‬‬

‫)‪23 = (1 * 161) + (7 * 160‬‬

‫‪(23)10 = (17)16‬‬

‫__________________________________‬

‫)‪145 = (9 * 161) + (1 * 160‬‬

‫‪(145)10 = (91)16‬‬

‫)‪367 = (1 * 162) + (6 * 161) + (15 * 160‬‬

‫أن اﻟﺮﻗﻢ ‪ 15‬ﰲ اﻟﻨﻈﺎم اﻟﺴﺖ‬
‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫) ‪367 = (1 * 16 ) + (6 * 16 ) + (15 * 16‬‬ ‫ﻋﴩي ﻫﻮ اﻟﺤﺮف ‪) F‬راﺟﻊ ﺟﺪول‬
‫)‪367 = (1 * 162) + (6 * 161) + (F * 160‬‬ ‫اﻷﻋﺪاد اﻟﺴﺖ ﻋﴩﻳﺔ(‬
‫‪(367)10 = (16F)16‬‬

‫‪ ‬‬

‫‪32‬‬
 ‫‪‬‬
‫اﻟﻄﺮﯾﻘﺔ ﺑﺴﯿﻄﺔ ﺟﺪا وﺗﻜﻮن ﻋﺒﺮ ﺗﻔﻜﯿﻚ اﻟﻌﺪد اﻟﺴﺖ ﻋﺸﺮي إﻟﻰ أﻋﺪاد ﻣﻨﻔﺼﻠﺔ‪ ،‬ﺛﻢ ﻧﻌﻄﻲ ﻛﻞ‬

‫ﻋﺪد ﻓﻲ اﻟﺘﺮﻣﯿﺰ اﻟﺴﺖ ﻋﺸﺮي ﻗﯿﻤﺘﮫ ﻓﻲ اﻟﺘﺮﻣﯿﺰ اﻟﻌﺸﺮي ﺑﺎﻻﺳﺘﻨﺎد إﻟﻰ ﺟﺪول اﻷﻋﺪاد اﻟﺴﺖ‬

‫ﻋﺸﺮﯾﺔ اﻟﺬي أوردﻧﺎه ﻓﻲ اﻷﻋﻠﻰ‪ ،‬وﻃﺮﯾﻘﺔ اﻟﺘﺤﻮﯾﻞ ﺗﺘﻢ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬

‫)‪(54)16 = (5 * 161) + (4 * 160‬‬
‫)‪(54)16 = (80) + (4‬‬
‫‪(54)16 = (84)10‬‬
‫‪----------------------------------------‬‬
‫)‪(89)16 = (8 * 161) + (9 * 160‬‬
‫)‪(89)16 = (128) + (9‬‬
‫‪(89)16 = (137)10‬‬
‫‪----------------------------------‬‬
‫)‪(F3D)16 = (15 * 162)+(3 * 161) + (13 * 160‬‬
‫)‪(F3D)16 = (3840) + (48) + (13‬‬
‫‪(F3D)16 = (3901)10‬‬

‫‪‬‬
‫ﺗﺠﺪر اﻹﺷﺎرة إﻟﻰ أن ﻋﻤﻠﯿﺔ اﻟﺘﺤﻮﯾﻞ ﻣﻦ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ إﻟﻰ اﻟﻨﻈﺎم اﻟﺴﺖ ﻋﺸﺮي ﺗﺘﻢ ﻋﺒﺮ‬

‫ﺗﺠﻤﯿﻊ ﻛﻞ أرﺑﻊ وﺣﺪات ﻋﻠﻰ ﺣﺪة‪ ،‬ﺛﻢ ﺗﺴﺘﺒﺪل ھﺬه اﻟﺮﺑﺎﻋﯿﺔ ﺑﻤﻘﺎﺑﻠﮭﺎ ﻓﻲ اﻟﻨﻈﺎم اﻟﺴﺖ ﻋﺸﺮي‬

‫وﻓﻖ اﻟﺠﺪول اﻟﺘﺎﻟﻲ‪:‬‬

‫‪0‬‬ ‫‪0000‬‬ ‫‪8‬‬ ‫‪1000‬‬

‫‪1‬‬ ‫‪0001‬‬ ‫‪9‬‬ ‫‪1001‬‬
‫‪2‬‬ ‫‪0010‬‬ ‫‪A‬‬ ‫‪1010‬‬
‫‪3‬‬ ‫‪0011‬‬ ‫‪B‬‬ ‫‪1011‬‬
‫‪4‬‬ ‫‪0100‬‬ ‫‪C‬‬ ‫‪1100‬‬
‫‪5‬‬ ‫‪0101‬‬ ‫‪D‬‬ ‫‪1101‬‬

‫‪33‬‬
 ‫‪6‬‬ ‫‪0110‬‬ ‫‪E‬‬ ‫‪1110‬‬
‫‪7‬‬ ‫‪0111‬‬ ‫‪F‬‬ ‫‪1111‬‬

‫وھﺬه اﻷﻣﺜﻠﺔ ﺗﻮﺿﺢ اﻟﻜﻼم أﻋﻼه‪:‬‬

‫= ‪(100110111101)2‬‬ ‫‪1001‬‬ ‫‪1011‬‬ ‫‪1101‬‬

‫‪9‬‬ ‫‪B‬‬ ‫‪D‬‬

‫‪(100110111101)2 = (9BD)16‬‬

‫_________________________________________________________‬

‫‪(11101111000111000101001)2 = 111 0111‬‬ ‫‪1000‬‬ ‫‪1110‬‬ ‫‪0010‬‬ ‫‪1001‬‬

‫‪7‬‬ ‫‪7‬‬ ‫‪8‬‬ ‫‪E‬‬ ‫‪2‬‬ ‫‪9‬‬

‫‪(11101111000111000101001)2 = (778E29)16‬‬

‫‪ ‬‬
‫‪ ‬‬

‫‪ ‬‬
‫‪ ‬‬

‫‪ ‬‬

‫‪34‬‬
‫‪ ‬‬
‫أﻣﺎ ﻃﺮﯾﻘﺔ ﺗﺤﻮﯾﻞ اﻟﺒﯿﺎﻧﺎت اﻟﺴﺖ ﻋﺸﺮﯾﺔ إﻟﻰ اﻟﺒﯿﺎﻧﺎت اﻟﺜﻨﺎﺋﯿﺔ ﻓﯿﻜﻮن ﻋﺒﺮ ﻗﻠﺐ اﻟﻄﺮﯾﻘﺔ‬

‫اﻟﺴﺎﺑﻘﺔ‪ ،‬ﺑﺤﯿﺚ ﻧﻘﻮم ﺑﺘﻔﻜﯿﻚ اﻟﻌﺪد اﻟﺴﺖ ﻋﺸﺮي إﻟﻰ أﺟﺰاء وﻧﺄﺧﺬ ﻛﻞ ﺟﺰء ﻋﻠﻰ ﺣﺪة وﻧﺴﺘﺒﺪﻟﮫ‬

‫ﺑﻤﻘﺎﺑﻠﮫ ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ﺑﺎﻻﻋﺘﻤﺎد ﻋﻠﻰ اﻟﺠﺪول اﻟﺴﺎﺑﻖ‪ ،‬وھﺬه اﻷﻣﺜﻠﺔ ﺗﺒﯿﻦ ﻟﻨﺎ ﻛﯿﻔﯿﺔ اﻟﻘﯿﺎم ﺑﮭﺬا‬

‫اﻟﻨﻮع ﻣﻦ اﻟﺘﺤﻮﯾﻞ‪:‬‬

‫‪(3D)16 = (0011 1101)2‬‬

‫ﻫﻮ ‪ ،0011‬واﻟﺮﻗﻢ ‪ D‬ﻫﻮ ‪) 1101‬راﺟﻊ‬ ‫ﻷن اﻟﺮﻗﻢ ‪ 3‬ﰲ اﻟﱰﻣﻴﺰ‬
‫اﻟﺠﺪول اﻟﺴﺎﺑﻖ(‬

‫‪(6FE89A)16 = (0110 1111 1110 1000 1001 1010)2‬‬

‫‪(458ECB)16 = (10001011000111011001011)2‬‬

‫‪(12CFE8B74B)16 = (1001011001111111010001011011101001011)2‬‬

‫‪ ‬‬
‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬
‫‪ ‬‬

‫‪35‬‬
‫‪ ‬‬
‫ﯾﻤﻜﻨﻚ ﺗﺤﻮﯾﻞ اﻟﻘﯿﻤﺔ اﻟﺜﻤﺎﻧﯿﺔ إﻟﻰ اﻟﻨﻈﺎم اﻟﺴﺖ ﻋﺸﺮي ﻋﺒﺮ ﺗﺤﻮﯾﻠﮭﺎ أوﻻ إﻟﻰ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ﺛﻢ‬

‫ﺗﺤﻮﯾﻞ اﻟﻨﺎﺗﺞ إﻟﻰ اﻟﻨﻈﺎم اﻟﺴﺖ ﻋﺸﺮي ﺑﻨﻔﺲ اﻟﻄﺮﯾﻘﺔ اﻟﺘﻲ رأﯾﻨﺎھﺎ ﻓﻲ اﻟﻔﻘﺮة اﻟﺴﺎﺑﻘﺔ‪:‬‬

‫‪(12)8 = (001‬‬ ‫‪110)2‬‬

‫‪(12)8 = (1110)2‬‬ ‫ﻳﺴﺎوي ‪ 001‬ﰲ اﻟﻨﻈﺎم‬ ‫ﻷن اﻟﺮﻗﻢ ‪ 1‬ﰲ اﻟﻨﻈﺎم‬

‫)راﺟﻊ‬ ‫واﻟﺮﻗﻢ ‪ 2‬ﻳﺴﺎوي ‪ 110‬ﰲ اﻟﻨﻈﺎم‬
‫‪(1110)2 = (E)16‬‬
‫إﱃ اﻟﻨﻈﺎم‬ ‫ﺟﺪول اﻟﺘﺤﻮﻳﻞ ﻣﻦ اﻟﻨﻈﺎم‬
‫‪(12)8 = (E)16‬‬ ‫اﳌﻮﺟﻮد ﰲ اﻟﺼﻔﺤﺔ ‪(20‬‬
‫__________________________________________________‬

‫‪(345)8 = (011‬‬ ‫‪100‬‬ ‫‪101)2‬‬

‫‪(345)8 = (11100101)2‬‬

‫‪(11100101)2 = (E5)16‬‬

‫‪(345)8 = (E5)16‬‬
‫_____________________________________‬

‫‪(2431)8 = (010 100‬‬ ‫‪011‬‬ ‫‪001)2‬‬

‫‪(2431)8 = (10100011001)2‬‬

‫‪(10100011001)2 = (519)16‬‬

‫‪(2431)8 = (519)16‬‬

‫‪ ‬‬
‫ﻧﺴﺘﻄﯿﻊ ﺗﺤﻮﯾﻞ اﻟﺒﯿﺎﻧﺎت اﻟﻤﻤﺜﻠﺔ ﻓﻲ اﻟﻨﻈﺎم اﻟﺴﺖ ﻋﺸﺮي إﻟﻰ ﺑﯿﺎﻧﺎت أﺧﺮى ﻣﻤﺜﻠﺔ ﻓﻲ اﻟﻨﻈﺎم‬

‫اﻟﺜﻤﺎﻧﻲ ﻣﻦ ﺧﻼل اﺳﺘﺨﺪام اﻟﺘﺤﻮﯾﻞ اﻟﺜﻨﺎﺋﻲ ﻛﻮﺳﯿﻂ ﺑﯿﻦ اﻟﻨﻈﺎﻣﯿﻦ‪ ،‬ﺑﻨﻔﺲ اﻟﻄﺮﯾﻘﺔ اﻟﺴﺎﺑﻘﺔ‪ ،‬ﻟﻜﻦ‬

‫‪36‬‬
‫ھﺬه اﻟﻤﺮة ﻋﺒﺮ ﺗﺤﻮﯾﻞ اﻟﻘﯿﻤﺔ اﻟﺴﺖ ﻋﺸﺮﯾﺔ إﻟﻰ ﻗﯿﻤﺔ ﺛﻨﺎﺋﯿﺔ‪ ،‬ﺛﻢ ﺗﺤﻮﯾﻞ اﻟﻨﺎﺗﺞ إﻟﻰ ﻗﯿﻤﺔ ﺛﻤﺎﻧﯿﺔ‪،‬‬

‫ﻛﻤﺎ ﺗﻌﺮض ﻟﻨﺎ اﻷﻣﺜﻠﺔ اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫‪(6EB)16 = (0110 1110 1011)2‬‬

‫‪(6EB)16 = (11011101011)2‬‬
‫راﺟﻊ ﻃﺮﻳﻘﺔ ﺗﺤﻮﻳﻞ اﻟﺒﻴﺎﻧﺎت اﻟﺴﺖ ﻋﴩﻳﺔ إﱃ‬
‫ﺑﻴﺎﻧﺎت ﺛﻨﺎﺋﻴﺔ ﰲ اﻟﺼﻔﺤﺔ ‪25‬‬
‫‪(11011101011)2 = (3353)8‬‬

‫‪(6EB)16 = (3353)8‬‬

‫____________________________________________________‬

‫‪(EE56FD)16 = (1110‬‬ ‫‪1110‬‬ ‫‪0101‬‬ ‫‪0110‬‬ ‫‪1111‬‬ ‫‪1101)2‬‬

‫‪(EE56FD)16 = (111011100101011011111101)2‬‬

‫‪(111011100101011011111101)2 = (73453375)8‬‬

‫‪(EE56FD)16 = (73453375)8‬‬

‫‪37‬‬
 ‫‪‬‬
‫اﻟﺘﻤﺮﯾﻦ ‪:1‬‬

‫‪ .1‬اﻋﻂ ﺗﻌﺮﻳﻔﺎ ﻣﻮﺟﺰا ﻟﺠﻬﺎز اﻟﺤﺎﺳﻮب‪.‬‬

‫‪ .2‬ﻣﺎ اﻟﺠﺰءان اﳌﻜﻮﻧﺎن ﻟﻠﺤﺎﺳﻮب‪ ،‬وﻗﻢ ﺑﺘﻌﺮﻳﻒ ﻛﻞ‬
‫‪ .3‬ﻣﺎﻫﻲ أﻫﻢ اﳌﻜﻮﻧﺎت اﳌﺎدﻳﺔ ﻟﺠﻬﺎز اﻟﺤﺎﺳﻮب؟‬
‫‪ .4‬ﻣﺎﻫﻮ دور اﻟﺬاﻛﺮة اﻟﺮﺋﻴﺴﻴﺔ؟‬
‫‪ .5‬ﻣﺎﻫﻮ دور وﺣﺪة ﻣﻌﺎﻟﺠﺔ اﻟﺒﻴﺎﻧﺎت؟‬
‫‪ .6‬ﻣﺎﻫﻲ أﻧﻮاع اﻷﺟﻬﺰة اﳌﻤﻜﻦ وﺻﻠﻬﺎ ﻣﻊ اﻟﺤﺎﺳﻮب؟‬
‫‪ .7‬اذﻛﺮ اﳌﺮاﺣﻞ اﻟﺘﻲ ﻣﻨﻬﺎ ﺗﻨﻔﻴﺬ أي ﺑﺮﻧﺎﻣﺞ ﻋﲆ ﺟﻬﺎز اﻟﺤﺎﺳﻮب‪ ،‬ﻣﻊ ﺗﺤﺪﻳﺪ‬
‫اﳌﻜﻮﻧﺎت اﳌﺘﺪﺧﻠﺔ ﰲ اﻟﻌﻤﻠﻴﺔ ﻣﻮﺿﺤﺎ دور ﻛﻞ ﻣﻜﻮن ﻣﺎدي ﰲ ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ‬
‫اﻟﱪاﻣﺞ‪.‬‬
‫‪ .8‬ﻣﺎﻫﻮ ﻧﻈﺎم ﺗﺮﻣﻴﺰ اﻟﺒﻴﺎﻧﺎت اﻟﺬي ﻳﻔﻬﻤﻪ اﻟﺤﺎﺳﻮب؟‬
‫اﻟﺒﻴﺎﻧﺎت؟ واذﻛﺮ اﻟﻘﺎﻋﺪة اﻟﺮﻗﻤﻴﺔ ﻟﻜﻞ ﻧﻈﺎم‪.‬‬ ‫‪ .9‬ﻣﺎﻫﻲ أﺷﻬﺮ أﻧﻮاع أﻧﻈﻤﺔ‬
‫‪ .10‬ﻟﺨﺺ ﰲ ورﻗﺔ ﻃﺮﻳﻘﺔ اﻻﻧﺘﻘﺎل ﻣﻦ ﻧﻈﺎم إﱃ ﻧﻈﺎم آﺧﺮ‪ ،‬ﻟﻴﺴﻬﻞ ﻋﻠﻴﻚ اﻹﺟﺎﺑﺔ‬
‫اﻟﺘﺎﻟﻴﺔ‪.‬‬ ‫ﻋﲆ‬

‫اﻟﺘﻤﺮﯾﻦ ‪:2‬‬

‫وﺣﺪات ﻗﻴﺎس اﻟﺒﻴﺎﻧﺎت اﻟﺘﺎﻟﻴﺔ‪:‬‬ ‫ﻗﻢ ﺑﺤﺴﺎب ﻧﺎﺗﺞ اﻟﺘﺤﻮﻳﻞ‬

‫‪ 1‬ﺟﻴﻐﺎ ﺑﺎﻳﺖ ﻛﻢ ﻳﺴﺎوي ﻣﻦ ﻛﻴﻠﻮ ﺑﺎﻳﺖ؟‬
‫‪ 75‬ﻣﻴﻐﺎ ﺑﺎﻳﺖ ﻛﻢ ﻳﺴﺎوي ﻣﻦ ﻛﻴﻠﻮ ﺑﺎﻳﺖ؟‬
‫‪ 12‬ﻛﻴﻠﻮ ﺑﺎﻳﺖ ﻛﻢ ﻳﺴﺎوي ﻣﻦ ﺑﺎﻳﺖ؟‬
‫‪ 1750‬ﺑﺎﻳﺖ ﻛﻢ ﻳﺴﺎوي ﻣﻦ ﻛﻴﻠﻮﺑﺎﻳﺖ؟‬
‫‪ 5680‬ﻛﻴﻠﻮﺑﺎﻳﺖ ﻛﻢ ﻳﺴﺎوي ﻣﻦ ﻣﻴﻐﺎ ﺑﻴﺖ؟‬

‫‪38‬‬
 ‫اﻟﺘﻤﺮﯾﻦ ‪:3‬‬
‫‪:‬‬ ‫ﺣﻮل اﻷرﻗﺎم اﻟﺘﺎﻟﻴﺔ ﻣﻦ اﻟﻨﻈﺎم اﻟﻌﴩي إﱃ اﻟﻨﻈﺎم‬
‫‪7‬‬
‫‪162‬‬
‫‪943‬‬
‫‪5872‬‬
‫‪761452‬‬

‫اﻟﺘﻤﺮﯾﻦ ‪:4‬‬

‫اﻟﻨﻈﺎم اﻟﻌﴩي‪:‬‬ ‫ﺣﻮل اﻷرﻗﺎم اﻟﺘﺎﻟﻴﺔ ﻣﻦ اﻟﻨﻈﺎم‬

‫‪100101‬‬
‫‪111100110110001‬‬
‫‪10011100000101010010‬‬
‫‪100100010011111001010010‬‬
‫‪10111001110001000000011101001011001‬‬

‫اﻟﺘﻤﺮﯾﻦ ‪:5‬‬

‫‪:‬‬ ‫إﱃ اﻟﻨﻈﺎم‬ ‫ﺣﻮل اﻷرﻗﺎم اﻟﺘﺎﻟﻴﺔ ﻣﻦ اﻟﻨﻈﺎم‬

‫‪56‬‬
‫‪123‬‬
‫‪6761‬‬
‫‪671512‬‬
‫‪39‬‬
‫‪13726552‬‬
 ‫اﻟﺘﻤﺮﯾﻦ ‪:6‬‬

‫‪:‬‬ ‫ﺣﻮل اﻷرﻗﺎم اﻟﺘﺎﻟﻴﺔ ﻣﻦ اﻟﻨﻈﺎم‬

‫‪10101‬‬
‫‪1110111‬‬
‫‪1001000110‬‬
‫‪11111011101‬‬
‫‪1010101010101111010‬‬
‫اﻟﺘﻤﺮﯾﻦ ‪:7‬‬
‫ﺣﻮل اﻷرﻗﺎم اﻟﺘﺎﻟﻴﺔ ﻣﻦ اﻟﻨﻈﺎم اﻟﻌﴩي إﱃ اﻟﻨﻈﺎم اﻟﺴﺖ ﻋﴩي‪:‬‬
‫‪7‬‬
‫‪432‬‬
‫‪19827‬‬
‫‪1909725‬‬
‫‪5652414146‬‬

‫اﻟﺘﻤﺮﯾﻦ ‪:8‬‬
‫ﺣﻮل اﻷرﻗﺎم اﻟﺘﺎﻟﻴﺔ ﻣﻦ اﻟﻨﻈﺎم اﻟﺴﺖ ﻋﴩي إﱃ اﻷﻧﻈﻤﺔ اﻟﻌﴩﻳﺔ واﻟﺜﻨﺎﺋﻴﺔ‬
‫‪:‬‬
‫‪99‬‬
‫‪12D‬‬
‫‪AAABBC‬‬
‫‪54F‬‬
‫‪11FFEE11D456‬‬
‫‪980FD‬‬

‫‪40‬‬





41
 ‫‪‬‬
‫ﻧﺴﺘﻄﯿﻊ اﻟﻘﯿﺎم ﺑﺎﻟﻌﻤﻠﯿﺎت اﻟﺮﯾﺎﺿﯿﺔ اﻟﻤﺄﻟﻮﻓﺔ ﻣﻦ ﻗﺒﯿﻞ اﻟﺠﻤﻊ واﻟﻄﺮح واﻟﻀﺮب واﻟﻘﺴﻤﺔ ﻋﻠﻰ‬

‫اﻷﻋﺪاد اﻟﺜﻨﺎﺋﯿﺔ‪ ،‬ﺑﻨﻔﺲ اﻟﻄﺮﯾﻘﺔ اﻟﻌﺎدﯾﺔ اﻟﺘﻲ ﻧﺴﺘﺨﺪﻣﮭﺎ ﻓﻲ ﻧﻈﺎﻣﻨﺎ اﻟﻌﺸﺮي‪ ،‬ﻟﻜﻦ ﻗﺪ ﯾﺘﺴﺎءل‬

‫اﻟﺒﻌﺾ ﻟﻤﺎذا ﺳﻨﺤﺘﺎج إﻟﻰ ﺣﺴﺎب اﻷﻋﺪاد اﻟﺜﻨﺎﺋﯿﺔ‪ ،‬وھﻞ ﻋﻠﻲ أن أﻗﻮم ﺑﮭﺬه اﻟﻌﻤﻠﯿﺎت ﻛﻠﻤﺎ‬

‫أردت أن أﺑﺮﻣﺞ ﺷﯿﺌﺎ ﻓﻲ اﻟﻤﺴﺘﻘﺒﻞ‪ ،‬أﺑﺸﺮك ﺑﺄﻧﻚ ﻟﺴﺖ ﻣﻠﺰﻣﺎ ﺑﺈﺗﻘﺎن ھﺬه اﻟﻌﻤﻠﯿﺎت وﻻ ﺣﺘﻰ‬

‫ﻋﻤﻠﯿﺎت اﻟﺘﺤﻮﯾﻞ اﻟﺘﻲ رأﯾﻨﺎھﺎ ﻓﻲ اﻟﻔﺼﻞ اﻟﺴﺎﺑﻖ‪ ،‬ﻷن ذﻟﻚ ﻛﻠﮫ ﻣﻦ اﺧﺘﺼﺎﺻﺎت اﻷﺟﮭﺰة‬

‫اﻟﻤﺸﻐﻠﺔ ﻟﻠﺒﺮاﻣﺞ‪ ،‬ﻓﺎﻟﺤﺎﺳﻮب ھﻮ اﻟﻤﻮﻛﻞ ﺑﺎﻟﻘﯿﺎم ﺑﻜﻞ ھﺬه اﻟﻌﻤﻠﯿﺎت وﻟﯿﺲ اﻟﻤﺒﺮﻣﺞ ﻷن اﻟﻠﻐﺔ‬

‫اﻟﺜﻨﺎﺋﯿﺔ ﻛﻤﺎ ذﻛﺮﻧﺎ ﻓﻲ ﺑﺪاﯾﺔ اﻟﻜﺘﺎب ھﻲ اﻟﻠﻐﺔ اﻟﺨﺎﺻﺔ ﺑﺎﻟﺤﺎﺳﻮب وﺑﺎﻟﺘﺎﻟﻲ ﻛﻞ ﻣﺎ ﯾﺘﺮﺗﺐ ﻋﻨﮭﺎ‬

‫ھﻮ ﻣﺮﺗﺒﻂ ﺑﺎﻟﺤﺎﺳﻮب‪ ،‬ﻟﻜﻦ ﻣﻦ ﺑﺎب ﻓﮭﻢ ﺣﻘﯿﻘﺔ ﻣﺎ ﯾﺠﺮي ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﺤﺎﺳﻮب ﻋﻨﺪ ﻣﻌﺎﻟﺠﺘﮫ‬

‫ﻟﻠﺒﯿﺎﻧﺎت ﻓﺈﻧﻨﺎ ﻧﺘﻌﻠﻢ ھﺬه اﻷﻣﻮر ﻟﻜﻲ ﻧﻔﮭﻢ ﻛﯿﻒ ﺗﻔﻜﺮ ھﺬه اﻵﻟﺔ اﻟﺘﻲ ﻧﺨﺎﻃﺒﮭﺎ‪ ،‬وأﻋﺘﻘﺪ وﷲ اﻟﺤﻤﺪ‬

‫أن اﻟﺮؤﯾﺔ وﺿﺤﺖ أﻛﺜﺮ وﺻﺮﻧﺎ ﻋﻠﻰ دراﯾﺔ ﺑﺎﻟﻌﻤﻠﯿﺎت اﻟﺘﻲ ﺗﺠﺮي ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﺤﺎﺳﻮب‬

‫ﻟﺘﻨﻔﯿﺬ اﻷواﻣﺮ اﻟﻤﻮﺟﮭﺔ إﻟﯿﮫ‪ ،‬وھﺬا ھﻮ ﻣﺮﻣﺎﻧﺎ وﻣﺴﻌﺎﻧﺎ‪.‬‬

‫ﻃﯿﺐ ﺗﻌﺎﻟﻮا ﺑﻨﺎ اﻵن ﻧﻄﺮح اﻟﺴﺆال اﻟﺘﺎﻟﻲ‪ :‬ﺣﯿﻨﻤﺎ ﻧﻮﺟﮫ إﻟﻰ اﻟﺤﺎﺳﻮب أﻣﺮ إﺿﺎﻓﺔ ﻋﺪدﯾﻦ‬

‫ﻋﺸﺮﯾﯿﻦ ﻣﺎﻟﺬي ﯾﺤﺪث؟‬

‫أوﻻ ﯾﺘﻢ ﺗﺤﻮﯾﻞ ھﺬﯾﻦ اﻟﻌﺪدﯾﻦ اﻟﻌﺸﺮﯾﯿﻦ إﻟﻰ ﻋﺪدﯾﻦ ﺛﻨﺎﺋﯿﯿﻦ‪ ،‬ﺛﻢ ﯾﺘﻢ اﻟﺠﻤﻊ ﺑﯿﻨﮭﻤﺎ‪ ،‬وﺗﺤﻮﯾﻞ‬

‫اﻟﻨﺘﯿﺠﺔ إﻟﻰ اﻟﻨﻈﺎم اﻟﻌﺸﺮي ﻣﻦ أﺟﻞ ﻃﺒﺎﻋﺘﮭﺎ ﻟﻠﻤﺴﺘﺨﺪم‪.‬‬

‫‪42‬‬
 ‫‪‬‬
‫ﻓﻲ اﻟﻨﻈﺎم اﻟﻌﺸﺮي اﻟﺬي ﻧﺴﺘﺨﺪﻣﮫ ﻧﺤﻦ اﻟﺒﺸﺮ ﯾﻜﻮن ﻣﺠﻤﻮع واﺣﺪ زاﺋﺪ واﺣﺪ ھﻮ اﺛﻨﺎن‬

‫‪2=1+1‬‬

‫ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ﻧﺘﯿﺠﺔ واﺣﺪ زاﺋﺪ واﺣﺪ ھﻲ ﻋﺸﺮة وﻟﯿﺴﺖ إﺛﻨﺎن‪ ،‬أي أن ‪ ،10=1+1‬وﺑﺎﻗﻲ‬

‫اﻟﺤﺴﺎﺑﺎت ﺗﺘﻢ ﺑﺎﻟﺸﻜﻞ اﻟﻌﺎدي‪ ،‬وﯾﻤﻜﻨﻨﺎ ﺗﻠﺨﯿﺺ ﺣﺴﺎب اﻟﺠﻤﻊ ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ﻓﻲ اﻟﺠﺪول‬

‫اﻟﺘﺎﻟﻲ‪:‬‬

‫‪+‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪10‬‬

‫ﺑﻨﺎء ﻋﻠﻰ اﻟﺠﺪول أﻋﻼه ﻓﺈن ﻋﻤﻠﯿﺔ اﻟﺠﻤﻊ ﻟﻸﻋﺪاد اﻟﺜﻨﺎﺋﯿﺔ اﻟﺘﺎﻟﯿﺔ ﺗﺘﻢ ﺑﮭﺬا اﻟﺸﻜﻞ‪:‬‬

‫‪1001011‬‬ ‫‪1101110‬‬ ‫‪10101‬‬

‫‪+1110010‬‬ ‫‪+ 10010‬‬ ‫‪+ 1001‬‬
‫________‬ ‫________‬ ‫______‬
‫‪10111101‬‬ ‫‪10000000‬‬ ‫‪11110‬‬
‫____________________________________________________________________________‬

‫‪11000101110101‬‬
‫‪+10100100101001‬‬
‫_______________‬
‫‪101101010011110‬‬

‫‪43‬‬
 ‫‪‬‬
‫ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‪ ،‬ﺗﺘﻢ ﻋﻤﻠﯿﺔ اﻟﻄﺮح ﺑﻨﻔﺲ اﻟﻄﺮﯾﻘﺔ اﻟﻤﺄﻟﻮﻓﺔ واﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ اﻟﻨﻈﺎم اﻟﻌﺸﺮي‪،‬‬

‫ﺑﺤﯿﺚ ﯾﺘﻢ ﻃﺮح اﻟﺮﻗﻢ اﻟﻌﻠﻮي ﻣﻦ اﻟﺮﻗﻢ اﻟﺴﻔﻠﻲ‪ ،‬وإذا ﻛﺎن اﻟﺮﻗﻢ اﻟﺴﻔﻠﻲ أﻛﺒﺮ ﻣﻦ اﻟﺮﻗﻢ اﻟﻌﻠﻮي‬

‫ﯾﺘﻢ إﺿﺎﻓﺔ ﻋﺸﺮة إﻟﻰ ھﺬا اﻷﺧﯿﺮ ﻣﻊ ﻧﻘﺼﺎن واﺣﺪ ﻣﻦ اﻟﺮﻗﻢ اﻟﻤﻮاﻟﻲ ﻛﻤﺎ ﺟﺮت اﻟﻌﺎدة ﻣﻊ‬

‫ﻋﻤﻠﯿﺔ اﻟﻄﺮح‪ ،‬وﻟﻨﻔﺘﺮض أﻧﻨﺎ ﻓﻲ اﻟﻨﻈﺎم اﻟﻌﺸﺮي ﻧﻮد ﻃﺮح ‪ 127‬ﻣﻦ اﻟﺮﻗﻢ ‪ ،352‬اﻟﻌﻤﻠﯿﺔ‬

‫ﺳﺘﻜﻮن ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬

‫ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‪ ،‬إذا أردﻧﺎ ﻃﺮح ‪ 0‬ﻣﻦ واﺣﺪ ﻓﺈن اﻟﻨﺘﯿﺠﺔ ھﻲ ‪ ،1‬وإذا أردﻧﺎ ﻃﺮح ‪ 1‬ﻣﻦ ‪1‬‬

‫ﻓﺈن اﻟﻨﺘﯿﺠﺔ ھﻲ ﺻﻔﺮ‪ ،‬وإذا أردﻧﺎ ﻃﺮح ‪ 0‬ﻣﻦ ‪ 0‬ﻓﺈن اﻟﻨﺘﯿﺠﺔ ھﻲ ﺻﻔﺮ‪ ،‬أﻣﺎ إذا أردﻧﺎ أن‬

‫ﻧﻄﺮح ‪ 1‬ﻣﻦ ‪ 0‬ﻓﺈﻧﻨﺎ ھﻨﺎ ﻧﺤﺘﺎج إﻟﻰ إﺿﺎﻓﺔ ‪ 1‬إﻟﻰ ‪ 0‬ﻟﯿﺼﺒﺢ ﻟﺪﯾﻨﺎ وﺣﺪﺗﺎن ﻣﻘﺎﺑﻞ وﺣﺪة واﺣﺪة‬

‫وﺑﺎﻟﺘﺎﻟﻲ ﺗﻜﻮن ﻧﺘﯿﺠﺔ ﻃﺮح ‪ 1‬ﻣﻦ ‪ 0‬ھﻲ ‪.1‬‬

‫وھﺬا ﻣﺜﺎل ﻟﺘﻮﺿﯿﺢ ﻛﯿﻔﯿﺔ إﻧﺠﺎز ﻋﻤﻠﯿﺔ اﻟﻄﺮح ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‪:‬‬

‫‪44‬‬
‫ﻓﻲ ﻋﻤﻠﯿﺔ اﻟﻄﺮح أﻋﻼه‪ ،‬ﻗﻤﻨﺎ ﺑﻄﺮح اﻟﻘﯿﻤﺔ ‪ 1001‬ﻣﻦ اﻟﻘﯿﻤﺔ ‪ ،1010‬ﻓﺄول ﻣﺎ ﻛﺎن ﻟﺪﯾﻨﺎ ھﻮ‬

‫ﻃﺮح واﺣﺪ ﻣﻦ ﺻﻔﺮ‪ ،‬وﺑﺎﻟﻌﻮدة إﻟﻰ اﻟﻘﺎﻋﺪة اﻟﺴﺎﺑﻘﺔ ﻓﺈﻧﻨﺎ ﺳﻨﺤﺘﺎج إﻟﻰ إﺿﺎﻓﺔ واﺣﺪ إﻟﻰ ﺻﻔﺮ‪،‬‬

‫ﻓﯿﺼﺒﺢ ﻟﺪﯾﻨﺎ )‪ 0+1‬أي ﺻﺎر ﻟﺪﯾﻨﺎ وﺣﺪﺗﺎن ‪ (Bits 2 :‬وﺑﻄﺮح وﺣﺪة واﺣﺪة ﻣﻦ وﺣﺪﺗﯿﻦ ﻓﺈن‬

‫اﻟﻨﺎﺗﺞ ﺳﯿﻜﻮن ھﻮ وﺣﺪة واﺣﺪة ﻟﺬﻟﻚ ﺣﺼﻠﻨﺎ ﻋﻠﻰ ‪ ،1‬وﻟﺘﻌﻤﯿﻖ اﻟﺸﺮح ﺗﺬﻛﺮ أﻧﻨﺎ ﻓﻲ اﻟﻨﻈﺎم‬

‫اﻟﻌﺸﺮي إذا أردﻧﺎ ﻃﺮح رﻗﻢ ﺻﻐﯿﺮ ﻣﻦ رﻗﻢ ﻛﺒﯿﺮ ﻧﻀﯿﻒ ‪ 1‬وھﻮ ﯾﻤﺜﻞ ‪ ،10‬ﻓﻜﺬﻟﻚ ﻓﻲ اﻟﻨﻈﺎم‬

‫اﻟﺜﻨﺎﺋﻲ ﻧﻀﯿﻒ ‪ 1‬وھﻮ ﯾﻤﺜﻞ ‪.2‬‬

‫ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﻧﻘﺼﻨﺎ ‪ 1‬ﻣﻦ ‪) 1‬ﻷن اﻟﺼﻔﺮ اﻟﺴﻔﻠﻲ اﻧﻀﺎف إﻟﯿﮫ ‪ 1‬اﻟﺬي اﺳﺘﻠﻔﻨﺎه ﻓﻲ أول وﺣﺪة(‬

‫وﺑﺎﻟﺘﺎﻟﻲ ﺣﺼﻠﻨﺎ ﻋﻠﻰ ﺻﻔﺮ‪ ،‬ﺑﻌﺪ ذﻟﻚ ﻃﺮﺣﻨﺎ ﺻﻔﺮ ﻣﻦ ﺻﻔﺮ ﻓﺤﺼﻠﻨﺎ ﻋﻠﻰ ﺻﻔﺮ‪ ،‬ﺛﻢ ﻃﺮﺣﻨﺎ‬

‫واﺣﺪ ﻣﻦ واﺣﺪ ﻓﺤﺼﻠﻨﺎ ﻋﻠﻰ ﺻﻔﺮ‪.‬‬

‫ﻓﯿﻤﺎ ﯾﻠﻲ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﻣﺜﻠﺔ ﻟﻔﮭﻢ ﻋﻤﻠﯿﺔ اﻟﻄﺮح ﺟﯿﺪا‪:‬‬

‫‪‬‬
‫ﻋﻤﻠﯿﺔ اﻟﻀﺮب ﻓﻲ اﻟﻨﻈﺎم اﺛﻨﺎﺋﻲ ھﻲ ﻧﻔﺴﮭﺎ ﻓﻲ اﻟﻨﻈﺎم اﻟﻌﺸﺮي‪ ،‬ﻧﻘﻮم ﺑﻀﺮب ﻛﻞ رﻗﻢ ﻣﻦ‬

‫اﻟﻌﺪد اﻟﺴﻔﻠﻲ ﻓﻲ ﺟﻤﯿﻊ أرﻗﺎم اﻟﻌﺪد اﻟﻌﻠﻮي‪ ،‬ﺛﻢ ﻧﻘﻮم ﺑﺠﻤﻊ ﻧﺘﺎﺋﺞ ﻛﻞ ﺟﺪاء ﻟﻨﺤﺼﻞ ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ‬

‫اﻟﻨﮭﺎﺋﯿﺔ‪ ،‬ﻓﯿﻤﺎ ﯾﻠﻲ ﻣﺜﺎل ﻋﻠﻰ ﻋﻤﻠﯿﺔ اﻟﻀﺮب ﻓﻲ اﻟﻨﻈﺎم اﻟﻌﺸﺮي‪:‬‬

‫‪45‬‬
 ‫وھﺬا اﻟﺠﺪول ﯾﻠﺨﺺ ﻧﺘﯿﺠﺔ اﻟﻀﺮب ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‪:‬‬

‫‪X‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬

‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬

‫وھﺬه أﻣﺜﻠﺔ ﻟﻤﺠﻤﻮﻋﺔ ﻋﻤﻠﯿﺎت اﻟﻀﺮب ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‪:‬‬

‫‪46‬‬
47






48
 ‫‪‬‬
‫ﻣﻼﺣﻈﺎت ﻣﮭﻤﺔ ﻗﺒﻞ اﻟﺒﺪء‬

‫ﻗﺒﻞ أن ﻧﺒﺪأ دراﺳﺔ اﻟﺨﻮارزﻣﯿﺔ أﺣﺐ أن أﻧﺒﮫ إﻟﻰ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﻣﻮر اﻟﻤﮭﻤﺔ‪:‬‬

‫‪ ‬اﻟﻄﺮﯾﻘﺔ اﻟﺘﻲ ﺗﻜﺘﺐ ﺑﮭﺎ اﻟﺨﻮارزﻣﯿﺔ ﻟﯿﺴﺖ ﺛﺎﺑﺘﺔ وﻗﺪ ﺗﺘﻌﺪد ﺻﯿﻐﺔ ﻛﺘﺎﺑﺘﮭﺎ ﻟﻜﻦ اﻟﻤﮭﻢ‬

‫واﻷﺳﺎﺳﻲ أن ﺗﻜﻮن اﻟﺨﻄﻮات ﻣﻨﻄﻘﯿﺔ وﻣﺘﺮاﺑﻄﺔ وﻗﺎﺑﻠﺔ ﻟﻠﺘﺤﻮﯾﻞ إﻟﻰ ﻟﻐﺔ ﺑﺮﻣﺠﯿﺔ‪.‬‬

‫‪ ‬اﻟﻄﺮﯾﻘﺔ اﻟﺘﻲ ﺳﻨﺴﺘﻌﻤﻠﮭﺎ ﻓﻲ ھﺬا اﻟﻜﺘﺎب ﻃﺮﯾﻘﺔ ﺷﺨﺼﯿﺔ ﺗﺨﻠﻂ ﺑﯿﻦ اﻟﺼﯿﻐﺔ اﻟﻜﻼﺳﯿﻜﯿﺔ‬

‫ﻟﻜﺘﺎﺑﺔ اﻟﺨﻮارزﻣﯿﺎت وﺑﯿﻦ اﻟﺒﻨﯿﺔ اﻟﺮﺋﯿﺴﯿﺔ اﻟﻤﺸﺘﺮﻛﺔ ﺑﯿﻦ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ اﻟﻤﺸﮭﻮرة‬

‫)ﺟﺎﻓﺎ‪ ،‬ﺳﻲ ﺷﺎرب‪ ،‬ﺳﻲ‪ ،‬ﺳﻲ ﺑﻠﺲ ﺑﻠﺲ‪ ،‬ﺑﻲ إﺗﺶ ﺑﻲ‪ (... ،‬ﻟﻜﻲ ﻻ ﯾﺠﺪ اﻟﻤﺘﻌﻠﻢ ﺻﻌﻮﺑﺔ‬

‫ﺣﯿﻨﻤﺎ ﯾﺮﯾﺪ ﺗﻄﺒﯿﻖ ﻣﺎ ﻓﮭﻤﮫ ﻣﻦ اﻟﻜﺘﺎب ﻋﻠﻰ ﻟﻐﺔ ﺑﺮﻣﺠﯿﺔ ﻣﻌﯿﻨﺔ‪.‬‬

‫‪ ‬اﻷواﻣﺮ اﻟﻤﻜﺘﻮﺑﺔ ﻓﻲ اﻟﺨﻮارزﻣﯿﺎت ﺗﺴﻤﻰ ﻛﻮد زاﺋﻒ ‪ ،Pseudo Code‬أي أﻧﮭﺎ‬

‫ﻣﺠﺮد ﻛﺘﺎﺑﺔ ﻣﻨﻄﻘﯿﺔ وﻟﯿﺴﺖ ﻛﻮد ﺣﻘﯿﻘﻲ‪ ،‬وﻣﻌﻈﻢ اﻷﻛﻮاد اﻟﺰاﺋﻔﺔ اﻟﻮاردة ﻓﻲ اﻷﻣﺜﻠﺔ‬

‫ﺳﺘﺠﺪھﺎ ﻣﺮﻓﻘﺔ ﺑﻌﻨﺎوﯾﻦ ﺧﻀﺮاء ﺗﺴﻤﻰ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﺗﻌﺎﻟﯿﻘﺎ ‪ Comments‬وھﻲ ﻛﻠﻤﺎت‬

‫ﻻ ﯾﺘﻢ ﺗﻨﻔﯿﺬھﺎ وﯾﻜﻮن دورھﺎ ھﻮ ﺗﻨﻈﯿﻢ اﻟﻜﻮد وﻋﻨﻮﻧﺘﮫ ﻟﯿﻜﻮن ﺳﮭﻞ اﻟﻘﺮاءة وﻣﺴﺘﺴﺎغ‬

‫اﻟﻔﮭﻢ‪ ،‬وھﺬا ﻣﺜﺎل ﻋﻠﻰ اﻟﺘﻌﺎﻟﯿﻖ اﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ اﻟﻜﺘﺎب‪:‬‬

‫‪//‬ھﺬا اﻟﺴﻄﺮ اﻷﺧﻀﺮ ﺗﻌﻠﯿﻖ ﻋﻠﻰ اﻟﻜﻮد‬

‫‪*/‬‬

‫وھﺬا أﯾﻀﺎ ﺗﻌﻠﯿﻖ‬

‫ﻟﻜﻨﮫ ﻣﻮزع ﻋﻠﻰ أﻛﺜﺮ ﻣﻦ ﺳﻄﺮ‬

‫*‪/‬‬

‫‪49‬‬
 ‫‪‬‬
‫اﻟﺨﻮارزﻣﯿﺎت ھﻲ ﻃﺮﯾﻘﺔ ﻣﻨﻄﻘﯿﺔ ﻓﻲ اﻟﺘﻔﻜﯿﺮ ﻧﺴﺘﺨﺪﻣﮭﺎ ﻣﻦ أﺟﻞ اﻟﻮﺻﻮل إﻟﻰ ﺣﻞ وﺿﻌﯿﺔ‬

‫ﻣﻌﯿﻨﺔ ﻋﺒﺮ ﻋﺪد ﻣﺤﺪد ﻣﻦ اﻟﺨﻄﻮات اﻟﻤﻨﻄﻘﯿﺔ اﻟﻤﺘﺮاﺑﻄﺔ ﻓﯿﻤﺎ ﺑﯿﻨﮭﺎ‪ ،‬وﺳﻤﯿﺖ ﺑﮭﺬا اﻹﺳﻢ ﻧﺴﺒﺔ‬

‫إﻟﻰ ﺻﺎﺣﺒﮭﺎ أﺑﻲ ﺟﻌﻔﺮ اﻟﺨﻮارزﻣﻲ رﺣﻤﮫ اﷲ‪ ،‬اﻟﺬي ﻋﺎﺻﺮ ﻓﺘﺮة اﻟﺤﻜﻢ اﻟﻌﺒﺎﺳﻲ وﺗﺤﺪﯾﺪا‬

‫ﻋﺼﺮ اﻟﺨﻠﯿﻔﺔ اﻟﻤﺄﻣﻮن‪ ،‬وﻛﺎن اﻟﺨﻮارزﻣﻲ رﺣﻤﮫ اﷲ ﻧﺎﺑﻐﺎ ﻓﻲ ﻋﻠﻮم اﻟﺤﺴﺎب واﻟﻔﻠﻚ‬

‫واﻟﺠﻐﺮاﻓﯿﺎ وھﻮ ﻣﺆﺳﺲ ﻋﻠﻢ اﻟﺠﺒﺮ وﻣﺆﺳﺲ اﻟﺨﻮارزﻣﯿﺎت‪ ،‬وﻟﮫ اﻟﻌﺪﯾﺪ ﻣﻦ اﻹﻧﺠﺎزات اﻟﻌﻠﻤﯿﺔ‬

‫اﻟﻌﻈﯿﻤﺔ‪.‬‬

‫ﻟﻮ أردﻧﺎ ﺗﺒﺴﯿﻂ اﻟﺨﻮارزﻣﯿﺎت‪ ،‬ﻓﮭﻲ ﺧﻄﻮات ﻧﻘﻮم ﺑﮭﺎ ﻟﺤﻞ ﻣﺸﻜﻞ ﻣﻌﯿﻦ‪ ،‬ﻣﺜﻼ ﻋﻨﺪﻧﺎ ﺑﺮﻧﺎﻣﺞ‬

‫ﻣﻌﯿﻦ ﻟﻜﻲ ﻧﺸﻐﻠﮫ ﻋﻠﻰ ﺣﺎﺳﻮﺑﻨﺎ ﻓﻌﻠﯿﻨﺎ ﺗﻨﺼﯿﺒﮫ‪ ،‬أي اﺗﺒﺎع ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺨﻄﻮات اﻟﺘﻲ ﺗﺆدي ﻟﻨﺎ‬

‫ﻓﻲ اﻷﺧﯿﺮ ﺗﺜﺒﯿﺖ اﻟﺒﺮﻧﺎﻣﺞ وﺟﻌﻠﮫ ﻗﺎﺑﻼ ﻟﻼﺷﺘﻐﺎل ﻋﻠﻰ اﻟﺤﺎﺳﻮب‪.‬‬

‫ﻣﺜﻼ إذا ﻃﻠﺒﺖ ﻣﻨﻚ أن ﺗﺤﺴﺐ ﻟﻲ ﻣﺠﻤﻮع ﻋﺪدﯾﻦ‪ ،‬ﻓﺄﻧﺖ ﺗﻠﻘﺎﺋﯿﺎ ﺗﻄﺒﻖ ﺧﻮارزﻣﯿﺔ ﺗﻘﻮم ﺑﺄﺧﺬ‬

‫اﻟﻌﺪدﯾﻦ وإﺟﺮاء ﻋﻤﻠﯿﺔ اﻟﺠﻤﻊ ﻋﻠﯿﮭﻤﺎ ﺛﻢ إﻋﺎدة اﻟﻨﺘﯿﺠﺔ‪ ،‬ھﺬا ﺑﺎﺧﺘﺼﺎر ھﻮ ﻣﻔﮭﻮم‬

‫اﻟﺨﻮارزﻣﯿﺎت‪.‬‬

‫‪ ‬‬
‫ﻓﻲ اﻟﺒﺮﻣﺠﺔ‪ ،‬ﺗﻌﺘﺒﺮ ﺧﻮارزﻣﯿﺔً ﻛﻞ ﻣﺠﻤﻮﻋﺔ أواﻣﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﺤﻮﯾﻞ إﻟﻰ ﻟﻐﺔ ﺑﺮﻣﺠﯿﺔ‪ ،‬واﻟﺘﻲ‬

‫ﺗﺆدي دورا ﻣﻌﯿﻨﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬وﺗﺄﺗﻲ ﻣﺮﺣﻠﺔ إﻋﺪاد اﻟﺨﻮارزﻣﯿﺔ ﻣﺒﺎﺷﺮة ﺑﻌﺪ ﻣﺸﻜﻞ أو ﺣﺎﺟﺔ‪،‬‬

‫ﻓﺤﯿﻨﻤﺎ ﯾﻄﻠﺐ ﻣﻨﻚ ﻋﻤﯿﻞ إﻧﺠﺎز ﺑﺮﻧﺎﻣﺞ ﯾﻌﻤﻞ ﺷﻐﻼ ﻣﻌﯿﻨﺎ‪ ،‬ﻓﮭﻮ ﯾﻀﻊ أﻣﺎﻣﻚ ﻣﺸﻜﻠﺔ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻚ‪،‬‬

‫وﺣﺎﺟﺔ ﺑﺎﻟﻨﺴﺒﺔ ﻟﮫ‪ ،‬وأﻧﺖ ﺑﺼﻔﺘﻚ ﻣﺒﺮﻣﺠﺎ‪ ،‬ﻋﻠﯿﻚ ﺗﺤﻮﯾﻞ ﺣﺎﺟﺔ اﻟﻌﻤﯿﻞ ﻣﻦ ﻛﻼم ﺑﺸﺮي إﻟﻰ‬

‫‪50‬‬
‫أواﻣﺮ ﻣﻨﻄﻘﯿﺔ وﻣﺘﺴﻠﺴﻠﺔ )أي إﻧﺸﺎء اﻟﺨﻮارزﻣﯿﺔ اﻟﻤﻨﺎﺳﺒﺔ( ﺛﻢ ﺗﺤﻮل ھﺬه اﻟﺨﻮارزﻣﯿﺔ إﻟﻰ‬

‫ﺑﺮﻧﺎﻣﺞ ﺑﻮاﺳﻄﺔ إﺣﺪى ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ‪ ،‬اﻟﺸﻲء اﻟﺬي ﯾﻤﻜﻦ ﺗﻠﺨﯿﺼﮫ ﻓﻲ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬

‫‪ ‬‬

‫‪ ‬‬
‫‪ ‬‬
‫‪ ‬‬

‫‪51‬‬
 ‫‪‬‬
‫ﻹﻧﺸﺎء أﯾﺔ ﺧﻮارزﻣﯿﺔ‪ ،‬ﻓﺈﻧﻚ ﻣﻠﺰم ﺑﺎﻟﺘﻌﺮف ﻋﻠﻰ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﻔﺎھﯿﻢ واﻟﺘﻘﻨﯿﺎت اﻟﺘﻲ ﻋﻠﯿﻚ‬

‫اﺳﺘﺨﺪاﻣﮭﺎ ﻣﻦ أﺟﻞ وﺿﻊ ﺧﻮارزﻣﯿﺔ ﻗﺎﺑﻠﺔ ﻟﻠﺘﺤﻮﯾﻞ إﻟﻰ ﺑﺮﻧﺎﻣﺞ ﺑﺸﻜﻞ ﺻﺤﯿﺢ‪ ،‬وأوﻟﻰ ھﺬه‬

‫اﻟﻤﻔﺎھﯿﻢ أن ﻛﻞ ﺧﻮارزﻣﯿﺔ ﻟﮭﺎ ﺑﺪاﯾﺔ وﻟﮭﺎ ﻧﮭﺎﯾﺔ‪ ،‬وﺑﯿﻦ ھﺬﯾﻦ اﻟﻄﺮﻓﯿﻦ ﻧﻜﺘﺐ ﻣﺤﺘﻮى‬

‫اﻟﺨﻮارزﻣﯿﺔ اﻟﺬي ﯾﺆدي إﻟﻰ اﻟﺤﺼﻮل ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ اﻟﻤﺘﻮﺧﺎة‪ ،‬ﻟﺬﻟﻚ وﺟﺐ وﺿﻊ ﺧﻄﻮات أﯾﺔ‬

‫ﺧﻮارزﻣﯿﺔ ﺑﯿﻦ اﻷﻣﺮﯾﻦ اﻟﺘﺎﻟﯿﯿﻦ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬

‫‪//‬ھﻨﺎ ﯾﻜﺘﺐ ﻣﺤﺘﻮى اﻟﺨﻮارزﻣﯿﺔ‬

‫اﻟﻨﮭﺎﯾﺔ‬

‫‪BEGIN‬‬

‫‪//Program Instructions‬‬

‫‪END‬‬
‫‪Variables‬‬

‫ﻟﻨﻔﺘﺮض أن اﻟﻌﻤﯿﻞ ﻃﻠﺐ ﻣﻨﻚ ﺑﺮﻧﺎﻣﺠﺎ ﯾﻘﺮأ رﻗﻤﯿﻦ‪ ،‬ﺛﻢ ﯾﻄﺒﻊ أﻛﺒﺮھﻤﺎ )ﺑﻤﻌﻨﻰ أﻧﮫ ﯾﺮﯾﺪ ﻣﻨﻚ أن‬

‫ﺗﻨﺸﻰء ﺑﺮﻧﺎﻣﺠﺎ ﯾﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم أن ﯾﺪﺧﻞ رﻗﻤﯿﻦ ﻛﺘﺎﺑﺔً ﻣﻦ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﯿﺢ أو ﻣﻦ أي وﺳﯿﻠﺔ‬

‫إدﺧﺎل أﺧﺮى‪ ،‬ﻓﯿﺴﺘﻘﺒﻞ اﻟﺒﺮﻧﺎﻣﺞ ھﺬﯾﻦ اﻟﺮﻗﻤﯿﻦ وﯾﻘﺎرﻧﮭﻤﺎ داﺧﻠﯿﺎ وﯾﻄﺒﻊ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ‪Screen‬‬

‫ﻗﯿﻤﺔ أﻛﺒﺮ رﻗﻢ(‪.‬‬

‫ﻛﻤﺎ ﺗﻈﮭﺮ اﻟﺼﻮرة اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫‪52‬‬
‫أول ﺷﻲء ﯾﻨﺒﻐﻲ أن ﺗﻔﻜﺮ ﻓﯿﮫ‪ ،‬ھﻮ أﻧﻚ ﺳﺘﺤﺘﺎج إﻟﻰ ﻋﺪدﯾﻦ ﻟﻠﻘﯿﺎم ﺑﻌﻤﻠﯿﺔ اﻟﻤﻘﺎرﻧﺔ‪ ،‬وھﺬان‬

‫اﻟﻌﺪدان ﻏﯿﺮ ﺛﺎﺑﺘﯿﻦ و ﻏﯿﺮ ﻣﻌﺮوﻓﯿﻦ ﻣﺴﺒﻘﺎ‪ ،‬ﻷن اﻟﻤﺴﺘﺨﺪم ھﻮ اﻟﺬي ﺳﯿﺪﺧﻠﮭﻤﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ‪،‬‬

‫وأﻧﺖ ﻻ ﯾﻤﻜﻨﻚ اﻟﺘﻜﮭﻦ ﺑﮭﻤﺎ‪ ،‬ﻟﺬا ﻓﺈﻧﻚ ﺳﺘﺤﺘﺎج إﻟﻰ ﺣﺎوﯾﺎت ﻓﻲ اﻟﺬاﻛﺮة ﺗﻀﻊ ﻓﯿﮭﺎ اﻟﻘﯿﻢ اﻟﻤﺪﺧﻠﺔ‬

‫ﻟﻜﻲ ﺗﻘﺎرﻧﮭﺎ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻚ‪ ،‬وﻟﻠﻮﻟﻮج إﻟﻰ ھﺬه اﻟﺤﺎوﯾﺎت ﻓﺄﻧﺖ ﺗﺤﺘﺎج إﻟﻰ إﻋﻄﺎﺋﮭﺎ أﺳﻤﺎء ﻣﻤﯿﺰة‬

‫وﻏﯿﺮ ﻣﺘﺸﺎﺑﮭﺔ‪ ،‬وﻛﺬﻟﻚ ﺗﺤﺘﺎج إﻟﻰ ﺗﺤﺪﯾﺪ ﻧﻮع اﻟﻘﯿﻤﺔ اﻟﻤﺮاد ﺗﺨﺰﯾﻨﮭﺎ ﻓﻲ ﻛﻞ ﺣﺎوﯾﺔ‪.‬‬

‫اﻟﻘﯿﻢ اﻟﺘﻲ ﻧﺠﮭﻠﮭﺎ وﻻ ﻧﺪري ﻗﯿﻤﺘﮭﺎ ﻣﺴﺒﻘﺎ‪ ،‬وﻧﺤﺘﺎج إﻟﻰ ﺗﺤﺪﯾﺪ ﻧﻮع ﻟﮭﺎ وﺗﺨﺰﯾﻨﮭﺎ ﻓﻲ اﻟﺬاﻛﺮة‬

‫ﺗﺴﻤﻰ ﻣﺘﻐﯿﺮات أو ﻣﺘﺤﻮﻻت‪ ،‬أي أن ﻗﯿﻤﺘﮭﺎ ﻟﯿﺴﺖ ﺛﺎﺑﺘﺔ‪ ،‬وأﻧﮭﺎ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻐﯿﯿﺮ اﻟﻤﺴﺘﻤﺮ أﺛﻨﺎء‬

‫ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬

‫إذن‪ ،‬ﻓﺎﻟﻤﺘﻐﯿﺮات ھﻲ ﻗﯿﻢ ﯾﺤﺘﺎﺟﮭﺎ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﻧﻨﺸﺆه ﻣﻦ أﺟﻞ إﻧﺠﺎز ﻋﻤﻠﯿﺎت ﻣﻌﯿﻨﺔ ﻋﻠﯿﮭﺎ‪،‬‬

‫واﻟﻤﺴﺘﺨﺪم ھﻮ ﻣﻦ ﯾﻘﻮم ﺑﺈدﺧﺎل ھﺬه اﻟﻘﯿﻢ إﻟﻰ اﻟﺒﺮﻧﺎﻣﺞ )ﻋﺒﺮ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﯿﺢ ﻣﺜﻼ(‪ ،‬وﯾﻤﻜﻦ ﻟﻠﻘﯿﻢ‬

‫اﻟﻤﺪﺧﻠﺔ أن ﺗﻜﻮن ﻣﻦ أﻧﻮاع ﺷﺘﻰ‪ ،‬إﻣﺎ رﻗﻤﯿﺔ‪ ،‬أو ﻧﺼﯿﺔ‪ ،‬أو ﻋﺒﺎرة ﻋﻦ ﺗﺎرﯾﺦ‪...،‬‬

‫‪53‬‬
 ‫‪‬‬
‫اﻹﻋﻼن ﻋﻦ ﻣﺘﻐﯿﺮ ﯾﻌﻨﻲ ﺣﺠﺰ ﻣﻜﺎن ﻓﻲ اﻟﺬاﻛﺮة ﻣﻦ أﺟﻞ ﺗﺨﺰﯾﻦ ﻗﯿﻤﺔ ﻣﻌﯿﻨﺔ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻐﯿﺮ ﻓﻲ‬

‫زﻣﻦ اﻟﺘﻨﻔﯿﺬ ‪) Runtime‬اﻟﻤﻘﺼﻮد ﺑﺰﻣﻦ اﻟﺘﻨﻔﯿﺬ اﻟﻮﻗﺖ اﻟﺬي ﯾﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﺷﻐﺎﻻ(‪،‬‬

‫وﯾﻜﻮن ﺑﮭﺬا اﻟﺸﻜﻞ‪:‬‬

‫]ﻧﻮع اﻟﺒﯿﺎﻧﺎت[ اﺳﻢ_اﻟﻤﺘﻐﯿﺮ؛‬

‫; ‪[DATA_TYPE] VariableName‬‬

‫ﻓﻲ اﻟﺠﺰء اﻟﺨﺎص ﺑﺎﻟﻜﻠﻤﺔ ]ﻧﻮع اﻟﺒﯿﺎﻧﺎت[ ﻧﻀﻊ ﻧﻮع اﻟﻘﯿﻤﺔ اﻟﻤﺮاد ﺗﺨﺰﯾﻨﮭﺎ ﻓﻲ اﻟﻤﺘﻐﯿﺮ ﻣﺜﻼ ‪:‬‬

‫أرﻗﺎم‪ ،‬ﺣﺮوف‪ ،‬ﻧﺼﻮص )اﻟﻨﺺ ھﻮ ﻣﺠﻤﻮﻋﺔ ﺣﺮوف وأرﻗﺎم(‪ ،‬ﻧﻮع ﺗﺎرﯾﺨﻲ )وﻗﺖ أو ﺗﺎرﯾﺦ‬

‫أو ھﻤﺎ ﻣﻌﺎ(‪ ،‬ﻧﻮع ﻣﻨﻄﻘﻲ )ﯾﻘﺒﻞ ﻗﯿﻤﺘﯿﻦ ﻣﺘﻌﺎرﺿﺘﯿﻦ وھﻤﺎ‪ :‬ﺻﺤﯿﺢ أو ﺧﻄﺄ(‪ ،‬وﻏﯿﺮھﺎ‪...‬‬

‫واﻟﺠﺰء اﻟﺨﺎص ﺑﺎﻟﻜﻠﻤﺔ اﺳﻢ_اﻟﻤﺘﻐﯿﺮ ﻧﻀﻊ اﻻﺳﻢ اﻟﺬي ﻧﺮﯾﺪ إﻋﻄﺎءه ﻟﻠﻤﺘﻐﯿﺮ ﻟﻜﻲ ﻧﺘﻤﻜﻦ ﻣﻦ‬

‫اﺳﺘﻌﻤﺎﻟﮫ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻨﺎ‪ ،‬واﻟﻔﺎﺻﻠﺔ اﻟﻤﻨﻘﻮﻃﺔ ﻓﻲ آﺧﺮ اﻟﺴﻄﺮ ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ أن اﻷﻣﺮ اﻧﺘﮭﻰ وأن‬

‫اﻟﺴﻄﺮ ﻣﻜﺘﻤﻞ‪ ،‬وھﺬه أﻣﺜﻠﺔ ﻟﻜﯿﻔﯿﺔ اﻹﻋﻼن ﻋﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﺘﻐﯿﺮات‪:‬‬

‫‪//‬اﻹﻋﻼن ﻋﻦ ﻣﺘﻐﯿﺮ رﻗﻤﻲ اﺳﻤﮫ اﻟﺮﻗﻢ_‪1‬‬ ‫رﻗﻤﻲ اﻟﺮﻗﻢ_‪1‬؛‬

‫‪//‬اﻹﻋﻼن ﻋﻦ ﻣﺘﻐﯿﺮ ﻧﺼﻲ اﺳﻤﮫ اﻟﻨﺺ_‪1‬‬ ‫ﻧﺼﻲ اﻟﻨﺺ_‪1‬؛‬

‫‪//‬اﻹﻋﻼن ﻋﻦ ﻣﺘﻐﯿﺮ ﺣﺮﻓﻲ اﺳﻤﮫ اﻟﺤﺮف_‪1‬‬ ‫ﺣﺮﻓﻲ ﺣﺮف_‪1‬؛‬

‫‪//‬اﻹﻋﻼن ﻋﻦ ﻣﺘﻐﯿﺮ ﺗﺎرﯾﺨﻲ اﺳﻤﮫ ﺗﺎرﯾﺦ_اﻟﻤﯿﻼد‬ ‫ﺗﺎرﯾﺨﻲ ﺗﺎرﯾﺦ_اﻟﻤﯿﻼد؛‬

‫‪//‬اﻹﻋﻼن ﻋﻦ ﻣﺘﻐﯿﺮ ﻣﻨﻄﻘﻲ اﺳﻤﮫ ﻣﺘﻐﯿﺮ_ﻣﻨﻄﻘﻲ_‪1‬‬ ‫ﻣﻨﻄﻘﻲ ﻣﺘﻐﯿﺮ_ﻣﻨﻄﻘﻲ_‪1‬؛‬

‫‪54‬‬
 ‫; ‪Int Number1‬‬ ‫‪//Declare Integer Variable‬‬

‫; ‪String Text1‬‬ ‫‪//Declare‬‬ ‫‪String Variable‬‬

‫; ‪Char Char1‬‬ ‫‪//Declare Char Variable‬‬

‫; ‪Date Date1‬‬ ‫‪//Declare Date Variable‬‬

‫; ‪Boolean Bool1‬‬ ‫‪//Declare Boolean Variable‬‬

‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼه ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼن ﻋﻦ ﻋﺪة ﻣﺘﻐﯿﺮات‪ ،‬ﻟﻜﻨﻨﺎ ﻟﻢ ﻧﻌﻄﮭﺎ ﻗﯿﻤﺎ ﺑﺪﺋﯿﺔ‪ ،‬ﺑﻤﻌﻨﻰ أن أﻣﺎﻛﻦ‬

‫ھﺬه اﻟﻤﺘﻐﯿﺮات ﻓﻲ اﻟﺬاﻛﺮة ﻣﺎ ﺗﺰال ﻓﺎرﻏﺔ ‪ ،null‬وﯾﻠﺰﻣﻨﺎ إﻋﻄﺎؤھﺎ ﻗﯿﻤﺎ ﻟﻜﻲ ﻧﺴﺘﺨﺪﻣﮭﺎ‪ ،‬وھﺬه‬

‫اﻟﻘﯿﻢ إﻣﺎ أن ﺗﻜﻮن ﺑﺪﺋﯿﺔ ﯾﺤﺪدھﺎ اﻟﻤﺒﺮﻣﺞ ﻓﻲ ﺑﺪاﯾﺔ اﻹﻋﻼن ﻋﻦ اﻟﻤﺘﻐﯿﺮات‪ ،‬أو ﺗﻜﻮن ﺧﻼل‬

‫ﻣﺮﺣﻠﺔ ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺤﯿﺚ ﺗﺤﺼﻞ اﻟﻤﺘﻐﯿﺮات ﻋﻠﻰ ﻗﯿﻤﮭﺎ ﻣﻦ ﺧﻼل ﻣﺪﺧﻼت اﻟﻤﺴﺘﺨﺪﻣﯿﻦ‪.‬‬

‫أﯾﻀﺎ ﯾﻤﻜﻨﻨﺎ اﻻﻋﻼن ﻋﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﺘﻐﯿﺮات ذات ﻧﻔﺲ ﻧﻮع اﻟﺒﯿﺎﻧﺎت ﻓﻲ ﺳﻄﺮ واﺣﺪ‪ ،‬ﻛﻤﺎ‬

‫ﯾﻌﺮض اﻟﻤﺜﺎل اﻵﺗﻲ‪:‬‬

‫رﻗﻤﻲ اﻟﺮﻗﻢ_‪ ،1‬اﻟﺮﻗﻢ_‪ ،2‬اﻟﺮﻗﻢ_‪ ،3‬اﻟﺮﻗﻢ_‪4‬؛‬

‫; ‪Int Number1, Number2, Number3, Number4‬‬

‫‪‬‬
‫ﻹﺳﻨﺎد ﻗﯿﻤﺔ ﺑﺪﺋﯿﺔ ﻷي ﻣﺘﻐﯿﺮ‪ ،‬ﻓﺈن اﻟﻄﺮﯾﻘﺔ ﺗﻜﻮن ﻋﺒﺮ اﺳﺘﺨﺪام رﻣﺰ اﻟﺴﮭﻢ ) → ( ﺛﻢ ﺑﻌﺪه‬

‫اﻟﻘﯿﻤﺔ اﻟﻤﺮاد إﻋﻄﺎؤھﺎ ﻟﻠﻤﺘﻐﯿﺮ‪ ،‬وﯾﻤﻜﻦ ﻋﻤﻞ ذﻟﻚ ﻓﻲ زﻣﻦ اﻹﻋﻼن‪ ،‬وﻛﺬﻟﻚ ﺑﻌﺪ اﻹﻋﻼن‪،‬‬

‫وھﺬه أﻣﺜﻠﺔ ﺗﻮﺿﺢ ھﺬا اﻟﻜﻼم‪:‬‬

‫‪55‬‬
 ‫‪ //‬إﺳﻨﺎد ﻗﯿﻤﺔ ﻟﻠﻤﺘﻐﯿﺮ ﻋﻨﺪ اﻹﻋﻼن ﻋﻨﮫ‬ ‫رﻗﻤﻲ اﻟﺮﻗﻢ_اﻷول → ‪156‬؛‬
‫رﻗﻤﻲ اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ؛‬
‫‪//‬اﻹﻋﻼن ﻋﻦ اﻟﻤﺘﻐﯿﺮ أوﻻ ﺛﻢ إﺳﻨﺎد ﻗﯿﻤﺔ ﻟﮫ ﺑﻌﺪ ذﻟﻚ‬ ‫اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ → ‪48‬؛‬

‫; ‪Int First_Number ← 156‬‬ ‫‪ //‬إﺳﻨﺎد ﻗﯿﻤﺔ ﻟﻠﻤﺘﻐﯿﺮ ﻋﻨﺪ اﻹﻋﻼن ﻋﻨﮫ‬

‫; ‪Int Second_Number‬‬
‫; ‪Second_Number ← 48‬‬ ‫‪//‬اﻹﻋﻼن ﻋﻦ اﻟﻤﺘﻐﯿﺮ أوﻻ ﺛﻢ إﺳﻨﺎد ﻗﯿﻤﺔ ﻟﮫ ﺑﻌﺪ ذﻟﻚ‬

‫ﻓﻲ اﻟﺴﻄﺮ اﻷول أﻋﻄﯿﻨﺎ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻷول اﻟﻘﯿﻤﺔ ‪ 156‬ﻓﻲ ﻧﻔﺲ وﻗﺖ اﻹﻋﻼن‪ ،‬وﻓﻲ‬

‫اﻟﺴﻄﺮ اﻟﺜﺎﻧﻲ ﻗﻤﻨﺎ ﺑﺈﻋﻄﺎء ﻗﯿﻤﺔ ﻟﻠﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ ﺑﻌﺪ اﻹﻋﻼن ﻋﻨﮫ‪ ،‬ﻻﺣﻆ أن اﻟﻤﺘﻐﯿﺮات‬

‫اﻟﺮﻗﻤﯿﺔ ﺗﺴﺘﻘﺒﻞ اﻟﻘﯿﻢ ﺑﺸﻜﻞ ﻣﺒﺎﺷﺮ‪ ،‬ﺑﯿﻨﻤﺎ اﻟﻤﺘﻐﯿﺮات اﻟﻨﺼﯿﺔ ﻓﯿﻠﺰﻣﻨﺎ اﺳﺘﺨﺪام ﻋﻼﻣﺎت‬

‫اﻟﺘﻨﺼﯿﺺ )" "( ووﺿﻊ اﻟﻨﺺ داﺧﻠﮭﻤﺎ‪ ،‬ﻛﻤﺎ ﺗﻮﺿﺢ اﻷﻣﺜﻠﺔ اﻵﺗﯿﺔ‪:‬‬

‫ﻧﺼﻲ اﻻﺳﻢ_اﻟﻜﺎﻣﻞ → "ﺧﺎﻟﺪ اﻟﺴﻌﺪاﻧﻲ"؛ ‪ //‬إﺳﻨﺎد ﻗﯿﻤﺔ ﻟﻠﻤﺘﻐﯿﺮ ﻋﻨﺪ اﻹﻋﻼن ﻋﻨﮫ‬
‫ﻧﺼﻲ اﻟﺠﻨﺴﯿﺔ؛‬
‫‪//‬اﻹﻋﻼن ﻋﻦ اﻟﻤﺘﻐﯿﺮ أوﻻ ﺛﻢ إﺳﻨﺎد ﻗﯿﻤﺔ ﻟﮫ ﺑﻌﺪ ذﻟﻚ‬ ‫اﻟﺠﻨﺴﯿﺔ → "ﻣﻐﺮﺑﻲ"؛‬

‫;"ﺧﺎﻟﺪ اﻟﺴﻌﺪاﻧﻲ" ← ‪String FullName‬‬ ‫‪ //‬إﺳﻨﺎد ﻗﯿﻤﺔ ﻟﻠﻤﺘﻐﯿﺮ ﻋﻨﺪ اﻹﻋﻼن ﻋﻨﮫ‬
‫; ‪String Nationality‬‬
‫;"ﻣﻐﺮﺑﻲ" ← ‪Nationality‬‬ ‫‪//‬اﻹﻋﻼن ﻋﻦ اﻟﻤﺘﻐﯿﺮ أوﻻ ﺛﻢ إﺳﻨﺎد ﻗﯿﻤﺔ ﻟﮫ ﺑﻌﺪ ذﻟﻚ‬
‫ﻣﻠﺤﻮﻇﺔ‪:‬‬

‫ﯾﻤﻜﻨﻨﺎ إﺳﻨﺎد ﻗﯿﻤﺔ ﻣﺘﻐﯿﺮ إﻟﻰ ﻣﺘﻐﯿﺮ آﺧﺮ ﺑﻨﻔﺲ اﻟﻄﺮﯾﻘﺔ‪:‬‬

‫‪56‬‬
 ‫رﻗﻤﻲ اﻟﺮﻗﻢ_اﻷول → ‪156‬؛‬
‫رﻗﻤﻲ اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ؛‬
‫اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ → اﻟﺮﻗﻢ_اﻷول؛‬

‫; ‪Int First_Number ← 156‬‬

‫; ‪Int Second_Number‬‬
‫; ‪Second_Number ← First_Number‬‬
‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼه ﺗﻢ ﻧﻘﻞ ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻷول إﻟﻰ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ وﺑﺎﻟﺘﺎﻟﻲ ﺳﺘﺼﺒﺢ‬

‫ﻗﯿﻤﺔ ھﺬا اﻷﺧﯿﺮ ھﻲ ‪.156‬‬

‫وﻟﻜﻲ ﯾﺴﮭﻞ ﻋﻠﯿﻚ ﻣﻌﺮﻓﺔ ﻣﻦ أﯾﻦ ﺗﻨﻘﻞ اﻟﻘﯿﻤﺔ إﻟﻰ أﯾﻦ اﺗﺒﻊ داﺋﻤﺎ ﻣﺴﺎر اﻟﺴﮭﻢ‪:‬‬

‫اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ → اﻟﺮﻗﻢ_اﻷول؛ اﻟﺴﮭﻢ ﯾﺸﯿﺮ إﻟﻰ أن ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻷول ﺳﺘﻨﺘﻘﻞ إﻟﻰ‬

‫اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ‪.‬‬

‫‪57‬‬
 ‫‪‬‬
‫وﯾﻘﺼﺪ ﺑﺈﺧﺮاج اﻟﺒﯿﺎﻧﺎت ﻋﻤﻠﯿﺔ ﻃﺒﺎﻋﺔ ﻧﺺ ﻣﻌﯿﻦ أو ﻗﯿﻤﺔ ﻣﺘﻐﯿﺮ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﻤﺴﺘﺨﺪم‪ ،‬وﻓﻲ‬

‫اﻟﺨﻮارزﻣﯿﺎت ﻧﺴﺘﺨﺪم اﻷﻣﺮ‪ :‬اﻛﺘﺐ وﻧﻔﺘﺢ اﻟﻘﻮﺳﯿﻦ‪ ،‬ﺛﻢ ﻧﻀﻊ اﻟﻨﺺ اﻟﻤﺮاد إﻇﮭﺎره ﻟﻠﻤﺴﺘﺨﺪم‬

‫ﺑﯿﻦ ﻣﺰدوﺟﺘﯿﻦ‪ ،‬ﻛﻤﺎ ﯾﻌﺮض اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬

‫‪ //‬إﻇﮭﺎر ﻧﺺ ﻋﺎدي‬

‫اﻛﺘﺐ)"اﻟﺴﻼم ﻋﻠﯿﻜﻢ ﻓﻲ ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﺔ"(؛‬

‫‪ //‬إﻇﮭﺎر ﻗﯿﻤﺔ ﻣﺘﻐﯿﺮ‬

‫ﻧﺼﻲ رﺳﺎﻟﺔ → "اﻟﺼﺒﺮ ﻣﻔﺘﺎح اﻟﻔﺮج"؛‬

‫اﻛﺘﺐ)رﺳﺎﻟﺔ(؛‬

‫إﻇﮭﺎر ﻧﺺ ﻋﺎدي‪//‬‬

‫; )"اﻟﺴﻼم ﻋﻠﯿﻜﻢ ﻓﻲ ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﺔ"(‪WRITE‬‬

‫إﻇﮭﺎر ﻗﯿﻤﺔ ﻣﺘﻐﯿﺮ‪//‬‬

‫;"ﺧﺎﻟﺪ اﻟﺴﻌﺪاﻧﻲ" ← ‪String FullName‬‬

‫; )‪WRITE(FullName‬‬

‫‪ ‬‬

‫‪58‬‬
 ‫‪‬‬
‫اﻟﻤﻘﺼﻮد ﺑﻘﺮاءة اﻟﻤﺪﺧﻼت ھﻮ ﻛﯿﻔﯿﺔ إدﺧﺎل اﻟﻘﯿﻢ اﻟﻤﻜﺘﻮﺑﺔ ﻣﻦ ﻃﺮف اﻟﻤﺴﺘﺨﺪم إﻟﻰ اﻟﺒﺮﻧﺎﻣﺞ‬

‫ﻟﻜﻲ ﻧﺘﻌﺎﻣﻞ ﻣﻌﮭﺎ‪ ،‬ﻛﺄن ﻧﻜﻮن ﺑﺼﺪد اﻟﻘﯿﺎم ﺑﻌﻤﻠﯿﺔ اﻟﺠﻤﻊ وﻧﻄﻠﺐ ﻣﻨﮫ أن ﯾﺪﺧﻞ رﻗﻤﯿﻦ‪ ،‬ﻓﻌﻤﻠﯿﺔ‬

‫اﻹدﺧﺎل ھﺬه ﺗﺤﺘﺎج ﻣﻨﺎ إﻟﻰ ﻗﺮاءة اﻟﻘﯿﻢ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻟﻨﻌﯿﺪ ﺻﯿﺎﻏﺘﮭﺎ وﻓﻖ ﻣﺎ ﯾﺤﺘﺎﺟﮫ‬

‫اﻟﺒﺮﻧﺎﻣﺞ ﻣﻨﮭﺎ‪ ،‬وﺗﻜﻮن ﻋﻤﻠﯿﺔ ﻗﺮاءة اﻟﻤﺪﺧﻼت ﻓﻲ اﻟﺨﻮارزﻣﯿﺎت ﻋﺒﺮ اﻟﻜﻠﻤﺔ اﻗﺮأ وﯾﺘﻢ ﻛﺘﺎﺑﺔ‬

‫اﻟﻘﯿﻤﺔ أو اﻟﻤﺘﻐﯿﺮ اﻟﺬي ﺳﯿﺴﺘﻘﺒﻞ اﻟﻘﯿﻤﺔ ﻣﺒﺎﺷﺮة ﺑﻌﺪھﺎ ﺑﯿﻦ ﻗﻮﺳﯿﻦ‪ ،‬ﻛﻤﺎ ﺗﻌﺮض اﻟﻨﻤﺎذج اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬

‫ﻧﺼﻲ اﻻﺳﻢ_اﻟﺸﺨﺼﻲ؛‬

‫اﻛﺘﺐ)"رﺟﺎء أدﺧﻞ اﺳﻤﻚ اﻟﻜﺮﯾﻢ‪(" :‬؛‬

‫‪ //‬ﺗﺨﺰﯾﻦ اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻤﺪﺧﻠﺔ ﻓﻲ اﻟﻤﺘﻐﯿﺮ اﻟﻤﻌﻠﻦ ﻋﻨﮫ‬ ‫اﻗﺮأ) اﻻﺳﻢ_اﻟﺸﺨﺼﻲ( ؛‬

‫اﻛﺘﺐ)"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ﺳﯿﺪ‪(" :‬؛‬

‫اﻛﺘﺐ)اﻻﺳﻢ_اﻟﺸﺨﺼﻲ(؛‬

‫اﻟﻨﮭﺎﯾﺔ‬

‫‪BEGIN‬‬

‫; ‪String FullName‬‬

‫; )"رﺟﺎء أدﺧﻞ اﺳﻤﻚ اﻟﻜﺮﯾﻢ"(‪WRITE‬‬

‫; )‪READ(FullName‬‬ ‫ﺗﺨﺰﯾﻦ اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻤﺪﺧﻠﺔ ﻓﻲ اﻟﻤﺘﻐﯿﺮ اﻟﻤﻌﻠﻦ ﻋﻨﮫ‪//‬‬

‫; )"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ﺳﯿﺪ‪WRITE(" :‬‬

‫; )‪WRITE(FullName‬‬

‫‪END‬‬

‫‪59‬‬
‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼه ﯾﻈﮭﺮ اﻟﺒﺮﻧﺎﻣﺞ رﺳﺎﻟﺔ ﯾﻄﻠﺐ ﻓﯿﮭﺎ ﻣﻦ اﻟﻤﺴﺘﺨﺪم إدﺧﺎل اﺳﻤﮫ اﻟﺸﺨﺼﻲ‪،‬‬

‫وﺣﯿﻨﻤﺎ ﯾﺘﻢ ﻛﺘﺎﺑﺔ اﻻﺳﻢ‪ ،‬ﯾﺘﻢ ﻗﺮاءﺗﮫ وﺗﺨﺰﯾﻨﮫ ﻓﻲ اﻟﻤﺘﻐﯿﺮ اﻟﻤﺴﻤﻰ اﻻﺳﻢ_اﻟﺸﺨﺼﻲ ‪ ،‬وﺑﻌﺪ ذﻟﻚ‬

‫ﯾﻌﯿﺪ اﻟﺒﺮﻧﺎﻣﺞ ﻃﺒﺎﻋﺔ اﻻﺳﻢ ﻣﺴﺒﻮﻗﺎ ﺑﻌﺒﺎرة ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ﺳﯿﺪ‪.:‬‬

‫‪ /‬‬
‫اﻟﺮواﺑﻂ أو اﻟﻤﻌﺎﻣﻼت ھﻲ رﻣﻮز ﻧﺴﺘﺨﺪﻣﮭﺎ ﻹﺟﺮاء ﺑﻌﺾ اﻟﻌﻤﻠﯿﺎت ﻋﻠﻰ اﻟﻤﺘﻐﯿﺮات أو ﻋﻠﻰ‬

‫اﻟﻘﯿﻢ ﺑﺼﻔﺔ ﻋﺎﻣﺔ ﻣﺜﻞ اﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ‪ ،‬أو ﻋﻤﻠﯿﺎت ﻣﻘﺎرﻧﺔ اﻟﻘﯿﻢ )ﺗﺤﺪﯾﺪ اﻟﻘﯿﻤﺔ اﻟﻜﺒﺮى‬

‫واﻟﻘﯿﻤﺔ اﻟﺼﻐﺮى( وﻏﯿﺮ ذﻟﻚ‪.‬‬

‫اﻟﺮواﺑﻂ اﻟﺤﺴﺎﺑﯿﺔ أو اﻟﺮﯾﺎﺿﯿﺔ ‪:Arithmetic operators‬‬

‫وھﺬا ﺟﺪول رﻣﻮز اﻟﺮواﺑﻂ وأﻣﺎﻣﮭﺎ اﻟﺪور اﻟﻤﻨﻮط ﺑﮭﺎ‪:‬‬

‫دوره‬ ‫اﻟﺮاﺑﻂ‬
‫اﻟﺠﻤﻊ‬ ‫‪+‬‬
‫اﻟﻄﺮح‬ ‫‪-‬‬
‫اﻟﺠﺪاء‬ ‫*‬
‫اﻟﻘﺴﻤﺔ‬ ‫‪/‬‬
‫اﻟﻘﺴﻤﺔ اﻟﺼﺤﻴﺤﺔ اﻟﻄﺒﻴﻌﻴﺔ‬ ‫\‬
‫ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ‬ ‫‪%‬‬
‫اﻟﻘﻮة‬ ‫^‬

‫اﻟﺮواﺑﻂ اﻟﻈﺎھﺮة أﻋﻼه ھﻲ رﻣﻮز ﻧﺴﺘﺨﺪﻣﮭﺎ ﺣﯿﻨﻤﺎ ﻧﻮد اﻟﻘﯿﺎم ﺑﻌﻤﻠﯿﺔ ﺣﺴﺎﺑﯿﺔ ﻋﻠﻰ ﻗﯿﻤﺘﯿﻦ أو‬

‫أﻛﺜﺮ‪ ،‬وھﺬه أﻣﺜﻠﺔ ﻋﻠﻰ اﺳﺘﺨﺪام اﻟﺮواﺑﻂ أﻋﻼه‪:‬‬

‫‪60‬‬
 ‫اﻟﺒﺪاﯾﺔ‬
‫رﻗﻤﻲ اﻟﺮﻗﻢ_اﻷول‪ ،‬اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ؛‬
‫اﻟﺮﻗﻢ_اﻷول → ‪25‬؛‬
‫اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ → ‪5‬؛‬

‫‪ //‬اﺳﺘﺨﺪام اﻟﺮواﺑﻂ ﻟﺤﺴﺎب ﻗﯿﻢ اﻟﻤﺘﻐﯿﺮﯾﻦ اﻟﺴﺎﺑﻘﯿﻦ‬

‫‪//‬اﻟﺠﻤﻊ‬
‫رﻗﻤﻲ اﻟﺠﻤﻊ → اﻟﺮﻗﻢ_اﻷول ‪ +‬اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ؛‬

‫‪//‬اﻟﻄﺮح‬
‫رﻗﻤﻲ اﻟﻄﺮح → اﻟﺮﻗﻢ_اﻷول ‪ -‬اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ؛‬

‫‪//‬اﻟﻀﺮب‬
‫رﻗﻤﻲ اﻟﻀﺮب → اﻟﺮﻗﻢ_اﻷول * اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ؛‬

‫‪//‬اﻟﻘﺴﻤﺔ‬
‫رﻗﻤﻲ اﻟﻘﺴﻤﺔ → اﻟﺮﻗﻢ_اﻷول ‪ /‬اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ؛‬

‫‪//‬اﻟﻘﻮة ‪Power‬‬
‫رﻗﻤﻲ اﻟﻘﻮة → اﻟﺮﻗﻢ_اﻷول ^ اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ؛‬

‫‪//‬ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ‪Modulo‬‬

‫رﻗﻤﻲ اﻟﺒﺎﻗﻲ → اﻟﺮﻗﻢ_اﻷول ‪ %‬اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ؛‬
‫اﻟﻨﮭﺎﯾﺔ‬

‫‪61‬‬
 BEGIN
Int First_Number, Second_Number ;
First_Number ← 25 ;
Second_Number ← 5 ;

//‫اﺳﺘﺨﺪام اﻟﺮواﺑﻂ ﻟﺤﺴﺎب ﻗﯿﻢ اﻟﻤﺘﻐﯿﺮﯾﻦ اﻟﺴﺎﺑﻘﯿﻦ‬

//‫اﻟﺠﻤﻊ‬
Int Sum ← First_Number + Second_Number ;

//‫اﻟﻄﺮح‬
Int Substract ← First_Number - Second_Number ;

//‫اﻟﻀﺮب‬
Int Multiplication ← First_Number * Second_Number ;

//‫اﻟﻘﺴﻤﺔ‬
Int Division ← First_Number / Second_Number ;

// ‫اﻟﻘﻮة‬Power
Int Power ← First_Number ^ Second_Number ;

// ‫ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ‬Modulo
Int Modulo ← First_Number % Second_Number ;

END

‫اﻟﻤﺘﻐﯿﺮ اﻟﺠﻤﻊ ﯾﻘﻮم ﺑﺠﻤﻊ ﻗﯿﻤﺘﻲ اﻟﻤﺘﻐﯿﺮﯾﻦ اﻟﺮﻗﻢ_اﻷول و اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ ﻣﻦ ﺧﻼل اﺳﺘﺨﺪام‬

.30 ‫ أي‬5 + 25 ‫ أي أن ﻗﯿﻤﺘﮫ ﺳﺘﻜﻮن ھﻲ‬،+ ‫اﻟﺮاﺑﻂ‬

‫اﻟﻤﺘﻐﯿﺮ اﻟﻄﺮح ﯾﻘﻮم ﺑﻄﺮح ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻷول ﻣﻦ ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ ﻋﺒﺮ‬

.20 ‫ أي‬5 - 25 ‫ أي أن ﻗﯿﻤﺘﮫ ﺳﺘﻜﻮن ھﻲ‬، - ‫اﺳﺘﺨﺪام ﻋﻼﻣﺔ ﻧﺎﻗﺺ‬

62
‫اﻟﻤﺘﻐﯿﺮ اﻟﻀﺮب ﯾﻘﻮم ﺑﻀﺮب ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻷول ﻓﻲ ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ ﻋﺒﺮ‬

‫اﺳﺘﻌﻤﺎل اﻟﺮاﺑﻂ *‪ ،‬أي أن ﻗﯿﻤﺘﮫ ﺳﺘﻜﻮن ھﻲ ‪ 5 * 25‬أي ‪.125‬‬

‫اﻟﻤﺘﻐﯿﺮ اﻟﻘﺴﻤﺔ ﯾﻘﻮم ﺑﻘﺴﻤﺔ ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻷول ﻋﻠﻰ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ ﻋﺒﺮ اﺳﺘﺨﺪام‬

‫رﻣﺰ اﻟﻘﺴﻤﺔ‪ ،‬أي أن اﻟﻨﺘﯿﺠﺔ ﺳﺘﻜﻮن ھﻲ ‪ 5 / 25‬أي ‪.5‬‬

‫اﻟﻤﺘﻐﯿﺮ اﻟﻘﻮة ﯾﻘﻮم ﺑﺤﺴﺎب اﻷﺳﺎس اﻟﺮﻗﻢ_اﻷول ذي اﻷس اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ أي أن اﻟﻨﺘﯿﺠﺔ ﺳﺘﻜﻮن‬

‫ھﻲ ‪ ،255‬أي ‪.9765625‬‬

‫اﻟﻤﺘﻐﯿﺮ اﻟﺒﺎﻗﻲ ﯾﻘﻮم ﺑﺤﺴﺎب ﺑﺎﻗﻲ ﻗﺴﻤﺔ ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ اﻟﺮﻗﻢ_اﻷول ﻋﻠﻰ ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ‬

‫اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ ‪ ،‬وﻛﻤﺎ ھﻮ ﻣﻌﻠﻮم ﻓﺒﺎﻗﻲ ﻗﺴﻤﺔ ‪ 25‬ﻋﻠﻰ ‪ 5‬ھﻮ ﺻﻔﺮ ﻷﻧﮫ ﻻ ﯾﺘﺒﻘﻰ ﺷﻲء‪.‬‬

‫رواﺑﻂ دﻣﺞ اﻟﻨﺼﻮص ‪:String Concatenation operators‬‬

‫وﯾﻤﻜﻨﻨﺎ ھﺬا اﻟﻨﻮع ﻣﻦ اﻟﺮواﺑﻂ ﻣﻦ دﻣﺞ ﻧﺼﯿﻦ أو أﻛﺜﺮ ﻣﻊ ﺑﻌﻀﮭﻢ اﻟﺒﻌﺾ‪ ،‬وﯾﻜﻮن ﻣﻦ ﺧﻼل‬

‫اﺳﺘﺨﺪام اﻟﺮﻣﺰ ‪ ،+‬وھﺬا ﻣﺜﺎل ﻋﻠﻰ دﻣﺞ ﻗﯿﻤﺘﯿﻦ ﻧﺼﯿﺘﯿﻦ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫ﻧﺼﻲ اﻟﻨﺺ_اﻷول‪ ،‬اﻟﻨﺺ_اﻟﺜﺎﻧﻲ؛‬
‫اﻟﻨﺺ_اﻷول → "ﻻ ﯾﺠﺘﻤﻊ ﺳﯿﻔﺎن"؛‬
‫اﻟﻨﺺ_اﻟﺜﺎﻧﻲ → "ﻓﻲ ﻏِﻤْﺪٍ واﺣﺪ"؛‬
‫ﻧﺼﻲ اﻟﺪﻣﺞ → اﻟﻨﺺ_اﻷول ‪ +‬اﻟﻨﺺ_اﻟﺜﺎﻧﻲ؛‬
‫اﻛﺘﺐ)اﻟﺪﻣﺞ(؛‬

‫اﻟﻨﮭﺎﯾﺔ‬

‫‪63‬‬
‫‪BEGIN‬‬
‫; ‪String Text1, Text2‬‬

‫; "ﻻ ﯾﺠﺘﻤﻊ ﺳﯿﻔﺎن" ← ‪Text1‬‬

‫; " ﻓﻲ ﻏِﻤْﺪٍ واﺣﺪ" ← ‪Text2‬‬

‫‪String Concat‬‬ ‫;‪← Text1 + Text2‬‬

‫)‪WRITE(Concat‬‬

‫‪END‬‬

‫اﻵن ﺻﺎرت اﻟﻘﯿﻤﺔ ﻻ ﯾﺠﺘﻤﻊ ﺳﯿﻔﺎن ﻓﻲ ﻏﻤﺪ واﺣﺪ ھﻲ اﻟﻘﯿﻤﺔ اﻟﻤﺨﺰﻧﺔ ﻓﻲ اﻟﻤﺘﻐﯿﺮ اﻟﺪﻣﺞ ﺑﻌﺪ‬

‫دﻣﺞ ﻗﯿﻤﺘﻲ اﻟﻤﺘﻐﯿﺮﯾﻦ اﻷوﻟﯿﻦ ﺑﻮاﺳﻄﺔ رﻣﺰ اﻟﺪﻣﺞ ‪.+‬‬

‫رواﺑﻂ اﻟﺰﯾﺎدة واﻟﻨﻘﺼﺎن ‪:Increment and Decrement Operators‬‬

‫وھﻲ رواﺑﻂ ﻧﺴﺘﺨﺪﻣﮭﺎ ﻣﻊ اﻟﻤﺘﻐﯿﺮات اﻟﺮﻗﻤﯿﺔ ﻣﻦ أﺟﻞ زﯾﺎدة ﻗﯿﻤﺘﮭﺎ ﺑﻮاﺣﺪ أو إﻧﻘﺎص ﻗﯿﻤﺘﮭﺎ‬

‫ﺑﻮاﺣﺪ‪ ،‬وﺻﯿﻐﺔ اﻟﺮاﺑﻄﯿﻦ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫‪//‬زﯾﺎدة ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ب ‪1‬‬

‫رﻗﻤﻲ اﻟﺮﻗﻢ_اﻷول → ‪25‬؛‬

‫اﻟﺮﻗﻢ_اﻷول → اﻟﺮﻗﻢ_اﻷول ‪1+‬؛‬
‫‪//‬أو ھﻜﺬا‪:‬‬
‫اﻟﺮﻗﻢ_اﻷول ‪++‬؛‬

‫‪ //‬ﻧﻘﺼﺎن ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ب ‪1‬‬

‫رﻗﻤﻲ اﻟﺮﻗﻢ_اﻟﺜﺎﻧﻲ → ‪25‬؛‬

‫اﻟﺮﻗﻢ_ اﻟﺜﺎﻧﻲ → اﻟﺮﻗﻢ_ اﻟﺜﺎﻧﻲ ‪1-‬؛‬
‫‪//‬أو ھﻜﺬا‪:‬‬
‫اﻟﺮﻗﻢ_ اﻟﺜﺎﻧﻲ ‪--‬؛‬
‫اﻟﻨﮭﺎﯾﺔ‬

‫‪64‬‬
 ‫‪BEGIN‬‬
‫زﯾﺎدة ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ب ‪//1‬‬

‫; ‪Int First_Number ← 25‬‬

‫;‪First_Number ← First_Number + 1‬‬
‫أو ھﻜﺬا‪//:‬‬
‫;‪First_Number++‬‬
‫ﻧﻘﺼﺎن ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ب ‪//1‬‬

‫; ‪Int Second_Number ← 25‬‬

‫;‪Second_Number ← Second_Number - 1‬‬
‫أو ھﻜﺬا‪//:‬‬
‫;‪Second_Number--‬‬
‫‪END‬‬

‫رواﺑﻂ اﻟﻤﻘﺎرﻧﺔ ‪:Comparison operators‬‬

‫وھﻲ رواﺑﻂ ﻧﺴﺘﺨﺪﻣﮭﺎ ﻣﻦ أﺟﻞ ﻣﻘﺎرﻧﺔ ﻗﯿﻤﺘﯿﻦ وﺗﺤﺪﯾﺪ ﻧﻮع اﻟﻌﻼﻗﺔ ﺑﯿﻨﮭﻤﺎ )أﻛﺒﺮ ﻣﻦ‪ ،‬أﺻﻐﺮ‬

‫ﻣﻦ‪ ،‬ﺗﺴﺎوي‪ (... ،‬وﻧﺘﯿﺠﺔ اﻟﻤﻘﺎرﻧﺔ ﺗﻜﻮن ﻣﻨﻄﻘﯿﺔ ‪ ،boolean‬أي ﻻ ﺗﻘﺒﻞ إﻻ ﻗﯿﻤﺘﯿﻦ‪ :‬إﻣﺎ‬

‫ﺻﺤﯿﺢ ‪ true‬وإﻣﺎ ﺧﻄﺄ ‪ ،false‬ﻓﯿﻤﺎ ﯾﻠﻲ ﺟﺪول ﯾﻌﺮض رﻣﻮز اﻟﺮواﺑﻂ اﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ‬

‫ﻋﻤﻠﯿﺎت اﻟﻤﻘﺎرﻧﺔ‪:‬‬

‫دوره‬ ‫اﻟﺮاﺑﻂ‬
‫أﻛﱪ ﻣﻦ‬ ‫>‬
‫أﺻﻐﺮ ﻣﻦ‬ ‫<‬
‫ﻳﺴﺎوي‬ ‫=‬
‫ﻳﺨﺎﻟﻒ‬ ‫><‬
‫أﻛﱪ ﻣﻦ أو ﻳﺴﺎوي‬ ‫=>‬
‫أﺻﻐﺮ ﻣﻦ أو ﻳﺴﺎوي‬ ‫=<‬

‫‪65‬‬
 ‫وھﺬه أﻣﺜﻠﺔ ﻋﻠﻰ اﺳﺘﺨﺪام ھﺬا اﻟﻨﻮع ﻣﻦ اﻟﺮواﺑﻂ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫‪ //‬اﻟﻌﺒﺎرة اﻷوﻟﻰ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺢ ‪ True‬ﻷن ‪ 4‬أﻛﺒﺮ ﻣﻦ ‪2‬‬

‫ﻣﻨﻄﻘﻲ اﻟﻌﺒﺎرة_اﻷوﻟﻰ → ‪4 > 2‬؛‬

‫‪ //‬اﻟﻌﺒﺎرة اﻟﺜﺎﻧﯿﺔ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺧﻄﺄ ‪ False‬ﻷن ‪ 5‬ﻟﯿﺴﺖ أﺻﻐﺮ ﻣﻦ ‪1‬‬

‫ﻣﻨﻄﻘﻲ اﻟﻌﺒﺎرة_اﻟﺜﺎﻧﯿﺔ → ‪5 < 1‬؛‬

‫‪ //‬اﻟﻌﺒﺎرة اﻟﺜﺎﻟﺜﺔ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻘﯿﻤﺔ ﺻﺤﯿﺢ ‪ True‬ﻷن ‪ 5‬ﺗﺨﺎﻟﻒ ‪10‬‬

‫ﻣﻨﻄﻘﻲ اﻟﻌﺒﺎرة_اﻟﺜﺎﻟﺜﺔ → ‪10 <> 5‬؛‬

‫‪ //‬اﻟﻌﺒﺎرة اﻟﺮاﺑﻌﺔ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻘﯿﻤﺔ ﺻﺤﯿﺢ ‪ True‬ﻷن ‪ 20‬ﺗﺴﺎوي ﻣﺠﻤﻮع ‪ 6‬و ‪.14‬‬

‫ﻣﻨﻄﻘﻲ اﻟﻌﺒﺎرة_اﻟﺮاﺑﻌﺔ → ‪20 = 14 + 6‬؛‬

‫اﻟﻨﮭﺎﯾﺔ‬

‫‪BEGIN‬‬
‫ﻷن ‪ 4‬أﻛﺒﺮ ﻣﻦ ‪ True2‬اﻟﻌﺒﺎرة اﻷوﻟﻰ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺢ ‪//‬‬

‫; ‪Bool Expression1 ← 4 > 2‬‬

‫ﻷن ‪ 5‬ﻟﯿﺴﺖ أﺻﻐﺮ ﻣﻦ ‪ False1‬اﻟﻌﺒﺎرة اﻟﺜﺎﻧﯿﺔ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺧﻄﺄ ‪//‬‬

‫; ‪Bool Expression2 ← 5 < 1‬‬

‫ﻷن ‪ 5‬ﺗﺨﺎﻟﻒ ‪ True10‬اﻟﻌﺒﺎرة اﻟﺜﺎﻟﺜﺔ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻘﯿﻤﺔ ﺻﺤﯿﺢ ‪//‬‬

‫; ‪Bool Expression3 ← 10 <> 5‬‬

‫ﻷن ‪ 20‬ﺗﺴﺎوي ﻣﺠﻤﻮع ‪ 6‬و ‪ True.14‬اﻟﻌﺒﺎرة اﻟﺮاﺑﻌﺔ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻘﯿﻤﺔ ﺻﺤﯿﺢ ‪//‬‬

‫; ‪Bool Expression4 ← 20 = 14 + 6‬‬

‫‪END‬‬

‫‪66‬‬
 ‫اﻟﺮواﺑﻂ اﻟﻤﻨﻄﻘﯿﺔ ‪:Logical operators‬‬

‫ھﻲ رواﺑﻂ ﻧﺴﺘﺨﺪﻣﮭﺎ ﻣﻦ أﺟﻞ اﻟﺤﺼﻮل ﻋﻠﻰ ﻧﺘﯿﺠﺔ ﺷﺮﻃﯿﻦ أو أﻛﺜﺮ‪ ،‬واﻟﻨﺘﯿﺠﺔ ﺗﻜﻮن ﻣﻨﻄﻘﯿﺔ‬

‫‪ ،boolean‬أي ﻻ ﺗﻘﺒﻞ إﻻ ﻗﯿﻤﺘﯿﻦ‪ :‬إﻣﺎ ﺻﺤﯿﺢ ‪ true‬وإﻣﺎ ﺧﻄﺄ ‪ ،false‬ھﺬه اﻟﺮواﺑﻂ ھﻲ‬

‫‪ AND‬واﻟﺬي ﯾﻌﻨﻲ )و( وﺗﻜﻮن اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺤﺔ إذا ﻛﺎﻧﺖ ﻛﻞ أﻃﺮاف اﻟﺸﺮط ﺻﺤﯿﺤﺔ‪،‬‬

‫واﻟﺮاﺑﻂ ‪ OR‬واﻟﺬي ﯾﻌﻨﻲ )أو( وﺗﻜﻮن اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺤﺔ إذا ﻛﺎن ھﻨﺎﻟﻚ ﻃﺮف واﺣﺪ ﻓﻘﻂ أو‬

‫أﻛﺜﺮ ﻓﻲ اﻟﺸﺮط ﺻﺤﯿﺤﺎ‪.‬‬

‫ﺣﺘﻰ ﻧﺒﺴﻂ ﻣﻔﮭﻮم اﻟﺮواﺑﻂ اﻟﻤﻨﻄﻘﯿﺔ‪ ،‬دﻋﻨﺎ ﻧﺴﺘﺤﻀﺮ ﻣﺜﺎﻻ ﺳﮭﻼ‪ ،‬ﻟﻮ ﻗﻠﺖ ﻟﻚ‪ :‬ﺳﯿﺰورﻧﻲ أﺣﻤﺪ‬

‫و ﻛﻤﺎل‪ ،‬ﻓﺬﻟﻚ ﯾﻌﻨﻲ أن ﻛﻼﻣﻲ ﺳﯿﻜﻮن ﺻﺤﯿﺤﺎ ﺣﯿﻨﻤﺎ ﺳﯿﺄﺗﯿﺎن ﻣﻌﺎ‪ ،‬ﻟﻜﻦ ﻟﻮ ﻗﻠﺖ ﻟﻚ‪ :‬ﻗﺪ‬

‫ﯾﺰورﻧﻲ أﺣﻤﺪ أو ﻛﻤﺎل‪ ،‬ﻓﺎﻟﻤﻌﻨﻰ ﻣﺨﺘﻠﻒ وﻛﻼﻣﻲ ﺳﯿﻜﻮن ﺻﺤﯿﺤﺎ ﺳﻮاء ﺣﻀﺮ أﺣﻤﺪ أو‬

‫ﻛﻤﺎل‪.‬‬

‫اﻵن ﻻﺣﻆ ﻣﻌﻲ ھﺬا اﻟﻤﺜﺎل ﻟﺘﺘﻌﺮف ﻋﻠﻰ ﻛﯿﻔﯿﺔ اﺳﺘﺨﺪام اﻟﺮواﺑﻂ اﻟﻤﻨﻄﻘﯿﺔ‪:‬‬

‫‪67‬‬
 ‫اﻟﺒﺪاﯾﺔ‬
‫‪ //‬اﻟﻌﺒﺎرة اﻷوﻟﻰ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺢ ‪ True‬ﻷن ‪ 2‬أﺻﻐﺮ ﻣﻦ ‪ ،4‬و ‪ 7‬أﻛﺒﺮ ﻣﻦ ‪5‬‬

‫ﻣﻨﻄﻘﻲ اﻟﻌﺒﺎرة_اﻷوﻟﻰ → )‪ 2 < 4‬و ‪(7 > 5‬؛‬

‫‪ //‬اﻟﻌﺒﺎرة اﻟﺜﺎﻧﯿﺔ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺧﻄﺄ ‪ False‬ﻷن أﺣﺪ ﻃﺮﻓﻲ اﻟﻤﻌﺎدﻟﺔ ﻏﯿﺮ ﺻﺤﯿﺢ ﻷن ‪ 3‬ﻻ ﺗﺴﺎوي ‪5‬‬

‫ﻣﻨﻄﻘﻲ اﻟﻌﺒﺎرة_اﻟﺜﺎﻧﯿﺔ → )‪ 2 < 4‬و ‪(3 = 5‬؛‬

‫‪ */‬اﻟﻌﺒﺎرة اﻟﺜﺎﻟﺜﺔ‬

‫ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺢ ‪True‬‬

‫ﻷﻧﮫ ﯾﻮﺟﺪ ﺷﺮط واﺣﺪ ﻋﻠﻰ اﻷﻗﻞ ﺻﺤﯿﺢ وھﻮ ‪2 < 4‬‬

‫وﺑﻤﺎ أﻧﻨﺎ ﻧﺴﺘﺨﺪم اﻟﺮاﺑﻂ " أو " ﻓﯿﻜﻔﻲ وﺟﻮد ﺷﺮط‬

‫واﺣﺪ ﺻﺤﯿﺢ ﻟﺘﻜﻮن اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺤﺔ‪.‬‬

‫*‪/‬‬

‫ﻣﻨﻄﻘﻲ اﻟﻌﺒﺎرة_اﻟﺜﺎﻟﺜﺔ → )‪ 2 < 4‬أو ‪(2 > 5‬؛‬

‫‪ //‬اﻟﻌﺒﺎرة اﻟﺮاﺑﻌﺔ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺧﻄﺄ ﻷن ﻃﺮﻓﻲ اﻟﻤﻌﺎدﻟﺔ ﻏﯿﺮ ﺻﺤﯿﺤﯿﻦ ﻣﻌﺎ‬

‫ﻣﻨﻄﻘﻲ اﻟﻌﺒﺎرة_اﻟﺮاﺑﻌﺔ → )‪ 2 > 4‬أو ‪(3 = 5‬؛‬

‫اﻟﻨﮭﺎﯾﺔ‬

‫‪68‬‬
‫‪BEGIN‬‬
‫ﻷن ‪ 2‬أﺻﻐﺮ ﻣﻦ ‪ ،4‬و ‪ 7‬أﻛﺒﺮ ﻣﻦ ‪ True5‬اﻟﻌﺒﺎرة اﻷوﻟﻰ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺢ ‪//‬‬

‫; ) ‪Bool Expression1 ← ( 2 < 4 AND 7 > 5‬‬

‫ﻷن أﺣﺪ ﻃﺮﻓﻲ اﻟﻤﻌﺎدﻟﺔ ﻏﯿﺮ ﺻﺤﯿﺢ ﻷن ‪ 3‬ﻻ ﺗﺴﺎوي ‪ False5‬اﻟﻌﺒﺎرة اﻟﺜﺎﻧﯿﺔ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺧﻄﺄ ‪//‬‬

‫; ) ‪Bool Expression2 ← ( 2 < 4 AND 3 = 5‬‬

‫اﻟﻌﺒﺎرة اﻟﺜﺎﻟﺜﺔ‪*/‬‬

‫‪True‬ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺢ‬

‫‪2 < 4‬ﻷﻧﮫ ﯾﻮﺟﺪ ﺷﺮط واﺣﺪ ﻋﻠﻰ اﻷﻗﻞ ﺻﺤﯿﺢ وھﻮ‬

‫وﺑﻤﺎ أﻧﻨﺎ ﻧﺴﺘﺨﺪم اﻟﺮاﺑﻂ " أو " ﻓﯿﻜﻔﻲ وﺟﻮد ﺷﺮط‬

‫واﺣﺪ ﺻﺤﯿﺢ ﻟﺘﻜﻮن اﻟﻨﺘﯿﺠﺔ ﺻﺤﯿﺤﺔ‪.‬‬

‫*‪/‬‬

‫; ) ‪Bool Expression3 ← ( 2 > 5 OR 2 < 4‬‬

‫اﻟﻌﺒﺎرة اﻟﺮاﺑﻌﺔ ﺳﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻨﺘﯿﺠﺔ ﺧﻄﺄ ﻷن ﻃﺮﻓﻲ اﻟﻤﻌﺎدﻟﺔ ﻏﯿﺮ ﺻﺤﯿﺤﯿﻦ ﻣﻌﺎ‪//‬‬

‫; ) ‪Bool Expression4 ← ( 2 > 4 OR 3 = 5‬‬

‫‪END‬‬

‫‪69‬‬
 ‫‪ ‬‬
‫أﺣﯿﺎﻧﺎ ﻧﺤﺘﺎج إﻟﻰ إﺟﺮاء ﺗﺤﻘﻖ ﻣﻦ ﻋﺒﺎرة ﻣﻌﯿﻨﺔ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻨﺎ‪ ،‬ﻓﺈن ﻛﺎﻧﺖ ﻧﺘﯿﺠﺔ اﻟﺘﺤﻘﻖ ﺗﺴﺎوي‬

‫ﻗﯿﻤﺔ ﻣﻌﯿﻨﺔ ﻧﻨﻔﺬ ﺷﻔﺮة ﻣﻌﯿﻨﺔ‪ ،‬وإن ﻛﺎن اﻟﻌﻜﺲ أو ﻛﺎﻧﺖ ﺗﺴﺎوي ﻗﯿﻤﺔ أﺧﺮى ﻧﻨﻔﺬ ﺷﻔﺮات‬

‫أﺧﺮى‪ ،‬ﻋﻠﻰ ﺳﺒﯿﻞ اﻟﻤﺜﺎل‪ ،‬ﻧﺮﯾﺪ إﻧﺸﺎء ﺑﺮﻧﺎﻣﺞ ﯾﺘﻜﻮن ﻣﻦ ﺷﺎﺷﺔ ﻟﺘﺴﺠﯿﻞ اﻟﺪﺧﻮل ﻣﺜﻞ ﺗﻠﻚ اﻟﺘﻲ‬

‫ﻓﻲ ﺑﺮﻧﺎﻣﺞ ‪ Skype‬أو ﺑﺮﻧﺎﻣﺞ ‪ ،Messenger‬ﻓﻨﺤﻦ ﻣﻠﺰﻣﯿﻦ ﺑﺎﻟﺘﺤﻘﻖ ﻣﻦ اﺳﻢ اﻟﻤﺴﺘﺨﺪم‬

‫وﻛﻠﻤﺔ اﻟﺴﺮ اﻟﻤﺪﺧﻠﯿﻦ‪ ،‬إن ﻛﺎﻧﺎ ﺻﺤﯿﺤﯿﻦ ﺳﻤﺤﻨﺎ ﺑﻌﻤﻠﯿﺔ اﻟﺪﺧﻮل‪ ،‬وإن ﻛﺎن أﺣﺪھﻤﺎ ﺧﺎﻃﺌﺎ‬

‫أﻇﮭﺮﻧﺎ رﺳﺎﻟﺔ ﺧﻄﺄ‪.‬‬

‫ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﺗﺴﻤﻰ ﻋﻤﻠﯿﺔ اﻟﺘﺤﻘﻖ ﻣﻦ ﻋﺒﺎرة ﻣﻌﯿﻨﺔ ﺷﺮﻃﺎ ‪ Condition‬أو ﺑﻨﯿﺔ ﺷﺮﻃﯿﺔ ‪Flow‬‬

‫‪ ،Control‬وﺻﯿﻐﺘﮭﺎ ﻛﻤﺎ ﯾﻠﻲ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬

‫إذا ﻛﺎن )‪ //‬اﻟﻌﺒﺎرة اﻟﺸﺮﻃﯿﺔ( إذن‬

‫‪ //‬إذا ﺗﺤﻘﻘﺖ اﻟﻌﺒﺎرة اﻟﺸﺮﻃﯿﺔ ﺳﯿﺘﻢ ﺗﻨﻔﯿﺬ ھﺬه اﻷواﻣﺮ‬

‫أﻣﺎ إذا ﻛﺎن )‪//‬ﻋﺒﺎرة ﺷﺮﻃﯿﺔ أﺧﺮى( إذن‬

‫‪ //‬إذا ﺗﺤﻘﻘﺖ اﻟﻌﺒﺎرة اﻟﺸﺮﻃﯿﺔ ﺳﯿﺘﻢ ﺗﻨﻔﯿﺬ ھﺬه اﻷواﻣﺮ‬

‫وإﻻ‬
‫‪ */‬ﻓﻲ ﺣﺎل ﻋﺪم ﺗﺤﻘﻖ أي ﺷﺮط‬

‫*‪/‬‬ ‫ﻣﻦ اﻟﺸﺮوط اﻟﺴﺎﺑﻘﺔ ﻓﺴﯿﺘﻢ ﺗﻨﻔﯿﺬ ھﺬ اﻟﺠﺰء اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﺠﺰء " وإﻻ"‬

‫ﻧﮭﺎﯾﺔ إذا ﻛﺎن‬

‫اﻟﻨﮭﺎﯾﺔ‬

‫‪70‬‬
 ‫‪BEGIN‬‬

‫‪IF ( /*Statement that can be either true or false*/) THEN‬‬

‫‪//Do Someting‬‬
‫‪ELSEIF (/* Other Condition */) THEN‬‬
‫‪//Do Someting‬‬
‫‪ELSE‬‬
‫‪//Do Someting‬‬
‫‪END IF‬‬

‫‪END‬‬

‫اﻵن ﻟﻨﻌﻄﻲ ﻣﺜﺎﻻ ﻧﺘﻌﻠﻢ ﻣﻦ ﺧﻼﻟﮫ ﻃﺮﯾﻘﺔ اﺳﺘﺨﺪام اﻟﺒﻨﯿﺔ اﻟﺸﺮﻃﯿﺔ ﻓﻲ ﺑﺮاﻣﺠﻨﺎ ﻟﻨﻔﺘﺮض أﻧﻨﺎ‬

‫ﺑﺼﺪد إﻧﺸﺎء ﺷﺎﺷﺔ ﻟﺘﺴﺠﯿﻞ اﻟﺪﺧﻮل‪ ،‬ﻣﺜﻞ اﻟﺸﺎﺷﺔ اﻟﻈﺎھﺮة ﻓﻲ اﻟﺼﻮرة اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫ﻓﻲ ﺷﺎﺷﺔ اﻟﺪﺧﻮل أﻋﻼه‪ ،‬ﺳﯿﻘﻮم اﻟﻤﺴﺘﺨﺪم ﺑﻜﺘﺎﺑﺔ اﺳﻤﮫ‪ ،‬وﺑﻜﺘﺎﺑﺔ ﻛﻠﻤﺔ اﻟﻤﺮور‪ ،‬وﻧﺤﻦ ﺳﻨﺴﺘﻘﺒﻞ‬

‫ھﺬﯾﻦ اﻟﻘﯿﻤﺘﯿﻦ‪ ،‬وﺳﻨﻘﻮم ﺑﺘﺨﺰﯾﻨﮭﻤﺎ ﻓﻲ ﻣﺘﻐﯿﺮﯾﻦ ﻧﺼﯿﯿﻦ‪ ،‬ﺛﻢ ﻧﻘﺎرﻧﮭﻤﺎ ﻣﻊ اﻟﺒﯿﺎﻧﺎت اﻟﻤﺴﺠﻠﺔ‬

‫‪71‬‬
‫ﻋﻨﺪﻧﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ أو اﻟﻤﺨ ﺰﻧﺔ ﻓﻲ ﻣﻠﻒ أو ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت‪ ،‬ﻓﺈن ﻛﺎن ھﻨﺎك ﺗﻮاﻓﻖ ﺑﯿﻦ اﻟﺒﯿﺎﻧﺎت‬

‫اﻟﻤﺪﺧﻠﺔ وﺑﯿﻦ اﻟﺒﯿﺎﻧﺎت اﻟﻤﺨﺰﻧﺔ‪ ،‬ﻧﺴﻤﺢ ﺑﻌﻤﻠﯿﺔ اﻟﺪﺧﻮل‪ ،‬وإﻻ ﻧﻈﮭﺮ رﺳﺎﻟﺔ ﺧﻄﺄ ﺗﻌﻠﻢ اﻟﻤﺴﺘﺨﺪم‬

‫ﺑﺄن ﻋﻤﻠﯿﺔ ﺗﺴﺠﯿﻞ اﻟﺪﺧﻮل ﻓﺸﻠﺖ‪.‬‬

‫وھﺬه ھﻲ اﻟﺨﻮارزﻣﯿﺔ اﻟﺘﻲ ﻋﻠﯿﻨﺎ وﺿﻌﮭﺎ ﺑﺎﻻﻋﺘﻤﺎد ﻋﻠﻰ اﻟﺒﻨﯿﺔ اﻟﺸﺮﻃﯿﺔ ﻹﻧﺠﺎز ﻣﺤﺎﻛﺎة ﻟﮭﺬا‬

‫اﻟﺒﺮﻧﺎﻣﺞ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫ﻧﺼﻲ اﺳﻢ_اﻟﻤﺴﺘﺨﺪم_اﻟﻤﺨﺰن → "‪"myUserName‬؛‬
‫ﻧﺼﻲ ﻛﻠﻤﺔ_اﻟﻤﺮور_اﻟﻤﺨﺰﻧﺔ → "‪"MyPassword123‬؛‬
‫ﻧﺼﻲ اﺳﻢ_اﻟﻤﺴﺘﺨﺪم؛‬
‫ﻧﺼﻲ ﻛﻠﻤﺔ_اﻟﻤﺮور؛‬

‫اﻛﺘﺐ)"أدﺧﻞ اﺳﻢ اﻟﻤﺴﺘﺨﺪم ﻣﻦ ﻓﻀﻠﻚ"(؛‬

‫اﻗﺮأ )اﺳﻢ_اﻟﻤﺴﺘﺨﺪم(؛‬

‫اﻛﺘﺐ)"أدﺧﻞ ﻛﻠﻤﺔ اﻟﻤﺮور ﻣﻦ ﻓﻀﻠﻚ"(؛‬

‫اﻗﺮأ )ﻛﻠﻤﺔ_اﻟﻤﺮور(؛‬

‫إذا ﻛﺎن )اﺳﻢ_اﻟﻤﺴﺘﺨﺪم = اﺳﻢ_اﻟﻤﺴﺘﺨﺪم_اﻟﻤﺨﺰن و ﻛﻠﻤﺔ_اﻟﻤﺮور = ﻛﻠﻤﺔ_اﻟﻤﺮور_اﻟﻤﺨﺰﻧﺔ( إذن‬

‫اﻛﺘﺐ)"ﺗﻢ ﺗﺴﺠﯿﻞ اﻟﺪﺧﻮل ﺑﻨﺠﺎح"(؛‬

‫أﻣﺎ إذا ﻛﺎن )اﺳﻢ_اﻟﻤﺴﺘﺨﺪم >< اﺳﻢ_اﻟﻤﺴﺘﺨﺪم_اﻟﻤﺨﺰن و ﻛﻠﻤﺔ_اﻟﻤﺮور = ﻛﻠﻤﺔ_اﻟﻤﺮور_اﻟﻤﺨﺰﻧﺔ( إذن‬

‫اﻛﺘﺐ)"اﺳﻢ اﻟﻤﺴﺘﺨﺪم اﻟﻤﺪﺧﻞ ﻏﯿﺮ ﺻﺤﯿﺢ"(؛‬

‫أﻣﺎ إذا ﻛﺎن )اﺳﻢ_اﻟﻤﺴﺘﺨﺪم = اﺳﻢ_اﻟﻤﺴﺘﺨﺪم_اﻟﻤﺨﺰن و ﻛﻠﻤﺔ_اﻟﻤﺮور >< ﻛﻠﻤﺔ_اﻟﻤﺮور_اﻟﻤﺨﺰﻧﺔ( إذن‬

‫اﻛﺘﺐ)"ﻛﻠﻤﺔ اﻟﻤﺮور ﻏﯿﺮ ﺻﺤﯿﺤﺔ"(؛‬

‫وإﻻ‬
‫اﻛﺘﺐ)"ﻋﻔﻮا‪ ،‬اﻟﺒﯿﺎﻧﺎت اﻟﻤﺪﺧﻠﺔ ﻏﯿﺮ ﺻﺤﯿﺤﺔ"(؛‬

‫ﻧﮭﺎﯾﺔ إذا ﻛﺎن‬

‫اﻟﻨﮭﺎﯾﺔ‬

‫‪72‬‬
BEGIN
String SavedID ← " myUserName";
String SavedPWD ← " MyPassword123";
String ID ;
String Password ;

WRITE("‫;)"أدﺧﻞ اﺳﻢ اﻟﻤﺴﺘﺨﺪم ﻣﻦ ﻓﻀﻠﻚ‬

READ(UserName);

WRITE(" ‫;)"أدﺧﻞ ﻛﻠﻤﺔ اﻟﻤﺮور ﻣﻦ ﻓﻀﻠﻚ‬

READ(UserName);

IF (ID = SavedID AND Password= SavedPWD) THEN

WRITE(" ‫;)"ﺗﻢ ﺗﺴﺠﯿﻞ اﻟﺪﺧﻮل ﺑﻨﺠﺎح‬

ELSEIF (ID <> SavedID AND Password= SavedPWD) THEN

WRITE(" ‫;)"اﺳﻢ اﻟﻤﺴﺘﺨﺪم اﻟﻤﺪﺧﻞ ﻏﯿﺮ ﺻﺤﯿﺢ‬

ELSEIF (ID = SavedID AND Password<> SavedPWD) THEN

WRITE(" ‫;)"ﻛﻠﻤﺔ اﻟﻤﺮور ﻏﯿﺮ ﺻﺤﯿﺤﺔ‬

ELSE (ID = SavedID AND Password<> SavedPWD)

WRITE(" ‫ اﻟﺒﯿﺎﻧﺎت اﻟﻤﺪﺧﻠﺔ ﻏﯿﺮ ﺻﺤﯿﺤﺔ‬،‫;)"ﻋﻔﻮا‬

END IF
END

73
 ‫‪ ‬‬
‫اﻟﺘﻤﺮﯾﻦ اﻷول‪ :‬أﻧﺸﻰء ﺑﺮﻧﺎﻣﺠﺎ ﯾﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم إدﺧﺎل ﻗﯿﻤﺘﯿﻦ رﻗﻤﯿﺘﯿﻦ‪ ،‬ﺛﻢ ﯾﻘﺎرﻧﮭﻤﺎ‬

‫وﯾﻄﺒﻊ أﻛﺒﺮھﻤﺎ‪.‬‬

‫اﻟﺘﻤﺮﯾﻦ اﻟﺜﺎﻧﻲ‪ :‬أﻧﺸﻰء ﺑﺮﻧﺎﻣﺠﺎ ﯾﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم إدﺧﺎل ﻗﯿﻤﺔ رﻗﻤﯿﺔ ﺛﻢ ﯾﻌﯿﺪ ﻟﮫ ھﻞ اﻟﻘﯿﻤﺔ‬

‫اﻟﻤﺪﺧﻠﺔ ﻣﻮﺟﺒﺔ أم ﺳﺎﻟﺒﺔ‪.‬‬

‫اﻟﺘﻤﺮﯾﻦ اﻟﺜﺎﻟﺚ‪ :‬أﻧﺸﻰء ﺑﺮﻧﺎﻣﺠﺎ ﯾﺴﺘﻘﺒﻞ ﺛﻼﺛﺔ ﻗﯿﻢ ﺛﻢ ﯾﻘﻮم ﺑﻄﺒﺎﻋﺔ أﻛﺒﺮھﺎ‪.‬‬

‫اﻟﺘﻤﺮﯾﻦ اﻟﺮاﺑﻊ‪ :‬أﻧﺸﻰء ﺑﺮﻧﺎﻣﺠﺎ ﯾﺴﺘﻘﺒﻞ رﻗﻤﯿﻦ ﺛﻢ ﯾﻌﯿﺪ ﻟﻨﺎ ھﻞ ﻧﺘﯿﺠﺔ ﻋﻤﻠﯿﺔ ﺿﺮﺑﮭﻤﺎ ﻣﻮﺟﺒﺔ أم‬

‫ﺳﺎﻟﺒﺔ‪.‬‬

‫اﻟﺘﻤﺮﯾﻦ اﻟﺨﺎﻣﺲ‪ :‬أﻧﺸﻰء ﺑﺮﻧﺎﻣﺠﺎ ﯾﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم إدﺧﺎل ﻗﯿﻤﺔ ﻧﺼﯿﺔ‪ ،‬ﻓﺈن ﻛﺎﻧﺖ ﻣﺴﺎوﯾﺔ‬

‫ﻟﻠﻜﻠﻤﺔ "‪ "JAVA‬أو اﻟﻜﻠﻤﺔ "‪ "PERL‬ﯾﻈﮭﺮ ﻟﮫ رﺳﺎﻟﺔ ﻣﻔﺎدھﺎ أن اﻟﺠﻮاب ﺻﺤﯿﺢ وإن ﻛﺎﻧﺖ‬

‫ﻋﻠﻰ ﺧﻼف ذﻟﻚ ﯾﻈﮭﺮ ﻟﮫ رﺳﺎﻟﺔ ﻣﻔﺎدھﺎ أن اﻟﺠﻮاب ﺧﺎﻃﻰء‪.‬‬

‫اﻟﺘﻤﺮﯾﻦ اﻟﺴﺎدس‪ :‬أﻧﺸﻰء ﺑﺮﻧﺎﻣﺠﺎ ﯾﺤﺴﺐ اﻟﻤﺒﻠﻎ اﻟﻌﺎم ﻟﻤﻨﺘﻮج ﻣﻌﯿﻦ )ﻋﻠﻤﺎ أن اﻟﻤﺒﻠﻎ اﻟﻌﺎم =‬

‫ﺛﻤﻦ اﻟﻮﺣﺪة اﻟﻮاﺣﺪة ﻣﻦ اﻟﻤﻨﺘﻮج * اﻟﻜﻤﯿﺔ اﻟﻤﺮاد ﺑﯿﻌﮭﺎ( ﻟﻜﻦ ﻗﺒﻞ ذﻟﻚ ﯾﺘﻢ اﻟﺘﺤﻘﻖ ﻣﻦ اﻟﻜﻤﯿﺔ إن‬

‫ﻛﺎﻧﺖ أﺻﻐﺮ ﻣﻦ أو ﺗﺴﺎوي ﺻﻔﺮ ﯾﺘﻢ إﻇﮭﺎر رﺳﺎﻟﺔ ﺧﻄﺄ‪ ،‬وإن ﻛﺎﻧﺖ أﻛﺒﺮ ﻗﻄﻌﺎ ﻣﻦ ﺻﻔﺮ ﯾﺘﻢ‬

‫ﺣﺴﺎب اﻟﻤﺒﻠﻎ اﻟﻌﺎم‪.‬‬

‫اﻟﺘﻤﺮﯾﻦ اﻟﺴﺎﺑﻊ‪ :‬أﻧﺸﻰء ﺑﺮﻧﺎﻣﺠﺎ ﯾﻘﻮم ﺑﺤﺴﺎب اﻟﻤﺒﻠﻎ اﻟﻌﺎم ﻟﻤﻨﺘﻮج ﻣﻌﯿﻦ ﺑﺎﻷﺧﺬ ﺑﻌﯿﻦ اﻻﻋﺘﺒﺎر‬

‫ﻧﺴﺒﺔ اﻟﺨﺼﻢ‪:‬‬

‫‪74‬‬
 ‫‪ .1‬إن ﻛﺎن اﻟﻤﺒﻠﻎ اﻟﻌﺎم أﺻﻐﺮ ﻣﻦ ‪ 500‬درھﻢ ﻓﺈن ﻧﺴﺒﺔ اﻟﺨﺼﻢ ﺻﻔﺮ‪.‬‬

‫‪ .2‬إن ﻛﺎن اﻟﻤﺒﻠﻎ اﻟﻌﺎم أﻛﺒﺮ ﻣﻦ ‪ 500‬وأﺻﻐﺮ ﻣﻦ ‪ 1000‬ﻓﺈن ﻧﺴﺒﺔ اﻟﺨﺼﻢ ھﻲ ‪ 1‬ﻓﻲ اﻟﻤﺌﺔ‪.‬‬

‫‪ .3‬إن ﻛﺎن اﻟﻤﺒﻠﻎ اﻟﻌﺎم أﻛﺒﺮ ﻗﻄﻌﺎ ﻣﻦ ‪ 1000‬درھﻢ ﻓﺈن ﻧﺴﺒﺔ اﻟﺨﺼﻢ ھﻲ ‪ 5‬ﻓﻲ اﻟﻤﺌﺔ‪.‬‬

‫ﻋﻠﻤﺎ أن اﻟﻤﺒﻠﻎ اﻟﻨﮭﺎﺋﻲ ﯾﺤﺴﺐ وﻓﻘﺎ ﻟﻠﺼﯿﻐﺔ اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫اﻟﻤﺒﻠﻎ اﻟﻨﮭﺎﺋﻲ = اﻟﻤﺒﻠﻎ * )‪ 1‬ـ ﻧﺴﺒﺔ اﻟﺨﺼﻢ ‪(100 /‬‬

‫اﻟﺘﻤﺮﯾﻦ اﻟﺜﺎﻣﻦ‪ :‬أﻧﺸﻰء ﺑﺮﻧﺎﻣﺠﺎ ﯾﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم إدﺧﺎل اﻟﻜﻤﯿﺔ اﻟﻤﺮاد ﺑﯿﻌﮭﺎ واﻟﻜﻤﯿﺔ‬

‫اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﻤﺨﺰن‪ ،‬ﺛﻢ ﯾﺘﺤﻘﻖ ﻣﻦ أن اﻟﻜﻤﯿﺔ اﻟﻤﺮاد ﺑﯿﻌﮭﺎ أﺻﻐﺮ ﻣﻦ اﻟﻜﻤﯿﺔ اﻟﻤﺨﺰﻧﺔ ﻟﻜﻲ‬

‫ﯾﺴﻤﺢ ﺑﻌﻤﻠﯿﺔ اﻟﺒﯿﻊ‪ ،‬وإﻻ ﻓﺈﻧﮫ ﯾﻈﮭﺮ رﺳﺎﻟﺔ ﺧﻄﺄ ﻣﻔﺎدھﺎ أن اﻟﻜﻤﯿﺔ اﻟﻤﺮاد ﺑﯿﻌﮭﺎ ﻏﯿﺮ ﻣﺘﻮﻓﺮة‬

‫ﻛﺎﻣﻠﺔ ﻓﻲ اﻟﻤﺨﺰن‪.‬‬

‫‪75‬‬
 ‫‪ Loops ‬‬
‫أﺣﯿﺎﻧﺎ ﻧﺤﺘﺎج إﻟﻰ ﺗﻜﺮار أﻣﺮ ﺑﺮﻣﺠﻲ ﻣﻌﯿﻦ أﻛﺜﺮ ﻣﻦ ﻣﺮة داﺧﻞ ﺗﻄﺒﯿﻘﺎﺗﻨﺎ‪ ،‬ﻓﻠﻮ اﻓﺘﺮﺿﻨﺎ أﻧﻨﺎ‬

‫ﺑﺼﺪد ﺑﺮﻣﺠﺔ ﺗﻄﺒﯿﻖ ﺻﻐﯿﺮ ﯾﺨﺰن ﻗﯿﻤﺔ رﻗﻤﯿﺔ ﻓﻲ ﻣﺘﻐﯿﺮ ﻣﻌﯿﻦ وﯾﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ﺗﺨﻤﯿﻦ‬

‫ھﺬه اﻟﻘﯿﻤﺔ‪ ،‬ﺣﺘﻤﺎ ﻧﺤﻦ ﻻ ﻧﻌﺮف ﻋﺪد اﻻﺣﺘﻤﺎﻻت اﻟﺘﻲ ﺳﯿﻘﻮم ﺑﮭﺎ اﻟﻤﺴﺘﺨﺪم ﻟﻜﻲ ﯾﺼﻞ إﻟﻰ‬

‫ﻧﻔﺲ اﻟﻘﯿﻤﺔ اﻟﻤﺨﺰﻧﺔ ﻋﻨﺪﻧﺎ‪ ،‬ﻟﺬﻟﻚ ﯾﺘﻮﺟﺐ ﻃﺮح ﻧﻔﺲ اﻟﺴﺆال ﻓﻲ ﻛﻞ ﻣﺮة ﯾﺪﺧﻞ اﻟﻤﺴﺘﺨﺪم ﻓﯿﮭﺎ‬

‫ﻗﯿﻤﺔ ﻣﺨﺎﻟﻔﺔ ﻟﻠﻘﯿﻤﺔ اﻟﻤﺨﺰﻧﺔ‪.‬‬

‫أو ﻟﻨﻔﺘﺮض أﻧﻨﺎ ﺑﺼﺪد إﻧﺘﺎج ﺑﺮﻧﺎﻣﺞ ﯾﺴﺄل اﻟﻤﺴﺘﺨﺪم ﻋﻦ اﺳﻢ أول ﺧﻠﻔﺎء اﻟﺪوﻟﺔ اﻟﻌﺒﺎﺳﯿﺔ‪ ،‬ﻓﺈن‬

‫ﻛﺎن اﻟﺠﻮاب ﺻﺎﺋﺒﺎ ﯾﺘﻮﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ وإن ﻛﺎن اﻟﺠﻮاب ﺧﺎﻃﺌﺎ ﯾﻌﯿﺪ ﻃﺮح اﻟﺴﺆال ﻋﻠﻰ‬

‫اﻟﻤﺴﺘﺨﺪم إﻟﻰ ﺣﯿﻦ ﯾﺤﺼﻞ ﻋﻠﻰ اﻟﺠﻮاب اﻟﺼﺤﯿﺢ‪ ،‬ﻓﻲ ﺣﺎﻟﺘﻨﺎ ھﺬه ﻧﺤﻦ ﻻ ﻧﻌﻠﻢ ﻋﺪد اﻟﻤﺮات‬

‫اﻟﻼزﻣﺔ ﻟﻜﻲ ﯾﺠﯿﺐ اﻟﻤﺴﺘﺨﺪم ﺑﺎﻟﺠﻮاب اﻟﺼﺎﺋﺐ‪ ،‬ﻟﺬﻟﻚ ﻓﻨﺤﻦ ﺑﺤﺎﺟﺔ إﻟﻰ إﺟﺮاء ﺗﻜﺮار ﻟﻸﻣﺮ‬

‫اﻟﺬي ﯾﻄﺒﻊ اﻟﺴﺆال ﻓﻲ ﻛﻞ ﻣﺮة ﯾﺨﻄﻰء اﻟﻤﺴﺘﺨﺪم ﻓﻲ اﻹﺟﺎﺑﺔ‪.‬‬

‫ﻹﺟﺮاء ﺗﻜﺮار أﻣﺮ ﻣﻌﯿﻦ ﻓﻲ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﺗﻮﺟﺪ أﻛﺜﺮ ﻣﻦ ﺻﯿﻐﺔ‪ ،‬ﺳﻨﺘﻨﺎول ﻧﺤﻦ ﻓﻲ ھﺬا‬

‫اﻟﺠﺰء أﺷﮭﺮ ﺻﯿﻐﺘﯿﻦ وھﻤﺎ اﻟﺼﯿﻐﺔ اﻟﺘﻜﺮارﯾﺔ اﻟﺸﺮﻃﯿﺔ ﻣﺎ دام ‪ while‬واﻟﺼﯿﻐﺔ اﻟﺘﻜﺮارﯾﺔ‬

‫اﻟﺤﺴﺎﺑﯿﺔ ﻷﺟﻞ ‪ ،for‬وﻟﺒﺪأ ﺑﺎﻟﺼﯿﻐﺔ اﻷوﻟﻰ وﻟﻨﻄﺒﻘﮭﺎ ﻋﻠﻰ ﻧﻔﺲ اﻟﻤﺜﺎل اﻷﺧﯿﺮ اﻟﻤﺘﻌﻠﻖ ﺑﺄول‬

‫ﺧﻠﻔﺎء اﻟﺪوﻟﺔ اﻟﻌﺒﺎﺳﯿﺔ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﺘﻜﺮارﯾﺔ اﻟﺸﺮﻃﯿﺔ ‪ :‬ﻣﺎ دام ‪:while‬‬

‫وھﻲ ﺻﯿﻐﺔ ﺗﺒﺪأ ﺑﺸﺮط ﻣﺴﺒﻮق ﺑﺎﻟﻜﻠﻤﺔ ﻣﺎ دام‪ ،‬وﺗﻌﻨﻲ أﻧﮫ ﻣﺎدام ھﺪا اﻟﺸﺮط ﻣﺘﺤﻘﻘﺎ ﻓﻘﻢ ﺑﺘﻜﺮار‬

‫اﻷواﻣﺮ اﻟﺘﻲ ﺗﺄﺗﻲ ﺑﻌﺪه‪ ،‬وﺣﯿﻨﻤﺎ ﻻ ﯾﺘﺤﻘﻖ اﻟﺸﺮط ﯾﺘﻢ اﻟﺨﺮوج ﻣﻦ اﻟﺒﻨﯿﺔ اﻟﺘﻜﺮارﯾﺔ واﻻﻧﺘﻘﺎل‬

‫إﻟﻰ ﻣﺎ ﺑﻌﺪھﺎ‪.‬‬

‫‪76‬‬
 ‫وھﺬه ھﻲ ﺻﯿﻐﺔ اﻟﺒﻨﯿﺔ اﻟﺘﻜﺮارﯾﺔ ﺑﺎﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ ﻣﺎ دام‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫ﻣﺎ دام )‪ */‬اﻟﺸﺮط *‪(/‬‬
‫‪ //‬ﻧﻔﺬ ﻣﺎ ﯾﻠﻲ‬

‫ﻧﮭﺎﯾﺔ ﻣﺎ دام‬
‫اﻟﻨﮭﺎﯾﺔ‬

‫‪BEGIN‬‬
‫)‪WHILE (Expression‬‬
‫‪//Statements‬‬
‫‪END WHILE‬‬
‫‪END‬‬

‫ﺧﻮارزﻣﯿﺔ ﺗﺨﻤﯿﻦ أول ﺧﻠﻔﺎء اﻟﺪوﻟﺔ اﻟﻌﺒﺎﺳﯿﺔ ﺳﺘﻜﺘﺐ ﺑﮭﺬا اﻟﺸﻜﻞ إذن‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫ﻧﺼﻲ اﺳﻢ_اﻟﺨﻠﯿﻔﺔ_اﻷول ؛‬

‫اﻛﺘﺐ)"ﻣﺎ ھﻮ اﺳﻢ أول ﺧﻠﯿﻔﺔ ﻓﻲ اﻟﺪوﻟﺔ اﻟﻌﺒﺎﺳﯿﺔ ؟ "(؛‬

‫اﻗﺮأ )اﺳﻢ_اﻟﺨﻠﯿﻔﺔ_اﻷول(؛‬

‫ﻣﺎ دام )اﺳﻢ_اﻟﺨﻠﯿﻔﺔ_اﻷول >< " أﺑﻮ اﻟﻌﺒﺎس اﻟﺴﻔﺎح "(‬

‫اﻛﺘﺐ)"ﻟﻸﺳﻒ ﻟﻢ ﺗﺴﺠﻞ اﻹﺟﺎﺑﺔ اﻟﺼﺤﯿﺤﺔ ! "(؛‬

‫ﻧﮭﺎﯾﺔ ﻣﺎ دام‬
‫اﻛﺘﺐ)"ﻣﻤﺘﺎز ! ﻟﻘﺪ أدﺧﻠﺖ اﻟﺠﻮاب اﻟﺼﺎﺋﺐ‪(".‬؛‬

‫اﻟﻨﮭﺎﯾﺔ‬

‫‪77‬‬
‫‪BEGIN‬‬

‫; ‪String First_Khalifa‬‬

‫; )"ﻣﺎ ھﻮ اﺳﻢ أول ﺧﻠﯿﻔﺔ ﻓﻲ اﻟﺪوﻟﺔ اﻟﻌﺒﺎﺳﯿﺔ ؟"(‪WRITE‬‬

‫; )‪READ(First_Khalifa‬‬

‫" أﺑﻮ اﻟﻌﺒﺎس اﻟﺴﻔﺎح " >< ‪WHILE First_Khalifa‬‬

‫; )"ﻟﻸﺳﻒ ﻟﻢ ﺗﺴﺠﻞ اﻹﺟﺎﺑﺔ اﻟﺼﺤﯿﺤﺔ ! "(‪WRITE‬‬

‫‪END WHILE‬‬

‫)"ﻣﻤﺘﺎز ! ﻟﻘﺪ أدﺧﻠﺖ اﻟﺠﻮاب اﻟﺼﺎﺋﺐ‪WRITE(".‬‬

‫‪END‬‬

‫ﻣﻠﺤﻮﻇﺔ‪:‬‬

‫ﻗﺪ ﺗﺘﺴﺎءل‪ :‬وﻟﻤﺎذا ﻻ ﻧﺴﺘﺨﺪم اﻟﺠﻤﻠﺔ اﻟﺸﺮﻃﯿﺔ إذا ﻛﺎن ﻣﺒﺎﺷﺮة‪ ،‬ﺳﺄﺟﯿﺒﻚ‪ :‬ﺑﺄن اﻟﻜﻠﻤﺔ إذا ﻛﺎن‬

‫ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻘﯿﻤﺔ اﻟﻤﺪﺧﻠﺔ ﻟﻤﺮة واﺣﺪة ﺛﻢ ﺗﻨﺘﻘﻞ إﻟﻰ ﻣﺎ ﺑﻌﺪھﺎ‪ ،‬ﺑﯿﻨﻤﺎ اﻟﺒﻨﯿﺔ اﻟﺘﻜﺮارﯾﺔ ﺳﺘﻌﯿﺪ ﻧﻔﺲ‬

‫اﻷﻣﺮ ﻣﺎ دام اﻟﺸﺮط ﻣﺘﺤﻘﻘﺎ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﺘﻜﺮارﯾﺔ اﻟﺤﺴﺎﺑﯿﺔ ‪ :‬ﻷﺟﻞ ‪:for‬‬

‫اﻟﺼﯿﻐﺔ اﻟﺘﻜﺮارﯾﺔ اﻟﺤﺴﺎﺑﯿﺔ ﻣﮭﻤﺔ ﺟﺪا ﻓﻲ اﻟﺒﺮﻣﺠﺔ‪ ،‬وﻧﺤﺘﺎﺟﮭﺎ ﻛﺜﯿﺮا ﻓﻲ ﺗﻄﺒﯿﻘﺎﺗﻨﺎ ﻷﻧﮭﺎ ﺗﺴﺎﻋﺪ‬

‫ﻋﻠﻰ ﺗﻜﺮار أﻣﺮ ﻣﻌﯿﻦ ﺑﺎﻟﻌﺪد اﻟﺬي ﻧﺸﺎء‪ ،‬ﻓﺘﺨﯿﻞ ﻟﻮ أﻧﻨﺎ ﻧﺮﯾﺪ ﻃﺒﺎﻋﺔ ﺟﻤﻠﺔ اﻟﺼﺪق ﻋﺰ واﻟﻜﺬب ذل‬

‫وﺧﻀﻮع أﻟﻒ ﻣﺮة ﻛﻢ ﺳﯿﻠﺰﻣﻨﺎ ﻣﻦ ﺳﻄﺮ ﻣﻦ اﻟﺠﻤﻠﺔ اﻟﺼﺪق ﻋﺰ واﻟﻜﺬب ذل وﺧﻀﻮع‪ ،‬أﻛﯿﺪ‬

‫ﺳﻨﺤﺘﺎج إﻟﻰ أﻟﻒ ﺳﻄﺮ‪ ،‬وھﺬا ﺷﻲء ﻣﺘﻌﺐ وﻣﺮھﻖ ﺟﺪا ﻟﻠﻤﺒﺮﻣﺞ‪ ،‬ﻟﺬﻟﻚ ﻓﺎﻟﺒﻨﯿﺔ اﻟﺘﻜﺮارﯾﺔ‬

‫‪78‬‬
‫اﻟﺤﺴﺎﺑﯿﺔ ﺗﺴﮭﻞ ﻋﻠﯿﻨﺎ ھﺬا اﻷﻣﺮ ﺑﺸﻜﻞ راﺋﻊ ﺟﺪا‪ ،‬ﺑﺤﯿﺚ ﯾﻜﻔﻲ أن ﻧﺤﺪد ﺑﺪاﯾﺔ اﻟﺘﻜﺮار وﻧﮭﺎﯾﺘﮫ ﺛﻢ‬

‫ﻧﻜﺘﺐ اﻷﻣﺮ اﻟﻤﺮاد ﺗﻜﺮاره ﻣﺮة واﺣﺪة وﯾﺘﻢ إﻋﺎدﺗﮫ ﺣﺴﺐ اﻟﻤﺠﺎل اﻟﺮﻗﻤﻲ اﻟﺬي ﺣﺪدﻧﺎه‪.‬‬

‫ﺻﯿﻐﺔ اﻟﺒﻨﯿﺔ اﻟﺘﻜﺮارﯾﺔ اﻟﺤﺴﺎﺑﯿﺔ ﺗﻜﺘﺐ ﺑﮭﺬا اﻟﺸﻜﻞ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫رﻗﻤﻲ اﻟﻌﺪاد؛‬
‫ﻷﺟﻞ اﻟﻌﺪاد → ‪ 1‬إﻟﻰ ‪1000‬‬
‫اﻛﺘﺐ )" اﻟﺼﺪق ﻋﺰ واﻟﻜﺬب ذل وﺧﻀﻮع "(‬
‫ﻧﮭﺎﯾﺔ ﻷﺟﻞ‬
‫اﻟﻨﮭﺎﯾﺔ‬

‫‪BEGIN‬‬
‫; ‪Int Count‬‬
‫‪FOR Count ← 1 TO 1000‬‬
‫; )" اﻟﺼﺪق ﻋﺰ واﻟﻜﺬب ذل وﺧﻀﻮع "( ‪WRITE‬‬
‫‪END FOR‬‬
‫‪END‬‬

‫ﺑﻌﺪ ﺗﻨﻔﯿﺬ اﻟﺨﻮارزﻣﯿﺔ أﻋﻼه ﺳﯿﺘﻢ ﻃﺒﺎﻋﺔ اﻟﺠﻤﻠﺔ اﻟﻤﺬﻛﻮرة أﻟﻒ ﻣﺮة ﻷن اﻟﺘﻜﺮار اﻟﺤﺴﺎﺑﻲ ﯾﺒﺪأ‬

‫ﻣﻦ ‪ 1‬وﯾﻨﺘﮭﻲ ﺑﺄﻟﻒ‪.‬‬

‫وھﺬا ﻣﺜﺎل آﺧﺮ ﯾﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم أن ﯾﺪﺧﻞ رﻗﻤﺎ‪ ،‬ﺛﻢ ﯾﻘﻮم ﺑﺠﻤﻊ ھﺬا اﻟﺮﻗﻢ ﻣﻊ ﺟﻤﯿﻊ اﻷرﻗﺎم‬

‫اﻟﺘﻲ ﺗﺴﺒﻘﮫ‪ ،‬وﯾﻄﺒﻊ اﻟﻨﺘﯿﺠﺔ‪ ،‬ﻣﺜﻼ ﻟﻮ أدﺧﻞ اﻟﻤﺴﺘﺨﺪم اﻟﺮﻗﻢ ‪ 6‬ﻓﺴﻮف ﯾﻘﻮم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺎﻟﻌﻤﻠﯿﺔ‬

‫اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫‪21 = 6 + 5 + 4 + 3 + 2 + 1‬‬

‫‪79‬‬
 ‫اﻟﺒﺪاﯾﺔ‬
‫رﻗﻤﻲ اﻟﺮﻗﻢ‪ ،‬اﻟﻌﺪاد؛‬
‫رﻗﻤﻲ اﻟﻤﺠﻤﻮع → ‪0‬؛‬
‫اﻛﺘﺐ )"ﻣﻦ ﻓﻀﻠﻚ أدﺧﻞ رﻗﻤﺎ "(‬
‫اﻗﺮأ )اﻟﺮﻗﻢ(‬
‫ﻷﺟﻞ اﻟﻌﺪاد → ‪ 1‬إﻟﻰ اﻟﺮﻗﻢ‬
‫اﻟﻤﺠﻤﻮع → اﻟﻤﺠﻤﻮع ‪ +‬اﻟﺮﻗﻢ ؛‬
‫ﻧﮭﺎﯾﺔ ﻷﺟﻞ‬
‫اﻛﺘﺐ )"اﻟﻤﺠﻤﻮع ﯾﺴﺎوي‪ +" :‬اﻟﻤﺠﻤﻮع(‬
‫اﻟﻨﮭﺎﯾﺔ‬

‫‪BEGIN‬‬
‫; ‪Int Number, Count‬‬
‫; ‪Int Sum ← 0‬‬
‫; )"ﻣﻦ ﻓﻀﻠﻚ أدﺧﻞ رﻗﻤﺎ "( ‪WRITE‬‬
‫; )‪READ(Number‬‬
‫‪FOR Count ← 1 TO Number‬‬
‫; ‪Sum ← Sum + Number‬‬
‫‪END FOR‬‬
‫; )‪" + Sum‬اﻟﻤﺠﻤﻮع ﯾﺴﺎوي‪WRITE(" :‬‬
‫‪END‬‬

‫ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼن ﻋﻦ ﻣﺘﻐﯿﺮﯾﻦ رﻗﻤﯿﯿﻦ اﺳﻤﮭﻤﺎ‪ :‬اﻟﺮﻗﻢ وھﻮ اﻟﻘﯿﻤﺔ اﻟﺮﻗﻤﯿﺔ اﻟﺘﻲ ﺳﯿﺪﺧﻠﮭﺎ اﻟﻤﺴﺘﺨﺪم‪،‬‬

‫واﻟﻤﺘﻐﯿﺮ‪ :‬اﻟﻌﺪاد وھﻮ اﻟﺬي ﺳﻨﺴﺘﺨﺪﻣﮫ ﻓﻲ اﻟﺘﻜﺮار ﺑﺤﯿﺚ ﺳﯿﺒﺪأ ﻣﻦ اﻟﺮﻗﻢ ‪ 1‬وﯾﻨﺘﮭﻲ ﺑﺎﻟﺮﻗﻢ‬

‫اﻟﻤﺪﺧﻞ ﻣﻦ ﻃﺮف اﻟﻤﺴﺘﺨﺪم‪ ،‬وﻓﻲ ﻛﻞ ﺗﻜﺮار ﯾﻀﯿﻒ ﻗﯿﻤﺔ اﻟﺮﻗﻢ اﻟﺬي ﯾﺼﻞ إﻟﯿﮫ إﻟﻰ ﻗﯿﻤﺔ‬

‫اﻟﻤﺘﻐﯿﺮ اﻟﺬي أﺳﻤﯿﻨﺎه‪ :‬اﻟﻤﺠﻤﻮع‪.‬‬

‫ﻟﻨﻔﺘﺮض أن اﻟﻤﺴﺘﺨﺪم ﻗﺎم ﺑﺈدﺧﺎل اﻟﺮﻗﻢ ‪ ،7‬ﺑﻨﺎء ﻋﻠﻰ ذﻟﻚ ﻓﻌﻤﻠﯿﺔ اﻟﺘﻜﺮار ﺳﺘﻮزع اﻟﻘﯿﻢ ﻋﻠﻰ‬

‫اﻟﻤﺘﻐﯿﺮات ﻛﻤﺎ ﯾﻌﺮض اﻟﺠﺪول اﻟﺘﺎﻟﻲ‪:‬‬

‫اﻟﻤﺠﻤﻮع‬ ‫اﻟﻌﺪاد‬ ‫اﻟﺮﻗﻢ‬

‫‪1‬‬ ‫‪1‬‬ ‫‪7‬‬

‫‪80‬‬
 ‫‪3=2+1‬‬ ‫‪2‬‬ ‫‪7‬‬
‫‪6=3+3‬‬ ‫‪3‬‬ ‫‪7‬‬
‫‪10=4+6‬‬ ‫‪4‬‬ ‫‪7‬‬
‫‪15=5+10‬‬ ‫‪5‬‬ ‫‪7‬‬
‫‪21=6+15‬‬ ‫‪6‬‬ ‫‪7‬‬
‫‪28=7+21‬‬ ‫‪7‬‬ ‫‪7‬‬

‫‪ Arrays‬‬
‫ﺧﻼل اﻟﻔﻘﺮات اﻟﺴﺎﺑﻘﺔ ﻛﻨﺎ ﻧﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺘﻐﯿﺮات‪ ،‬ورأﯾﻨﺎ ﻛﯿﻒ ﺗﺴﻤﺢ ﻟﻨﺎ ﺑﺘﺨﺰﯾﻦ اﻟﻘﯿﻢ ﻓﻲ‬

‫اﻟﺬاﻛﺮة‪ ،‬ورأﯾﻨﺎ ﻛﺬﻟﻚ أن ﻛﻞ ﻣﺘﻐﯿﺮ ﻣﺨﺼﺺ ﻻﺣﺘﻮاء ﻗﯿﻤﺔ واﺣﺪة‪ ،‬وﻻ ﯾﻤﻜﻦ ﻟﻠﻤﺘﻐﯿﺮ اﻟﻮاﺣﺪ‬

‫أن ﯾﺴﺘﻘﺒﻞ أﻛﺜﺮ ﻣﻦ ﻗﯿﻤﺔ ﻓﻲ وﻗﺖ واﺣﺪ‪.‬‬

‫ﻟﺬﻟﻚ ﻟﻮ اﻓﺘﺮﺿﻨﺎ أﻧﻨﺎ ﻧﺮﯾﺪ إﻧﺸﺎء ﺑﺮﻧﺎﻣﺞ ﻟﺤﺴﺎب ﻣﻌﺪﻻت اﻟﻄﻠﺒﺔ‪ ،‬ﺑﺤﯿﺚ ﯾﺴﺘﻘﺒﻞ ھﺬا اﻟﺒﺮﻧﺎﻣﺞ‬

‫ﻧﻘﻄﺔ اﻟﻄﺎﻟﺐ ﻓﻲ ﻛﻞ ﻣﺎدة ﻣﻦ اﻟﻤﻮاد اﻟﺘﻲ ﯾﺪرﺳﮭﺎ‪ ،‬ﺛﻢ ﯾﻘﻮم ﺑﺤﺴﺎب اﻟﻤﻌﺪل اﻟﻌﺎم‪ ،‬ﻗﺪ ﺗﻘﻮل ﻟﻲ‪:‬‬

‫ﺑﺈﻣﻜﺎﻧﻨﺎ ﻋﻤﻞ ذﻟﻚ ﻣﻦ ﺧﻼل اﻹﻋﻼن ﻋﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﺘﻐﯿﺮات ﺣﺴﺐ ﻋﺪد اﻟﻤﻮاد ﻟﺪﯾﻨﺎ ﺛﻢ‬

‫ﻧﺠﺮي ﻋﻠﯿﮭﺎ ﻋﻤﻠﯿﺔ ﺣﺴﺎب اﻟﻤﻌﺪل اﻟﻌﺎم‪ ،‬ﺳﺄﻗﻮل ﻟﻚ ﺑﺄن ﺟﻮاﺑﻚ ﺻﺎﺋﺐ‪ ،‬ﻷﻧﮫ ﻟﻮ أردﻧﺎ ﻣﺜﻼ‬

‫ﺣﺴﺎب ﻣﻌﺪل ﻃﺎﻟﺐ ﻣﻌﯿﻦ ﻓﻲ ﻋﺸﺮة ﻣﻮاد ﯾﺪرﺳﮭﺎ‪ ،‬ﺳﻮف ﻧﻌﻠﻦ ﻋﻦ ﻋﺸﺮ ﻣﺘﻐﯿﺮات رﻗﻤﯿﺔ‬

‫ﻻﺳﺘﻘﺒﺎل ﻧﻘﺎط اﻟﻄﺎﻟﺐ‪ ،‬ﺑﺎﻟﻄﺮﯾﻘﺔ اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫رﻗﻤﻲ اﻟﺮﻗﻢ‪ ،1‬اﻟﺮﻗﻢ‪ ،2‬اﻟﺮﻗﻢ‪ ،3‬اﻟﺮﻗﻢ‪ ،4‬اﻟﺮﻗﻢ‪ ،5‬اﻟﺮﻗﻢ‪ ،6‬اﻟﺮﻗﻢ‪ ،7‬اﻟﺮﻗﻢ‪ ،8‬اﻟﺮﻗﻢ‪ ،9‬اﻟﺮﻗﻢ‪10‬؛‬

‫;‪Int Num1, Num2, Num3, Num4, Num5, Num6, Num7, Num8, Num9, Num10‬‬

‫‪81‬‬
‫ﻟﻜﻦ ھﺬه اﻟﻄﺮﯾﻘﺔ ﻟﯿﺴﺖ ﻣﺠﺪﯾﺔ إذا ﻛﻨﺎ ﺳﻨﺤﺘﺎج إﻟﻰ ﺗﺨﺰﯾﻦ ﻗﯿﻢ ﻛﺜﯿﺮة‪ ،‬ﻷﻧﻨﺎ ﺳﻨﺠﺪ ﺻﻌﻮﺑﺔ ﻓﻲ‬

‫اﺳﺘﺤﻀﺎر أﺳﻤﺎء اﻟﻤﺘﻐﯿﺮات‪ ،‬ﻧﺎھﯿﻚ ﻋﻦ ﺻﻌﻮﺑﺔ ﺗﺘﺒﻊ اﻟﻜﻮد وﻗﺮاءﺗﮫ‪.‬‬

‫ﻟﺤﻞ ھﺬه اﻟﻤﺸﺎﻛﻞ وﻏﯿﺮھﺎ وﺟﺪ ﻣﻔﮭﻮم اﻟﻤﺼﻔﻮﻓﺎت ‪ ،Arrays‬ﺑﺤﯿﺚ ﻧﺴﺘﺨﺪﻣﮭﺎ ﺣﯿﻨﻤﺎ ﻧﻮد‬

‫ﺗﺨﺰﯾﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻘﯿﻢ اﻟﻤﻨﺘﻤﯿﺔ ﻟﻨﻔﺲ ﻧﻮع اﻟﺒﯿﺎﻧﺎت ﻓﻲ ﻣﺘﻐﯿﺮ واﺣﺪ‪ ،‬وﯾﺮﺗﻜﺰ ﻣﻔﮭﻮم‬

‫اﻟﻤﺼﻔﻮﻓﺎت ﻋﻠﻰ رﻛﯿﺰﺗﯿﻦ أﺳﺎﺳﯿﺘﯿﻦ ھﻤﺎ‪:‬‬

‫اﻟﻘﯿﻤﺔ ‪ :Value‬وھﻲ اﻟﻘﯿﻢ اﻟﻤﺮاد ﺗﺨﺰﯾﻨﮭﺎ ﻓﻲ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‪ ،‬ﻟﻮ أﺧﺬﻧﺎ ﻣﺜﻼ ﻣﺼﻔﻮﻓﺔ‬

‫ﻟﺘﺨﺰﯾﻦ درﺟﺎت اﻟﻄﻼب ﻓﻲ اﻟﻤﻮاد ﻓﺈن اﻟﺪرﺟﺎت ھﻲ اﻟﻘﯿﻢ‪ ،‬ﻛﻞ درﺟﺔ ﻋﺒﺎرة ﻋﻦ ﻗﯿﻤﺔ ﺳﯿﺘﻢ‬

‫ﺗﺨﺰﯾﻨﮭﺎ ﻓﻲ ﻋﻨﺼﺮ ﻣﻌﯿﻦ ﻣﻦ ﻋﻨﺎﺻﺮ ﻣﺼﻔﻮﻓﺔ اﻟﻤﻮاد‪.‬‬

‫اﻟﺮﺗﺒﺔ ‪ :Index‬وھﻲ رﺗﺒﺔ اﻟﻌﻨﺼﺮ داﺧﻞ اﻟﻤﺼﻔﻮﻓﺔ‪ ،‬وﺗﺒﺪأ ﺑﺼﻔﺮ وﺗﻨﺘﮭﻲ ﺑﺮﺗﺒﺔ آﺧﺮ ﻋﻨﺼﺮ‬

‫ﻧﺎﻗﺺ واﺣﺪ‪ ،‬ﻣﺜﻼ ﻟﻮ أردﻧﺎ ﺗﺨﺰﯾﻦ اﻟﺪرﺟﺎت ﻓﻲ ﻣﺼﻔﻮﻓﺔ اﻟﻤﻮاد ﻓﺈن اﻟﺘﻤﺜﯿﻞ اﻟﻔﻌﻠﻲ ﺳﯿﻜﻮن‬

‫ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬

‫‪82‬‬
‫ﻧﺴﺘﻄﯿﻊ اﻟﻮﺻﻮل إﻟﻰ أي ﻋﻨﺼﺮ ﻣﻦ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﻣﻦ ﺧﻼل رﺗﺒﺘﮫ ‪ ،Index‬ھﺬا اﻟﻨﻮع‬

‫ﻣﻦ اﻟﻤﺼﻔﻮﻓﺎت اﻟﺬي ﻧﺘﺤﺪث ﻋﻨﮫ ﯾﺴﻤﻰ اﻟﻤﺼﻔﻮﻓﺎت اﻷﺣﺎدﯾﺔ اﻟﺒﻌﺪ ‪one-dimensional‬‬

‫‪ array‬ﻷﻧﮭﺎ ﺗﺤﺘﻮي ﻋﻠﻰ ﺑﻌﺪ واﺣﺪ ﯾﻀﻢ اﻟﻌﻨﺎﺻﺮ ﺑﺸﻜﻞ ﺧﻄﻲ ﻛﻤﺎ ﯾﻌﺮض اﻟﺸﻜﻞ أﻋﻼه‪.‬‬

‫اﻹﻋﻼن ﻋﻦ ﻣﺼﻔﻮﻓﺔ أﺣﺎدﯾﺔ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫‪//‬ﻣﺼﻔﻮﻓﺔ ﻣﻦ دون ﺗﺤﺪﯾﺪ ﻋﺪد اﻟﻌﻨﺎﺻﺮ‬
‫ﻧﻮع_اﻟﻤﺼﻔﻮﻓﺔ اﺳﻢ_اﻟﻤﺼﻔﻮﻓﺔ_اﻷوﻟﻰ ][ ؛‬

‫‪//‬ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ‪ 7‬ﻋﻨﺎﺻﺮ‬

‫ﻧﻮع_اﻟﻤﺼﻔﻮﻓﺔ اﺳﻢ_اﻟﻤﺼﻔﻮﻓﺔ_اﻟﺜﺎﻧﯿﺔ ]‪ [7‬؛‬
‫اﻟﻨﮭﺎﯾﺔ‬

‫‪BEGIN‬‬
‫ﻣﺼﻔﻮﻓﺔ ﻣﻦ دون ﺗﺤﺪﯾﺪ ﻋﺪد اﻟﻌﻨﺎﺻﺮ‪//‬‬
‫; ][‪Data_Type ArrayName‬‬

‫ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ‪ 7‬ﻋﻨﺎﺻﺮ‪//‬‬

‫; ]‪Data_Type ArrayName[7‬‬
‫‪END‬‬

‫أﻣﺜﻠﺔ ﻋﻠﻰ إﻋﻼن اﻟﻤﺼﻔﻮﻓﺎت أﺣﺎدﯾﺔ اﻟﺒﻌﺪ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫‪//‬ﻣﺼﻔﻮﻓﺔ ﻣﻦ دون ﺗﺤﺪﯾﺪ ﻋﺪد اﻟﻌﻨﺎﺻﺮ‬
‫رﻗﻤﻲ ﻣﺼﻔﻮﻓﺔ_درﺟﺎت_اﻟﻄﻼب ][ ؛‬

‫‪//‬ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ‪ 7‬ﻋﻨﺎﺻﺮ‬

‫رﻗﻤﻲ ﻣﺼﻔﻮﻓﺔ_درﺟﺎت_اﻟﻄﻼب ]‪ [7‬؛‬
‫اﻟﻨﮭﺎﯾﺔ‬

‫‪83‬‬
‫‪BEGIN‬‬
‫ﻣﺼﻔﻮﻓﺔ ﻣﻦ دون ﺗﺤﺪﯾﺪ ﻋﺪد اﻟﻌﻨﺎﺻﺮ‪//‬‬
‫; ][‪Int MarksArray‬‬

‫ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ‪ 7‬ﻋﻨﺎﺻﺮ‪//‬‬

‫; ]‪Int MarksArray[7‬‬
‫‪END‬‬

‫ﻣﺜﺎل ﻋﻤﻠﻲ ﻋﻠﻰ ﻛﯿﻔﯿﺔ اﺳﺘﺨﺪام اﻟﻤﺼﻔﻮﻓﺎت‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫‪//‬ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ‪ 7‬ﻋﻨﺎﺻﺮ ﻟﺘﺨﺰﯾﻦ أﯾﺎم اﻷﺳﺒﻮع‬
‫ﻧﺼﻲ ﻣﺼﻔﻮﻓﺔ_أﯾﺎم_اﻷﺳﺒﻮع ]‪ [7‬؛‬

‫‪ //‬ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع رﻗﻤﻲ ﻟﻠﻘﯿﺎم ﺑﻌﻤﻠﯿﺔ ﺗﻜﺮار ﺗﺬھﺐ ﻣﻦ أول ﻋﻨﺼﺮ إﻟﻰ آﺧﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‬
‫رﻗﻤﻲ اﻟﻌﺪاد ؛‬

‫‪//‬ﺗﺨﺰﯾﻦ اﻟﻘﯿﻢ ﻓﻲ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺣﺴﺐ اﻟﺮﺗﺒﺔ ‪Index‬‬

‫ﻣﺼﻔﻮﻓﺔ_أﯾﺎم_اﻷﺳﺒﻮع ]‪" → [0‬اﻷﺣﺪ"؛‬
‫ﻣﺼﻔﻮﻓﺔ_أﯾﺎم_اﻷﺳﺒﻮع ]‪" → [1‬اﻹﺛﻨﯿﻦ"؛‬
‫ﻣﺼﻔﻮﻓﺔ_أﯾﺎم_اﻷﺳﺒﻮع ]‪" → [2‬اﻟﺜﻼﺛﺎء"؛‬
‫ﻣﺼﻔﻮﻓﺔ_أﯾﺎم_اﻷﺳﺒﻮع ]‪" → [3‬اﻷرﺑﻌﺎء"؛‬
‫ﻣﺼﻔﻮﻓﺔ_أﯾﺎم_اﻷﺳﺒﻮع ]‪" → [4‬اﻟﺨﻤﯿﺲ"؛‬
‫ﻣﺼﻔﻮﻓﺔ_أﯾﺎم_اﻷﺳﺒﻮع ]‪" → [5‬اﻟﺠﻤﻌﺔ"؛‬
‫ﻣﺼﻔﻮﻓﺔ_أﯾﺎم_اﻷﺳﺒﻮع ]‪" → [6‬اﻟﺴﺒﺖ"؛‬

‫‪//‬ﻋﺮض ﻛﻞ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‬

‫ﻷﺟﻞ اﻟﻌﺪاد → ‪ 0‬إﻟﻰ ‪6‬‬
‫اﻛﺘﺐ )"اﺳﻢ اﻟﯿﻮم‪ +" :‬ﻣﺼﻔﻮﻓﺔ_أﯾﺎم_اﻷﺳﺒﻮع ]اﻟﻌﺪاد[( ؛‬
‫ﻧﮭﺎﯾﺔ ﻷﺟﻞ‬
‫اﻟﻨﮭﺎﯾﺔ‬

‫‪84‬‬
‫‪BEGIN‬‬
‫ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ‪ 7‬ﻋﻨﺎﺻﺮ ﻟﺘﺨﺰﯾﻦ أﯾﺎم اﻷﺳﺒﻮع‪//‬‬
‫; ]‪String WeekArray[7‬‬

‫ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع رﻗﻤﻲ ﻟﻠﻘﯿﺎم ﺑﻌﻤﻠﯿﺔ ﺗﻜﺮار ﺗﺬھﺐ ﻣﻦ أول ﻋﻨﺼﺮ إﻟﻰ آﺧﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‪//‬‬
‫; ‪Int Count‬‬
‫ﺗﺨﺰﯾﻦ اﻟﻘﯿﻢ ﻓﻲ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺣﺴﺐ اﻟﺮﺗﺒﺔ ‪//‬‬
‫;"‪WeekArray[0] ← " Sunday‬‬
‫;"‪WeekArray[1] ← " Monday‬‬
‫;"‪WeekArray[2] ← " Tuesday‬‬
‫;"‪WeekArray[3] ← " Wednesday‬‬
‫;"‪WeekArray[4] ← " Thursday‬‬
‫;"‪WeekArray[5] ← " Friday‬‬
‫;"‪WeekArray[6] ← " Saturday‬‬
‫ﻋﺮض ﻛﻞ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‪//‬‬
‫‪For Count ← 0 TO 6‬‬
‫;)]‪WRITE("The Day Name Is: "+ WeekArray[Count‬‬
‫‪END FOR‬‬
‫‪END‬‬

‫‪ ‬‬
‫اﻟﻤﺼﻔﻮﻓﺎت ﻣﺘﻌﺪدة اﻷﺑﻌﺎد ھﻲ ﻣﺼﻔﻮﻓﺎت ﺗﺘﻜﻮن ﻣﻦ أﻛﺜﺮ ﻣﻦ ﺑﻌﺪ‪ ،‬ﻗﺪ ﺗﻜﻮن ﺛﻨﺎﺋﯿﺔ اﻟﺒﻌﺪ‬

‫)ﻋﺒﺎرة ﻋﻦ أﻋﻤﺪة وأﺳﻄﺮ( أو ﺛﻼﺛﯿﺔ اﻟﺒﻌﺪ أو أﻛﺜﺮ ﻣﻦ ذﻟﻚ ﺣﺴﺐ اﻟﺤﺎﺟﺔ‪ ،‬ﻋﻠﻤﺎ أن ھﺬا اﻟﻨﻮع‬

‫ﻣﻦ اﻟﻤﺼﻔﻮﻓﺎت ﻧﺎدر اﻻﺳﺘﺨﺪام ﺟﺪا وﻻ ﻧﺤﺘﺎﺟﮫ إﻻ ﻓﻲ ﺣﺎﻟﺔ رﻏﺒﺘﻨﺎ ﻓﻲ اﻟﺘﻌﻤﻖ ﻓﻲ ﺑﺮﻣﺠﺔ‬

‫اﻷﻟﻌﺎب أو ﺑﺮاﻣﺞ اﻟﺘﺼﻤﯿﻢ‪...‬‬

‫‪85‬‬
‫ﻓﯿﻤﺎ ﯾﻠﻲ ﻣﺜﺎل ﻋﻦ اﻹﻋﻼن ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﺛﻨﺎﺋﯿﺔ ‪ two-dimensional array‬ﻣﻦ ﻧﻮع رﻗﻤﻲ‬

‫ﺗﺘﻜﻮن ﻣﻦ ﺧﻤﺴﺔ أﻋﻤﺪة ‪ Columns‬وأرﺑﻌﺔ أﺳﻄﺮ ‪:Rows‬‬

‫رﻗﻤﻲ ﻣﺼﻔﻮﻓﺔ_ﺛﻨﺎﺋﯿﺔ ]‪ [5,4‬؛‬

‫;]‪Int Two_Dimensional_Array[4,5‬‬

‫اﻟﻤﺼﻔﻮ ﻓﺔ أﻋﻼه ﻋﺒﺎرة ﻋﻦ ﻣﺼﻔﻮﻓﺔ رﻗﻤﯿﺔ ﺛﻨﺎﺋﯿﺔ اﻟﺒﻌﺪ ﺗﺘﻜﻮن ﻣﻦ أرﺑﻌﺔ أﺳﻄﺮ وﺧﻤﺴﺔ‬

‫أﻋﻤﺪة‪ ،‬إذا أردﻧﺎ ﺗﻤﺜﯿﻠﮭﺎ رﯾﺎﺿﯿﺎ ﻓﮭﻲ ﺑﻤﺜﺎﺑﺔ ﺟﺪول ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‪:‬‬

‫)‪(0,0‬‬ ‫)‪(0,1‬‬ ‫)‪(0,2‬‬ ‫)‪(0,3‬‬ ‫)‪(0,4‬‬

‫)‪(1,0‬‬ ‫)‪(1,1‬‬ ‫)‪(1,2‬‬ ‫)‪(1,3‬‬ ‫)‪(1,4‬‬
‫)‪(2,0‬‬ ‫)‪(2,1‬‬ ‫)‪(2,2‬‬ ‫)‪(2,3‬‬ ‫)‪(2,4‬‬
‫)‪(3,0‬‬ ‫)‪(3,1‬‬ ‫)‪(3,2‬‬ ‫)‪(3,3‬‬ ‫)‪(3,4‬‬

‫ﻣﻠﺤﻮﻇﺔ‪ :‬اﻧﺘﺒﮫ إﻟﻰ أن ﺗﺮﺗﯿﺐ اﻟﻌﻨﺎﺻﺮ ‪ Index‬ﯾﺒﺪأ ﻣﻦ ﺻﻔﺮ ﺳﻮاء ﺑﺎﻟﻨﺴﺒﺔ ﻟﻸﻋﻤﺪة أو‬

‫اﻷﺳﻄﺮ‪ ،‬وﯾﻨﺘﮭﻲ داﺋﻤﺎ ﺑﺮﺗﺒﺔ آﺧﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ ﻧﺎﻗﺺ واﺣﺪ‪ ،‬وﻋﺪد ﻋﻨﺎﺻﺮ‬

‫اﻟﻤﺼﻔﻮﻓﺔ اﻟﺜﻨﺎﺋﯿﺔ اﻟﺒﻌﮫ ﯾﺴﺎوي ﻋﺪد اﻷﻋﻤﺪة ﻓﻲ ﻋﺪد اﻷﺳﻄﺮ‪ ،‬ﻓﻲ ﺣﺎﻟﺘﻨﺎ أﻋﻼه ﻓﻌﺪد ﻋﻨﺎﺻﺮ‬

‫ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﺧﻤﺴﺔ أﻋﻤﺪة وأرﺑﻌﺔ أﺳﻄﺮ ھﻮ ﻋﺸﺮون ﺧﺎﻧﺔ ﻻﺣﺘﻮاء ﻗﯿﻢ اﻟﻌﻨﺎﺻﺮ‪.‬‬

‫‪86‬‬
 ‫‪‬‬
‫ﻓﯿﻤﺎ ﯾﻠﻲ ﻣﺜﺎل ﺑﺮﻣﺠﻲ ﯾﻮﺿﺢ ﻛﯿﻔﯿﺔ اﻹﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺎت اﻟﺜﻨﺎﺋﯿﺔ اﻟﺒﻌﺪ وﺗﻌﺒﺌﺔ ﻋﻨﺎﺻﺮھﺎ‬

‫ﺑﺎﻟﻘﯿﻢ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫‪//‬ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﻋﻤﻮدﯾﻦ وﺛﻼﺛﺔ أﺳﻄﺮ‬
‫رﻗﻤﻲ ﻣﺼﻔﻮﻓﺔ_ﺛﻨﺎﺋﯿﺔ ]‪ [2,3‬؛‬

‫‪ //‬ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع رﻗﻤﻲ ﻟﻠﻘﯿﺎم ﺑﻌﻤﻠﯿﺔ ﺗﻜﺮار ﺗﺬھﺐ ﻣﻦ أول ﻋﻨﺼﺮ إﻟﻰ آﺧﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‬
‫رﻗﻤﻲ ﻋﺪاد_اﻷﻋﻤﺪة‪ ،‬ﻋﺪاد_اﻷﺳﻄﺮ ؛‬

‫‪//‬ﺗﺨﺰﯾﻦ اﻟﻘﯿﻢ ﻓﻲ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺣﺴﺐ اﻟﺮﺗﺒﺔ ‪Index‬‬

‫ﻣﺼﻔﻮﻓﺔ_ﺛﻨﺎﺋﯿﺔ ]‪18 → [0,0‬؛‬
‫ﻣﺼﻔﻮﻓﺔ_ﺛﻨﺎﺋﯿﺔ ]‪14 → [0,1‬؛‬
‫ﻣﺼﻔﻮﻓﺔ_ﺛﻨﺎﺋﯿﺔ ]‪16 → [0,2‬؛‬

‫ﻣﺼﻔﻮﻓﺔ_ﺛﻨﺎﺋﯿﺔ ]‪11 → [1,0‬؛‬

‫ﻣﺼﻔﻮﻓﺔ_ﺛﻨﺎﺋﯿﺔ ]‪19 → [1,1‬؛‬
‫ﻣﺼﻔﻮﻓﺔ_ﺛﻨﺎﺋﯿﺔ ]‪20 → [1,2‬؛‬

‫‪//‬ﻋﺮض ﻛﻞ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‬

‫ﻷﺟﻞ ﻋﺪاد_اﻷﺳﻄﺮ → ‪ 0‬إﻟﻰ ‪2‬‬
‫ﻷﺟﻞ ﻋﺪاد_اﻷﻋﻤﺪة → ‪ 0‬إﻟﻰ ‪1‬‬
‫اﻛﺘﺐ )"ﻗﯿﻤﺔ اﻟﻌﻨﺼﺮ ھﻲ‪ +" :‬ﻣﺼﻔﻮﻓﺔ_ﺛﻨﺎﺋﯿﺔ]ﻋﺪاد_اﻷﺳﻄﺮ‪ ،‬ﻋﺪاد_اﻷﻋﻤﺪة[( ؛‬
‫ﻧﮭﺎﯾﺔ ﻷﺟﻞ‬
‫ﻧﮭﺎﯾﺔ ﻷﺟﻞ‬

‫اﻟﻨﮭﺎﯾﺔ‬

‫‪87‬‬
 ‫‪BEGIN‬‬
‫ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﻋﻤﻮدﯾﻦ وﺛﻼﺛﺔ أﺳﻄﺮ‪//‬‬
‫;]‪Int Two_Dimensional_Array[3,2‬‬

‫ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع رﻗﻤﻲ ﻟﻠﻘﯿﺎم ﺑﻌﻤﻠﯿﺔ ﺗﻜﺮار ﺗﺬھﺐ ﻣﻦ أول ﻋﻨﺼﺮ إﻟﻰ آﺧﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‪//‬‬
‫; ‪Int Count_Rows, Count_Columns‬‬

‫ﺗﺨﺰﯾﻦ اﻟﻘﯿﻢ ﻓﻲ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺣﺴﺐ اﻟﺮﺗﺒﺔ ‪//‬‬

‫; ‪Two_Dimensional_Array[0,0] ← 18‬‬
‫; ‪Two_Dimensional_Array[0,1] ← 14‬‬
‫; ‪Two_Dimensional_Array[0,2] ← 16‬‬

‫; ‪Two_Dimensional_Array[1,0] ← 11‬‬
‫; ‪Two_Dimensional_Array[1,1] ← 19‬‬
‫; ‪Two_Dimensional_Array[1,2] ← 20‬‬

‫ﻋﺮض ﻛﻞ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‪//‬‬

‫‪For Count_Columns ← 0 TO 2‬‬
‫‪For Count_Rows ← 0 TO 1‬‬
‫‪WRITE("The Element Is: "+‬‬
‫;)]‪Two_Dimensional_Array[Count_Columns, Count_Rows‬‬
‫‪END FOR‬‬
‫‪END FOR‬‬
‫‪END‬‬

‫‪Copying Arrays‬‬
‫ﺗﻮﻓﺮ ﺑﻌﺾ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ وﻇﺎﺋﻒ ‪ Methods‬ﺧﺎﺻﺔ ﺑﻨﺴﺦ ﻣﺤﺘﻮى ﻋﻨﺎﺻﺮ ﻣﻦ ﻣﺼﻔﻮﻓﺔ‬

‫إﻟﻰ ﻣﺼﻔﻮﻓﺔ أﺧﺮى‪ ،‬ﻓﻤﺜﻼ ﻧﺠﺪ ﻓﻲ ﻟﻐﺎت اﻟﺪوت ﻧﯿﺖ )اﻟﻔﯿﺠﻮال ﺑﺴﯿﻚ دوت ﻧﯿﺖ‪ ،‬وﺳﻲ‬

‫ﺷﺎرب( وﻇﯿﻔﺔ ﺗﺴﻤﻰ ‪ ،Clone‬ﺗﻘﻮم ﺑﻨﺴﺦ ﻣﺤﺘﻮى ﻣﺼﻔﻮﻓﺔ إﻟﻰ ﻣﺼﻔﻮﻓﺔ أﺧﺮى‪ ،‬ﻛﺬﻟﻚ ﻓﻲ‬

‫ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺗﻮﺟﺪ داﻟﺔ ﺑﻨﻔﺲ اﻻﺳﻢ ‪ Clone‬ﺗﻘﻮم ﺑﮭﺬا اﻟﺪور‪.‬‬

‫‪88‬‬
‫ﺑﺈﻣﻜﺎﻧﻨﺎ اﻻﺳﺘﻐﻨﺎء ﻋﻦ ھﺬه اﻟﺪاﻟﺔ واﻟﻘﯿﺎم ﺑﻨﺴﺦ ﻣﺤﺘﻮى اﻟﻤﺼﻔﻮﻓﺔ ﺑﻮاﺳﻄﺔ ﺗﻜﺮار ﺑﺴﯿﻂ ﯾﻨﻘﻞ‬

‫ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ اﻷﺻﻠﯿﺔ إﻟﻰ اﻟﻤﺼﻔﻮﻓﺔ اﻟﻤﺴﺘﮭﺪﻓﺔ ﻛﻤﺎ ﺗﻌﺮض ﻟﻨﺎ اﻟﺨﻮارزﻣﯿﺔ اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫اﻟﺒﺪاﯾﺔ‬
‫‪//‬اﻹﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺘﯿﻦ اﻷﺻﻠﯿﺔ واﻟﮭﺪف‬
‫رﻗﻤﻲ ﻣﺼﻔﻮﻓﺔ_رﻗﻤﯿﺔ_اﻟﻤﺼﺪر ]‪ [5‬؛‬
‫رﻗﻤﻲ ﻣﺼﻔﻮﻓﺔ_رﻗﻤﯿﺔ_اﻟﮭﺪف ]‪ [5‬؛‬
‫رﻗﻤﻲ ﻋﺪاد ؛‬

‫‪//‬ﺗﺨﺰﯾﻦ اﻟﻘﯿﻢ ﻓﻲ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺣﺴﺐ اﻟﺮﺗﺒﺔ‬

‫ﻣﺼﻔﻮﻓﺔ_رﻗﻤﯿﺔ_اﻟﻤﺼﺪر ]‪100 → [0‬؛‬
‫ﻣﺼﻔﻮﻓﺔ_رﻗﻤﯿﺔ_اﻟﻤﺼﺪر ]‪760 → [1‬؛‬
‫ﻣﺼﻔﻮﻓﺔ_رﻗﻤﯿﺔ_اﻟﻤﺼﺪر ]‪324 → [2‬؛‬
‫ﻣﺼﻔﻮﻓﺔ_رﻗﻤﯿﺔ_اﻟﻤﺼﺪر ]‪109 → [3‬؛‬
‫ﻣﺼﻔﻮﻓﺔ_رﻗﻤﯿﺔ_اﻟﻤﺼﺪر ]‪221 → [4‬؛‬

‫‪//‬ﻧﺴﺦ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ اﻟﻤﺼﺪر إﻟﻰ اﻟﻤﺼﻔﻮﻓﺔ اﻟﮭﺪف‬

‫ﻷﺟﻞ ﻋﺪاد → ‪ 0‬إﻟﻰ ‪4‬‬
‫ﻣﺼﻔﻮﻓﺔ_رﻗﻤﯿﺔ_ اﻟﮭﺪف ]ﻋﺪاد[ → ﻣﺼﻔﻮﻓﺔ_رﻗﻤﯿﺔ_اﻟﻤﺼﺪر]ﻋﺪاد[‬
‫ﻧﮭﺎﯾﺔ ﻷﺟﻞ‬

‫اﻟﻨﮭﺎﯾﺔ‬

‫‪89‬‬
BEGIN
//‫اﻹﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺘﯿﻦ اﻷﺻﻠﯿﺔ واﻟﮭﺪف‬
Int SourceNumericArray[5];
Int TargetNumericArray[5];

//‫ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع رﻗﻤﻲ ﻟﻠﻘﯿﺎم ﺑﻌﻤﻠﯿﺔ ﺗﻜﺮار ﺗﺬھﺐ ﻣﻦ أول ﻋﻨﺼﺮ إﻟﻰ آﺧﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‬
Int Count;

// ‫ﺗﺨﺰﯾﻦ اﻟﻘﯿﻢ ﻓﻲ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺣﺴﺐ اﻟﺮﺗﺒﺔ‬

SourceNumericArray[0] ← 100 ;
SourceNumericArray[1] ← 760 ;
SourceNumericArray[2] ← 324 ;
SourceNumericArray[3] ← 109 ;
SourceNumericArray[4] ← 221 ;

//‫ﻋﺮض ﻛﻞ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‬

For Count ← 0 TO 4
TargetNumericArray[Count] ← SourceNumericArray[Count];
END FOR
END

90
 ‫اﻟﺨﺎﺗﻤﺔ‬
‫ﺗﻢ ﺑﻔﻀﻞ اﷲ وﻋﻮﻧﮫ اﻻﻧﺘﮭﺎء ﻣﻦ ﻛﺘﺎب "اﻟﺒﺤﺮ اﻟﺸﺎﺳﻊ ﻟﺪﺧﻮل اﻟﺨﻮارزﻣﯿﺎت ﻣﻦ ﺑﺎﺑﮭﺎ‬

‫اﻟﻮاﺳﻊ" ﻋﻠﻰ أﻣﻞ أن أﻛﻮن ﻗﺪ وﻓﻘﺖ ﻓﻲ ﺷﺮح وﺗﺒﺴﯿﻂ أﺳﺲ اﻟﺘﻔﻜﯿﺮ اﻟﺒﺮﻣﺠﻲ‪ ،‬وﺗﺠﺪر‬

‫اﻹﺷﺎرة إﻟﻰ أن ھﺬا اﻟﻜﺘﺎب ﻣﺎھﻮ إﻻ ﺑﺎب ﻟﺪﺧﻮل ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﺔ وﺗﻠﯿﮫ ﺧﻄﻮات ﻋﻤﻠﯿﺔ أﺧﺮى‪.‬‬

‫ﯾﻤﻜﻨﻚ ﺗﺤﻤﯿﻞ ﺑﺎﻗﻲ ﻛﺘﺐ اﻟﺴﻠﺴﻠﺔ وﻏﯿﺮھﺎ ﻟﻜﻲ ﺗﺘﻀﻠﻊ أﻛﺜﺮ ﻓﻲ اﻟﺒﺮﻣﺠﺔ‪ ،‬ﻛﻤﺎ ﯾﻤﻜﻨﻚ أﯾﻀﺎ أن‬

‫ﺗﺸﺘﺮك ﻓﻲ اﻟﻘﻨﺎة ﻋﻠﻰ اﻟﯿﻮﺗﯿﻮب ﻟﺘﺴﺘﻔﯿﺪ ﻣﻦ اﻟﻤﺤﺘﻮى اﻟﻤﻌﺮﻓﻲ اﻟﻤﺮﺋﻲ‪.‬‬

‫ﻟﻜﻞ ﺷﻲء إذا ﻣﺎ ﺗﻢ ﻧﻘﺼﺎن‪ ،‬ﻓﺈن وﺟﺪﺗﻢ ﻓﻲ ﻃﯿﺎت ھﺬا اﻟﻜﺘﺎب أﺧﻄﺎء ﻟﻐﻮﯾﺔ أو ﺗﻘﻨﯿﺔ أو ﻟﺪﯾﻜﻢ‬

‫ﻣﻼﺣﻈﺎت واﻗﺘﺮاﺣﺎت ﻟﺘﺤﺴﯿﻦ اﻟﺴﻠﺴﻠﺔ ﻓﻼ ﺗﺘﺮددوا ﺑﻤﺮاﺳﻠﺘﻨﺎ ﻋﺒﺮ اﻟﻌﻨﺎوﯾﻦ اﻻﻟﻜﺘﺮوﻧﯿﺔ‬

‫اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫‪mobarmijoun@gmail.com‬‬

‫‪how2progspace@gmail.com‬‬

‫وﻛﺬﻟﻚ زﯾﺎرﺗﻨﺎ ﻋﻠﻰ ﻣﻮﻗﻊ أﻛﺎدﯾﻤﯿﺔ اﻟﻤﺒﺮﻣﺠﯿﻦ اﻟﻌﺮب‪:‬‬

‫‪www.mobarmjoun.com‬‬

‫وﻣﺘﺎﺑﻌﺘﻨﺎ ﻋﺒﺮ ﻗﻨﺎﺗﻨﺎ ﻋﻠﻰ اﻟﯿﻮﺗﯿﻮب وﺻﻔﺨﺘﻨﺎ ﻋﻠﻰ اﻟﻔﯿﺴﺒﻮك‪:‬‬

‫‪www.youtube.com/EssaadaniTV‬‬

‫‪www.facebook.com/EssaadaniPage‬‬

‫‪91‬‬