‫ﺘﺘﻤﺎﺕ ﻓﻲ ﻟﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ‬

‫ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺤﻜﻡ ﺍﻟﻤﺸﺘﻘﺔ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻷﺴﺎﺴﻴﺔ‬

‫ﻤﻘﺩﻤﺔ‬
‫ﻴﻤﻜﻥ ﺃﻥ ﻨﻌﺒ‪‬ﺭ ﻋﻥ ﺒﻌﺽ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺤﻜﻡ ﺍﻷﺴﺎﺴﻴﺔ )ﺍﻟﺸﺭﻁﻴﺔ ﻭﺍﻟﺘﻜﺭﺍﺭﻴـﺔ( ﺒﻁﺭﻴﻘـﺔ ﻤﺨﺘﻠﻔـﺔ‬
‫ﺘﺼﻑ ﻤﺎﻫﻴﺔ ﺍﻟﻌﻤل ﺍﻟﺫﻱ ﻨﻘﻭﻡ ﺒﻪ "ﺨﻭﺍﺭﺯﻤﻴﹰﺎ" ﺃﻭ ﻤﺎ ﻨﻔﻜﺭ ﺒﻪ ﻓﻲ ﺨﻁـﻭﺍﺕ ﺍﻟﺤـل ﻭﺼـﻔﹰﺎ ﺃﺩﻕ‬
‫ﻭﺃﺴﻬل‪ .‬ﻫﺫﺍ ﺍﻟﺸﻜل ﺍﻟﻤﺨﺘﻠﻑ ﻟﻠﺘﻌﺒﻴﺭ ﻋﻥ ﺍﻟﺘﺤﻜﻡ ﻗﺩ ﻨﺠﺩﻩ ﻤﺒﺎﺸﺭﺓ ﻓﻲ ﺃﻏﻠﺏ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‪ .‬ﻤﺜﺎل‬
‫ﺫﻟﻙ‪ ،‬ﺘﻌﻠﻴﻤﺔ "ﻤﻥ ﺃﺠل )ﻗﻴﻡ ﻟﻠﻤﺘﺤﻭل ‪ i‬ﺘﺒﺩﺃ ﺒﻜﺫﺍ ﻭﺘﻨﺘﻬﻲ ﺒﻜﺫﺍ ( ﻜﺭ‪‬ﺭ >ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤـﺎﺕ< "‪،‬‬
‫‪.‬‬ ‫‪for‬‬ ‫ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺘﺠﺩ ﺘﻌﻠﻴﻤ ﹰﺔ ﻤﻜﺎﻓﺌ ﹰﺔ ﻟﻬﺎ ﻓﻲ ﻤﻌﻅﻡ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﺘﺩﻋﻰ ﺘﻌﻠﻴﻤﺔ‬

‫ﻟﻜﻨﻙ ﺘﺴﺄل ﻫﻨﺎ‪ ،‬ﺃﻟﻡ ﻨﻘل ﺃﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻷﺴﺎﺴﻴﺔ ﺍﻟﺨﻤﺴﺔ ﻜﺎﻓﻴﺔ ﻟﻠﺘﻌﺒﻴﺭ ﻋﻥ ﺨﻭﺍﺭﺯﻤﻴﺘﻨﺎ ﻭ ﺍﻟﺘﺤﻜﻡ‬
‫ﺒﻤﺴﺎﺭﺍﺕ ﺘﻨﻔﻴﺫ ﺍﻟﺤل‪.‬‬
‫ﻴﺒﻘﻰ ﻤﺎ ﺫﻜﺭﻨﺎﻩ ﺼﺤﻴﺤﹰﺎ ‪ :‬ﺇﻥ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺤﻜﻡ ﺍﻷﺴﺎﺴﻴﺔ )ﺍﻟﺸﺭﻁﻴﺔ ﻭﺍﻟﺘﻜﺭﺍﺭﻴﺔ( ﻜﺎﻓﻴﺔ ﻟﻠﺘﻌﺒﻴـﺭ‬
‫ﻋﻥ ﻤﺴﺎﺭ ﺍﻟﺤل ﻓﻲ ﺇﻱ ﻤﻥ ﺨﻭﺍﺭﺯﻤﻴﺘﻨﺎ‪ ،‬ﻭﻟﺫﻟﻙ ﺴﻨﺭﻯ ﺃﻥ ﺠﻤﻴﻊ ﻫﺫﻩ ﺍﻟﺒﻨﻰ ﺍﻟﺠﺩﻴـﺩﺓ ﻟﻠـﺘﺤﻜﻡ ‪،‬‬
‫ﺍﻟﺘﻲ ﺴﻨﻁﺭﺤﻬﺎ ﻫﻨﺎ‪ ،‬ﺠﺭﻯ ﺍﺸﺘﻘﺎﻗﻬﺎ ﻤﻥ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺤﻜﻡ ﺍﻷﺴﺎﺴﻴﺔ )ﺍﻟﺸﺭﻁﻴﺔ ﻭﺍﻟﺘﻜﺭﺍﺭﻴﺔ(‪ .‬ﻭﻟﻜﻨﻨﺎ‬
‫ﻨﺸﺠﻊ ﻋﻠﻰ ﺍﺴﺘﺨﺩﺍﻡ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺒﻨﻰ ﺍﻟﺠﺩﻴﺩﺓ‪ ،‬ﻓﻬﻲ ﺘﺴﻬل ﺍﻟﺘﻌﺒﻴﺭ ﻋﻥ ﺤﻠﻨﺎ‪ ،‬ﻭﺘﺯﻴﺩ ﻤﻥ ﻭﻀـﻭﺡ‬
‫ﺍﻟﻘﺭﺍﺀﺓ ﻟﺨﻭﺍﺭﺯﻤﻴﺘﻨﺎ ﻭ ﺒﺭﺍﻤﺠﻨﺎ ‪.‬‬

‫‪1‬‬
 ‫ﺍﻷﺸﻜﺎل ﺍﻷﺨﺭﻯ ﻟﻠﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ‪ ،‬ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﺒﻌﺩ‪‬ﺍﺩ‬
‫ﻻﺤﻅﻨﺎ ﻓﻲ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺨﻭﺍﺭﺯﻤﻴﺎﺘﻨﺎ‪ ،‬ﺤﻴﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﻜﺭﺍﺭ‪ ،‬ﺃﻱ ﺘﻌﻠﻴﻤﺔ‬
‫ﻤﺎﺩﺍﻡ >ﺸﺭﻁ< ﻜﺭ‪‬ﺭ‬
‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬
‫ﺃﻥ ﺘﻜﺭﺍﺭ ﺍﻟﺘﻨﻔﻴﺫ ﻤﺸﺭﻭﻁ ﺒﻘﻴﻤﺔ ﻋﺩّﺍﺩ )ﻤﺘﺤﻭل ﻋﺩﺩﻱ ﺼﺤﻴﺢ ﺘﺘﺯﺍﻴﺩ ﻗﻴﻤﺘﻪ ﺨﻁﻭﺓ ﺨﻁـﻭﺓ( ﺘﻘـﻊ‬
‫ﺒﻴﻥ ﻗﻴﻤﺔ ﺒﺩﺍﺌﻴﺔ ﻭﻗﻴﻤﺔ ﻨﻬﺎﺌﻴﺔ‪.‬‬
‫ﺍﻟﻌﺩّﺍﺩ ﻭﻴﻤﻜﻨﻨﺎ ﺘﺴﻤﻴﺘﻪ ﻤﺘﺤﻭل ﺍﻟﺘﻜﺭﺍﺭ‪ .‬ﻭﻟﻴﻜﻥ ﻟﺩﻴﻨﺎ ﺘﺠﻤﻊ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻲ‪:‬‬ ‫‪counter‬‬ ‫ﻟﻴﻜﻥ‬

‫‪counter‬‬ ‫‪Å‬‬ ‫> ﺘﻌﺒﻴﺭ‪<1‬‬

‫ﻤﺎ ﺩﺍﻡ ) ‪ counter‬ﺃﺼﻐﺭ ﺃﻭ ﻴﺴﺎﻭﻱ >ﺘﻌﺒﻴﺭ‪ ( <2‬ﻜﺭ‪‬ﺭ‬

‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬
‫‪counter Å counter + 1‬‬

‫ﻴﻤﻜﻥ ﺍﻟﺘﻌﺒﻴﺭ ﻋﻤﺎ ﺴﺒﻕ ﺒﺎﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ‪:‬‬

‫ﺍﻟﺘﻲ ﺘﺒﺩﺃ ﺒﻘﻴﻤﺔ ﺍﻟﺘﻌﺒﻴﺭ >ﺘﻌﺒﻴﺭ‪<1‬‬ ‫‪counter‬‬ ‫ﻜـﺭ‪‬ﺭ >ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ< ﻤﻥ ﺃﺠل ﻗﻴﻡ‬
‫ﻭﺘﻨﺘﻬﻲ ﺒﺎﻟﻘﻴﻤﺔ >ﺘﻌﺒﻴﺭ‪.<2‬‬

‫ﻓﻠﻨﻜﺘﺏ ﺍﻟﺘﻌﺒﻴﺭ ﺍﻟﺴﺎﺒﻕ ﻋﻠﻰ ﻨﺤ ٍﻭ ﻤﻬﻴﻜل ﺃﺴﻭ ﹰﺓ ﺒﺒﻘﻴﺔ ﺘﻌﻠﻴﻤﺎﺘﻨﺎ ﺍﻟﻤﻬﻴﻜﻠﺔ ﺍﻷﺨﺭﻯ‪:‬‬

‫ﻜﺭ‪‬ﺭ‬ ‫ﺘﺒﺩﺃ ﻤﻥ > ﺘﻌﺒﻴﺭ‪ <1‬ﻭﺘﻨﺘﻬﻲ ﺇﻟﻰ >ﺘﻌﺒﻴﺭ‪<2‬‬ ‫‪counter‬‬ ‫ﻤﻥ ﺃﺠل ﻗﻴﻡ‬

‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬

‫ﺇﺫﻥ‪ ،‬ﺘﻌﻤل ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻜﻤﺎ ﻴﻠﻲ‪:‬‬

‫ﺃﺼﻐﺭ ﺃﻭ ﺘﺴﺎﻭﻱ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻌﻠﻴﺎ ﻟﻤﺠﺎل ﺍﻟﺘﻜﺭﺍﺭ > ﺘﻌﺒﻴـﺭ‪ <2‬ﺘﹸﻨﻔﱠـﺫ‬ ‫‪counter‬‬ ‫ﻤﺎﺩﺍﻤﺕ ﻗﻴﻤﺔ ﺍﻟﻌﺩّﺍﺩ‬
‫ﺘـﺴﺎﻭﻱ ‪،counter+1‬‬ ‫‪counter‬‬ ‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ< ﻭﻴﺯﺩﺍﺩ ﺍﻟﻌﺩّﺍﺩ ﺁﻟﻴﺎ ﺨﻁﻭﺓ‪ ،‬ﺃﻱ ﺘﺼﺒﺢ ﻗﻴﻤﺔ‬
‫ﺘﹸﺨﺘﺒ‪‬ﺭ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺠﺩﻴﺩﺓ ﺇﻥ ﻜﺎﻨﺕ ﻀﻤﻥ ﻤﺠﺎل ﺍﻟﺘﻜﺭﺍﺭ‪ ،‬ﺘﻨ ﹶﻔّﺫ >ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ< ﻤﻥ ﺠﺩﻴﺩ‪ ،‬ﻴﺯﺩﺍﺩ‬
‫ﺍﻟﻌﺩّﺍﺩ ﻤﻊ ﻜل ﺘﻨﻔﻴﺫ‪ ،‬ﻭ ﻴﺠﺭﻱ ﺘﻜﺭﺍﺭ ﺫﻟﻙ‪:‬‬
‫ﺍﺨﺘﺒﺎﺭ ﻗﻴﻤﺔ ﺍﻟﻌﺩّﺍﺩ‪ ،‬ﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ‪ ،‬ﺯﻴﺎﺩﺓ ﺍﻟﻌﺩّﺍﺩ ﺤﺘﻰ ﻴﺘﺠﺎﻭﺯ ﺍﻟﻌﺩّﺍﺩ ﻤﺠﺎل ﺍﻟﺘﻜﺭﺍﺭ ﺃﻱ ﺍﻟﻘﻴﻤـﺔ‬
‫>ﺘﻌﺒﻴﺭ‪.<2‬‬

‫‪2‬‬
 ‫ﻭﺴﻨﻜﺘﺏ ﺍﻟﺘﻌﺒﻴﺭ ﺍﻟﺴﺎﺒﻕ ﻤﻥ ﺍﻵﻥ ﻓﺼﺎﻋﺩﹰﺍ ﺒﺎﻟﺸﻜل‪:‬‬

‫ﺤﺘﻰ >ﺘﻌﺒﻴﺭ‪ <2‬ﻜﺭ‪‬ﺭ‬ ‫> ﺘﻌﺒﻴﺭ‪counter← <1‬‬ ‫ﻤﻥ ﺃﺠل‬

‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬

‫ﻤﻼﺤﻅﺎﺕ‪:‬‬
‫ﺇﻥ ﺸﻜل ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﺒﻌﺩّﺍﺩ‪ ،‬ﻋﺩﺍ ﻋﻥ ﺘﻌﺒﻴﺭﻩ ﺍﻟﻭﺍﻀﺢ ﺃﻥ ﺍﻟﺘﻜـﺭﺍﺭ ﻤـﺸﺭﻭﻁ‬
‫ﺒﻘﻴﻤﺔ ﻤﺘﺤﻭل ﺘﻜﺭﺍﺭ ﻤﺤﺩﺩ ﺍﻟﻤﺠﺎل‪ ،‬ﻓﺈﻨﻪ ﻴﻠﺯﻤﻙ ﺒﻌﺩﻡ ﻨﺴﻴﺎﻥ ﺇﻋﻁﺎﺀ ﺍﻟﻘﻴﻤـﺔ ﺍﻟﺒﺩﺍﺌﻴـﺔ‬
‫ﻟﻤﺘﺤﻭل ﺍﻟﺘﻜﺭﺍﺭ‪ ،‬ﻭ ﻴﻀﻤﻥ ﻟﻙ ﺯﻴﺎﺩﺓ ﻫﺫﺍ ﺍﻟﻤﺘﺤﻭل )ﺍﻟﻌﺩﺍﺩ( ﺨﻁﻭﺓ‪ ،‬ﻭﺍﻟﺫﻱ ﻜﻨﺕ ﻤـﻥ‬
‫ﺍﻟﻤﻤﻜﻥ ﺃﻥ ﺘﻨﺴﺎﻩ ﻓﻲ ﺍﻟﺤﻠﻘﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﺍﻟﻌﺎﺩﻴﺔ‪ ،‬ﻭﺘﺩﺨل ﻓﻲ ﺤﻠﻘﺔ ﻻ ﻨﻬﺎﺌﻴﺔ‪.‬‬
‫ﻴﻨﺼﺢ ﺒﺸﺩﺓ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺤﻠﻘﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﺇﻥ ﻜﺎﻥ ﺍﻟﺘﻜﺭﺍﺭ ﻤﺸﺭﻭﻁﹰﺎ ﺒﻌـﺩّﺍﺩ ﻴﺘﺯﺍﻴـﺩ‬
‫ﺨﻁﻭﺓ ﺨﻁﻭﺓ ﻤﻊ ﻜل ﺘﻜﺭﺍﺭ‪ .‬ﻭﻴﻨﺼﺢ ﺒﺸﺩﺓ ﻋﺩﻡ ﺘﻐﻴﻴﺭ ﻗﻴﻤﺔ ﺍﻟﻌﺩّﺍﺩ )ﻤﺘﺤﻭل ﺍﻟﺘﻜﺭﺍﺭ(‬
‫ﻀﻤﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ‪.‬‬
‫ﺇﻥ ﻟﻡ ﻨﻐﻴﺭ ﻗﻴﻤﺔ ﻤﺘﺤﻭل ﺍﻟﺘﻜﺭﺍﺭ ﺨﻼل ﺘﻜﺭﺍﺭ ﺘﻨﻔﻴﺫ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ)ﻭﻫـﺫﺍ ﻤـﺎ‬
‫ﻨﺼﺤﻨﺎ ﺒﻪ( ‪ ،‬ﻭﺇﻥ ﺘﺭﻙ ﺘﻜﺭﺍﺭ ﺍﻟﺘﻨﻔﻴﺫ ﻴﺠﺭﻱ ﺒﺸﻜل ﻁﺒﻴﻌﻲ ﺒﻼ ﺇﻨﻘﻁﺎﻉ‪ ،‬ﻓﺴﺘﻜﻭﻥ ﻗﻴﻤﺔ‬
‫ﺍﻟﻌﺩّﺍﺩ )ﻤﺘﺤﻭل ﺍﻟﺤﻠﻘﺔ( ﻴﺴﺎﻭﻱ ﺍﻟﻘﻴﻤﺔ >ﺘﻌﺒﻴﺭ‪ ،1+ <2‬ﻋﻨـﺩ ﺍﻨﺘﻬـﺎﺀ ﻫـﺫﻩ ﺍﻟﺘﻌﻠﻴﻤـﺔ‬
‫ﺍﻟﺘﻜﺭﺍﺭﻴﺔ‪.‬‬

‫ﺘﹸﻌﻁﻰ ﻜﺩﺨل‪.‬‬ ‫‪M‬‬ ‫ﺤﻴﺙ‬ ‫‪1, 2, 3,...M‬‬ ‫ﻤﺜﺎل‪ :‬ﺤﺴﺎﺏ ﻤﺠﻤﻭﻉ ﺍﻷﻋﺩﺍﺩ‬
‫ﺨﻭﺍﺭﺯﻤﻴﺔ ﺍﻟﺤل ﺍﻟﺴﺎﺒﻘﺔ ﺒﺎﺴﺘﺨﺩﺍﻡ‪:‬‬
‫ﺗﻌﻠﻴﻤﺔ اﻟﺘﻜﺮار ﺑﻌﺪّاد‬ ‫ﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭ ﺍﻷﺴﺎﺴﻴﺔ‬

‫ﺍﻗﺭﺃ ‪M‬‬ ‫ﺍﻗﺭﺃ ‪M‬‬

‫‪SÅ0‬‬ ‫‪SÅ0‬‬
‫ﻣﻦ أﺟﻞ ‪ i Å 1‬ﺣﺘﻰ ‪ M‬آﺮﱢر‬
‫‪iÅ1‬‬
‫‪SÅS+i‬‬
‫ﻤﺎﺩﺍﻡ ) ‪ ( i ≤ M‬ﻜﺭ‪‬ﺭ‬
‫ﺍﻜﺘﺏ ‪S‬‬ ‫‪S Å S +i‬‬
‫‪i Å i +1‬‬

‫ﺍﻜﺘﺏ ‪S‬‬

‫‪3‬‬
 ‫ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‪:‬‬
‫ﻫﺫﺍ ﺍﻟﺘﻌﺒﻴﺭ ﻋﻥ ﺍﻟﺘﻜﺭﺍﺭ ﻤﻭﺠﻭﺩ ﻓﻲ ﺃﻜﺜﺭ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ )ﺘﻌﻠﻴﻤﺔ ‪ :for‬ﻓﻲ ‪.Ada, Pascal, Basic‬‬
‫ﻓﻲ ‪.(Fortran‬‬ ‫‪DO‬‬ ‫ﻭﺘﻌﻠﻴﻤﺔ‬

‫‪Basic‬‬

‫‪For I=1 To M‬‬

‫‪S = S+I‬‬
‫‪Next I‬‬

‫‪C, Java:‬‬

‫ﺒﺩﻭﺭ ﺍﻟﺘﻜﺭﺍﺭ ﺒﻌﺩّﺍﺩ‪ ،‬ﻭ ﻫﺫﻩ ﺘﻌﻠﻴﻤﺔ ﺫﺍﺕ ﻋﻤﻭﻤﻴﺔ ﺃﻜﺒﺭ‪ ،‬ﻭﻟﻜﻨﻨـﺎ ﺴـﻨﺭﻯ ﻓﻘـﻁ‬ ‫‪for‬‬ ‫ﺘﻘﻭﻡ ﺘﻌﻠﻴﻤﺔ‬
‫ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻟﻠﺘﻜﺭﺍﺭ ﺒﻌﺩّﺍﺩ ﺨﻁﻭﺓ ﺨﻁﻭﺓ‪:‬‬
‫اﺳﻢ ﻣﺘﺤﻮل اﻟﺘﺤﻜﻢ ﺑﺎﻟﺘﻜﺮار‬ ‫اﻟﻘﻴﻤﺔ اﻟﻨﻬﺎﺋﻴﺔ ﻟﻤﺘﺤﻮل اﻟﺘﻜﺮار‬
‫↓‬ ‫↓‬
‫;‪ → for ( i = 1‬آﻠﻤﺔ ﻣﻔﺘﺎﺣﻴﺔ‬ ‫;‪i <= M‬‬ ‫) ‪i++‬‬ ‫};‪{S= S+i‬‬
‫↑‬ ‫↑‬
‫اﻟﻘﻴﻤﺔ اﻻﺑﺘﺪاﺋﻴﺔ ﻟﻤﺘﺤﻮل اﻟﺘﻜﺮار‬ ‫زﻳﺎدة ﻗﻴﻤﺔ ﻣﺘﺤﻮل اﻟﺘﻜﺮار ﺑﻮاﺣﺪ‬
‫ﺍﻷﺠﺯﺍﺀ ﺍﻟﻤﺅﻟﻔﺔ ﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭ ‪for‬‬

‫ﺘﹸﻌﻁﻰ ﻜﺩﺨل‪.‬‬ ‫‪M‬‬ ‫ﺤﻴﺙ‬ ‫‪1, 2, 3,...M‬‬ ‫ﻤﺜﺎل‪ :‬ﺤﺴﺎﺏ ﻤﺠﻤﻭﻉ ﺍﻷﻋﺩﺍﺩ‬
‫ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ ﻤﻜﺘﻭﺏ ﺒﻠﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪:Java‬‬

‫ﻧﺘﻴﺠﺔ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‬

‫‪15‬‬

‫‪4‬‬
 ‫ﺍﻷﺸﻜﺎل ﺍﻷﺨﺭﻯ ﻟﻠﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ‪ ،‬ﻜﺭ‪‬ﺭ_ﻤﺭﺓ_ﻭﺍﺤﺩﺓ_ﻋﻠﻰ_ﺍﻷﻗل‬
‫ﻋﻨﺩﻤﺎ ﺘﺄﺨﺫ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﻤﺎﺩﺍﻡ ‪ ...‬ﻜﺭﺭ ﺍﻹﻁﺎﺭ ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻨﺭﻯ ﺃﻨﻨﺎ ﻫﻨﺎ ﻨﻨﻔﺫ >ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ< ﺜﻡ ﻨﺨﺘﺒـﺭ ﺼـﺤﺔ‬ ‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬
‫ﺍﻟﺸﺭﻁ ﻟﻨﺘﺎﺒﻊ ﺘﻜﺭﺍﺭ ﺘﻨﻔﻴﺫ ﻨﻔﺱ >ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ< ﻤﺎﺩﺍﻡ‬ ‫ﻜﺭ‪‬ﺭ‬ ‫)ﺍﻟﺸﺭﻁ(‬ ‫ﻤﺎﺩﺍﻡ‬
‫)ﺍﻟﺸﺭﻁ( ﺼﺤﻴﺤﹰﺎ‪.‬‬ ‫> ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬
‫ﺇﺫﻥ > ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ< ﺴﺘﻨﻔﱠﺫ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻋﻠﻰ ﺍﻷﻗل‪ ،‬ﺜﻡ‬
‫ﻤﺭﺓ ﺃﻭ ﺃﻜﺜﺭ ﺤﺘﻰ ﻴﺼﺒﺢ )ﺍﻟﺸﺭﻁ( ﻏﻴﺭ ﺼﺤﻴﺢ‪.‬‬ ‫‪0‬‬ ‫ﻴﺘﻜﺭﺭ ﺘﻨﻔﻴﺫ >ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‪،‬‬

‫ﻴﻤﻜﻥ ﻗﺭﺍﺀﺓ ﺍﻟﺴﺎﺒﻕ ﻜﻤﺎ ﻴﻠﻲ‪:‬‬

‫ﻜﺭﺭ ﺘﻨﻔﻴﺫ > ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ< ﺤﺘﻰ ﻴﺼﺒﺢ )ﺍﻟﺸﺭﻁ( ﻏﻴﺭ ﻤﺤﻘﻕ‪.‬‬
‫ﻭﻴﻤﻜﻥ ﺃﻥ ﻨﻌﻁﻲ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﺍﻹﻁﺎﺭ ﺍﻟﺘﺎﻟﻲ ﺃﻴﻀﹶﺎ‪:‬‬

‫ﻜﺭ‪‬ﺭ‬

‫> ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬

‫ﺤﺘﻰ ﻨﻔﻲ )ﺍﻟﺸﺭﻁ(‬

‫ﻜﺭ‪‬ﺭ‬ ‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬

‫> ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬ ‫ﻜﺭ‪‬ﺭ‬ ‫)ﺍﻟﺸﺭﻁ(‬ ‫ﻤﺎﺩﺍﻡ‬

‫ﺤﺘﻰ ﻨﻔﻲ )ﺍﻟﺸﺭﻁ(‬ ‫> ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬

‫)‪(2‬‬ ‫)‪(1‬‬

‫ﻤﺘﻜﺎﻓﺌﺎﻥ‪ ،‬ﻭﻜﻼﻫﻤﺎ ﻴﺠﻤﻊ ﻓﻜﺭﺓ ﺍﻟﺘﻨﻔﻴﺫ ﻟﹻ >ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ< ﺃﻭﻻﹰ‪ ،‬ﺜﻡ‬ ‫)‪(2‬‬ ‫ﻭ‬ ‫)‪(1‬‬ ‫ﺇﻥ ﺍﻹﻁﺎﺭﻴﻥ‬
‫ﺘﻜﺭﺍﺭ ﺍﻟﺘﻨﻔﻴﺫ ﻟﻬﺫﻩ ﺍﻟﻤﺠﻤﻭﻋﺔ ﻭﻟﻜﻥ ﺒﺸﺭﻁ‪.‬‬

‫ﺃﻜﺜﺭ ﺇﻴﺠﺎﺯﺍﹰ‪ ،‬ﻭﻗﺩ ﻴﻜﻭﻥ ﺃﻭﻀـﺢ ﺘﻌﺒﻴـﺭﹰﺍ‪ .‬ﻭﺍﻟﻔﻜـﺭﺓ‬ ‫)‪(2‬‬ ‫ﺇﻥ ﺍﻟﺘﻌﺒﻴﺭ "ﺍﻟﺨﻭﺍﺭﺯﻤﻲ" ﻓﻲ ﺍﻹﻁﺎﺭ‬
‫ﺍﻷﺴﺎﺴﻴﺔ ﻫﻲ ﺘﻜﺭﺍﺭ ﺘﻨﻔﻴﺫ ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ﻟﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻋﻠﻰ ﺍﻷﻗل‪.‬‬

‫‪5‬‬
‫ﻓﻠﻨﻜﺘﺏ ﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭ ﻜﺭ‪‬ﺭ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻋﻠﻰ ﺍﻷﻗل‪ .‬ﻋﻠﻰ ﻨﺤ ٍﻭ ﻤﻬﻴﻜل ﺃﺴـﻭ ﹰﺓ ﺒﺒﻘﻴـﺔ ﺘﻌﻠﻴﻤﺎﺘﻨـﺎ‬
‫ﺍﻟﻤﻬﻴﻜﻠﺔ ﺍﻷﺨﺭﻯ‪:‬‬
‫ﻜﺭ‪‬ﺭ‬
‫> ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ<‬
‫ﺤﺘﻰ )ﺍﻟﺸﺭﻁ(‬

‫ﺘﻨﻔﺫ >ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ< ﺃﻭل ﻤﺭﺓ‪ ،‬ﻴﺘﻜﺭﺭ ﺘﻨﻔﻴﺫ >ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ< ﺤﺘﻰ ﻴـﺼﺒﺢ ﺍﻟـﺸﺭﻁ‬
‫ﺼﺤﻴﺤ ﹰﺎ‪.‬‬

‫ﻤﺜﺎل‪ :‬ﺤﺴﺎﺏ ﻤﺠﻤﻭﻉ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﻴﺠﺭﻱ ﺇﺩﺨﺎﻟﻬﺎ ﻟﻠﺒﺭﻨﺎﻤﺞ‪ ،‬ﻴﻨﺘﻬﻲ ﺍﻹﺩﺨﺎل‬
‫ﺒﺎﻟﻘﻴﻤﺔ ‪.999‬‬
‫ﺨﻭﺍﺭﺯﻤﻴﺔ ﺍﻟﺤل ﺒﺎﺴﺘﺨﺩﺍﻡ ﺘﻌﻠﻴﻤﺔ‪:‬‬
‫ﺍﻟﺘﻜﺭﺍﺭ ﻟﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻋﻠﻰ ﺍﻷﻗل‬ ‫ﺍﻟﺘﻜﺭﺍﺭ ﺍﻷﺴﺎﺴﻴﺔ‬
‫‪nÅ 0‬‬ ‫‪nÅ 0‬‬

‫‪Sum Å 0‬‬ ‫‪Sum Å 0‬‬

‫ﻜﺭّﺭ‬ ‫‪Sum Å Sum + n‬‬

‫ﺍﻗﺭﺃ ‪n‬‬
‫‪Sum Å Sum + n‬‬
‫ﻤﺎﺩﺍﻡ ) ‪ n‬ﻻ ﻴﺴﺎﻭﻱ ‪ ( 999‬ﻜﺭﺭ‬
‫ﺍﻗﺭﺃ ‪n‬‬ ‫‪Sum Å Sum + n‬‬
‫ﺤﺘﻰ ) ‪ n‬ﻴﺴﺎﻭﻱ ‪( 999‬‬
‫ﺍﻗﺭﺃ ‪n‬‬
‫ﺍﻜﺘﺏ ‪”Sum= ”, Sum‬‬
‫ﺍﻜﺘﺏ ‪”Sum= ”, Sum‬‬

‫ﻼ ﻟﻨﻬﺎﻴﺔ ﺍﻟﻤﺠﻤﻭﻋﺔ‬
‫ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﻌﺩﺩ ‪ 999‬ﺩﻟﻴ ﹰ‬
‫ﻤﻼﺤﻅﺔ‪:‬‬
‫ﻟﻼﻨﺘﻅﺎﻡ ﺒﺎﻟﺘﻌﻠﻴﻤﺎﺕ‪ ،‬ﺃﻋﻁﻴﻨﺎ ﺠﻤﻴﻊ ﺍﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﻘﻴﻡ ﺍﻟﺒﺩﺍﺌﻴﺔ ‪ ،0‬ﺘﻌﻠﻴﻤﺔ ﺍﻹﺴﻨﺎﺩ‬
‫‪Sum Å Sum + n‬‬
‫ﻗﺒل ﺍﻟﺘﻜﺭﺍﺭ ﻴﻤﻜﻥ ﺍﻻﺴﺘﻐﻨﺎﺀ ﻋﻨﻬﺎ‪ ،‬ﻷﻥ ﻗﻴﻤﺔ ‪ Sum‬ﻗﺒل ﻭﺒﻌﺩ ﺍﻹﺴﻨﺎﺩ ﻫﻲ ‪ .0‬ﻭﻟﻜﻨﻨـﺎ ﺘﺭﻜﻨﺎﻫـﺎ‬
‫ﻟﻼﻨﺘﻅﺎﻡ ﻓﻬﻲ ﺘﺸﻜل ﻤﻊ ﺘﻌﻠﻴﻤﺔ ﺍﻟﻘﺭﺍﺀﺓ‪ ،‬ﻤﺠﻤﻭﻋﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻁﻠﻭﺏ ﺘﻜﺭﺍﺭ ﺘﻨﻔﻴﺫﻫﺎ ﻟﻤﺭﺓ ﻭﺍﺤﺩﺓ‬
‫ﻋﻠﻰ ﺍﻷﻗل‪.‬‬

‫‪6‬‬
 ‫ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‪:‬‬
‫ﺘﺘﻭﻓﺭ ﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭ_ ﻟﻤﺭﺓ _ﻭﺍﺤﺩﺓ _ﻋﻠﻰ _ﺍﻷﻗل‪ ،‬ﻭﻓﻕ ﺍﻟﺼﻴﻐﺔ ﺍﻟﺘﻲ ﺸﺭﺤﻨﺎﻫﺎ ﻜﺭ‪‬ﺭ … ﺤﺘﻰ‪،‬‬
‫‪ .‬ﻭﺘﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﻔﺘﺎﺤﻴﺔ ‪ ،until‬ﺍﻟﻜﻠﻤـﺔ‬ ‫‪Visual Basic ،pascal‬‬ ‫ﻓﻲ ﻋﺩﺓ ﻟﻐﺎﺕ ﺒﺭﻤﺠﺔ ﻤﺜل‬
‫ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ﺍﻟﻤﻭﺍﻓﻘﺔ ﻟﻠﻜﻠﻤﺔ ﺤﺘﻰ‪.‬‬
‫‪Pascal‬‬ ‫ﻓﻲ‬
‫‪Repeat‬‬
‫;‪Sum := sum + n‬‬
‫;)‪Readln(n‬‬
‫;)‪Until (n=999‬‬
‫ﻓﻲ ‪:C, Java‬‬
‫ﺘﺘﻭﻓﺭ ﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭ_ ﻟﻤﺭﺓ _ﻭﺍﺤﺩﺓ _ﻋﻠﻰ _ﺍﻷﻗل‪ ،‬ﻭﻟﻜﻥ ﻟﻴﺱ ﻭﻓﻕ ﺍﻟﺼﻴﻐﺔ ﺍﻟﺘﻲ ﺸﺭﺤﻨﺎﻫﺎ‬
‫ﻜﺭ‪‬ﺭ … ﺤﺘﻰ ﻴﺘﺤﻘﻕ ﺸﺭﻁ‪.‬‬
‫ﺇﺫ ﺘﺘﻭﻓﺭ ﺘﻌﻠﻴﻤﺔ ﻭﻓﻕ ﺼﻴﻐﺔ‪ :‬ﻜﺭ‪‬ﺭ …‪ .‬ﻤﺎﺩﺍﻡ ﺸﺭﻁ ﻤﺤﻘﻕ‪.‬‬
‫ﻭﻟﻜـﻥ‬ ‫‪while‬‬ ‫ﺘﻀﻴﻑ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﻔﺘﺎﺤﻴﺔ ‪ ،do‬ﻭﻫﻲ ﻨﻔﺱ ﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭ ﺍﻷﺴﺎﺴﻴﺔ‪:‬‬
‫ﺘﹸﻨﻔﱠﺫ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺨﺎﺼﺔ ﺒﻬﺎ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻋﻠﻰ ﺍﻷﻗل‪.‬‬
‫‪Java ،C‬‬ ‫ﺇﺫﻥ ﻓﻲ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﺍﻷﺴﺎﺴﻴﺔ‪:‬‬
‫{ )‪while ( codition‬‬
‫‪Instructions‬‬
‫}‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺘﻜﺭﺍﺭ ﺍﻟﺘﻨﻔﻴﺫ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻋﻠﻰ ﺍﻷﻗل‪:‬‬
‫{ ‪do‬‬
‫‪Instructions‬‬
‫;) ‪} while ( condition‬‬

‫ﻤﺜﺎل‪ :‬ﺤﺴﺎﺏ ﻤﺠﻤﻭﻉ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﻴﺠﺭﻱ ﺇﺩﺨﺎﻟﻬﺎ ﻟﻠﺒﺭﻨﺎﻤﺞ‪ ،‬ﻴﻨﺘﻬﻲ ﺍﻹﺩﺨﺎل‬
‫ﺒﺎﻟﻘﻴﻤﺔ ‪.999‬‬
‫ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ ﻤﻜﺘﻭﺏ ﺒﻠﻐﺔ ‪:Java‬‬

‫‪7‬‬
 ‫ﻤﻼﺤﻅﺎﺕ ﻋﻠﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ‬
‫‪ -1‬ﺇﻥ ﺘﻌﻠﻴﻤﺎﺕ ﺇﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺍﻟﺒﺩﺍﺌﻴﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ‪ ،‬ﻻ ﻴﻭﺠﺩ ﻟﻬـﺎ ﺘﻌﻠﻴﻤـﺎﺕ ﺇﺴـﻨﺎﺩ‬
‫ﻤﻘﺎﺒﻠﺔ ﻓﻲ ﺠﺯﺀ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ؟‬
‫ﺘﻌﻤﺩﻨﺎ ﺃﻥ ﻨﻌﻠﹼﻤﻙ ﺃﻤﺭﹰﺍ ﻤﺘﺎﺤﹰﺎ ﻓﻲ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﻭﻫﻭ ﺇﻋﻁﺎﺀ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺒﺩﺍﺌﻴﺔ ﻟﻠﻤﺘﺤﻭل‬
‫ﻋﻨﺩ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻨﻪ‪.‬‬
‫ﻓﻲ ﻋﺒـﺎﺭﺓ ﺍﻟﺘـﺼﺭﻴﺢ ﻋـﻥ ﻨﻤـﻁ‬ ‫‪n‬‬ ‫ﻟﻠﻤﺘﺤﻭل‬ ‫‪0‬‬ ‫ﻓﻔﻲ ﺍﻟﺴﻁﺭ ‪ ،2‬ﻴﺠﺭﻱ ﺇﻋﻁﺎﺀ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺒﺩﺍﺌﻴﺔ‬
‫ﺍﻟﻤﺘﺤﻭل‬
‫ﻓﻲ ﻋﺒﺎﺭﺓ ﺍﻟﺘﺼﺭﻴﺢ ﻋـﻥ ﻨﻤـﻁ‬ ‫‪sum‬‬ ‫ﻟﻠﻤﺘﺤﻭل‬ ‫‪0‬‬ ‫ﻭﻓﻲ ﺍﻟﺴﻁﺭ ‪ ،3‬ﻴﺠﺭﻱ ﺇﻋﻁﺎﺀ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺒﺩﺍﺌﻴﺔ‬
‫ﺍﻟﻤﺘﺤﻭل‬
‫ﻻ ﺘﻨﺱ ﺇﻋﻁﺎﺀ ﻗﻴﻡ ﺒﺩﺍﺌﻴﺔ ﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﺒﺭﻨﺎﻤﺞ‪ ،‬ﻭﻻ ﺘﻔﺘﺭﺽ ﺃﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻴﻌﻁﻴﻬﺎ ﻀﻤﻨﻴﹰﺎ ﺍﻟﻘﻴﻤـﺔ‬
‫‪.0‬‬
‫‪ -2‬ﻫل ﻴﻤﻜﻥ ﻫﻨﺎ‪ ،‬ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺜﺎل‪ ،‬ﺘﺒﺩﻴل ﺘﺭﺘﻴﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﻲ ﻴﺘﻜـﺭﺭ‬
‫ﺘﻨﻔﻴﺫﻫﺎ؟‬
‫)ﺍﻟﺫﻱ ﺍﺼﻁﻠﺤﻨﺎﻩ ﻨﻬﺎﻴﺔ ﻤﺠﻤﻭﻋﺔ ﺍﻷﻋـﺩﺍﺩ ﺍﻟﻤﺩﺨﻠـﺔ( ﺇﻟـﻰ‬ ‫‪999‬‬ ‫ﺒﺎﻟﻁﺒﻊ ﻻ! ﺇﺫ ﺴﻴﻀﺎﻑ ﺍﻟﻌﺩﺩ‬
‫ﺍﻟﻨﺘﻴﺠﺔ‪.‬‬

‫ﻜﺴﺭ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻬﻴﻜﻠﺔ‬

‫ﻤﻨﺫ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻷﻭﻟﻰ‪ ،‬ﻓﻲ ﺘﻌﻠﻴﻤﻙ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﺃﻜﺩﻨﺎ ﺃﻥ ﺘﺩﺭﻴﺱ ﺃﺴﺱ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﺍﺴﺘﻘﺭ ﺒﺎﺴـﺘﺨﺩﺍﻡ‬
‫ل ﻴﺘﻀﻤﻥ ﻜﺘﻠﺔ ﺘﻌﻠﻴﻤـﺎﺕ ﺘﻨﻔـﺫﻫﺎ ﺍﻟﺘﻌﻠﻴﻤـﺔ‪ ،‬ﻭﻓـﻲ‬
‫ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻬﻴﻜﻠﺔ‪ ،‬ﻓﻠﻜل ﺘﻌﻠﻴﻤﺔ ﺘﺤﻜﻡ ﻫﻴﻜ ٌُ‬
‫ﻜﺘﻠﺔ_ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺘﻌﻁﻰ ﻜل ﺘﻌﻠﻴﻤﺔ ﻓﻲ ﺍﻟﻜﺘﻠﺔ ﻫﻴﻜل…‪..‬ﻭﻫﻜﺫﺍ‪.‬‬

‫ﺇﻥ ﺍﻟﻤﻴﺯﺓ ﺍﻷﻫﻡ ﻓﻲ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻬﻴﻜﻠﺔ ﺃﻥ ﻟﻜل ﺘﻌﻠﻴﻤﺔ ﺒﺩﺍﻴﺔ ﻭﺍﺤﺩﺓ ﻭﻨﻬﺎﻴﺔ ﻭﺍﺤﺩﺓ‪ ،‬ﻤﻤـﺎ ﻴـﺴﻤﺢ‬
‫ﺒﻭﻀﻭﺡ ﻤﺴﺎﺭ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻤﺘﺎﺒﻌﺘﻪ‪.‬‬
‫ﻼ ﻓﻲ ﺍﻟﺒﻨﻴﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻠﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭﻴـﺔ‪ ،‬ﺇﺫﺍ‬
‫ﻓﻤﺜ ﹰ‬
‫ﺩﺨﻠﻨﺎ ﻟﺘﻨﻔﻴﺫ ﻜﺘﻠﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻼ ﻨﺨﺭﺝ ﺇﻻ ﻤـﻊ‬
‫ﺘﻨﻔﻴﺫ ﺁﺨﺭ ﺘﻌﻠﻴﻤـﺔ ﻓـﻲ ﺍﻟﻜﺘﻠـﺔ ﺃﻱ ﺗﻌﻠﻴﻤ ﺔ ‪.n‬‬
‫ﻭﻻﻴﻤﻜﻥ ﺃﻥ ﻨﺨﺭﺝ ﻤﻥ ﺍﻟﻜﺘﻠﺔ ﻤﻥ ﺃﻱ ﺘﻌﻠﻴﻤﺔ‬
‫ﺃﺨﺭﻯ ‪.‬‬
‫ﻭﻟﻜﻥ ﻋﻠﻲ ﺃﻻ ﺃﺨﻔﻲ ﻋﻠﻴﻙ ﻴﺎ ﺼﺩﻴﻘﻲ ﺃﻨﻨـﺎ ﻻ‬
‫ﻨﺤﺏ ﺩﻭﻤﹰﺎ ﺍﻹﻨﺘﻅﺎﻡ‪ ،‬ﻭﻨﻘﻭل ﻟﻠﻀﺭﻭﺭﺓ ﺃﺤﻜﺎﻡ!‬

‫‪8‬‬
‫ﻭﻫﻜﺫﺍ‪ ،‬ﺃﻴﻀﹰﺎ ﻓﻲ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﻴﺭﻯ ﺍﻟﺒﻌﺽ ﺃﻥ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻬﻴﻜﻠﺔ ﺃﻤﺭ ﺠﻴﺩ ﻭﻓﻭﺍﺌﺩﻫﺎ ﺍﻟﺘﻲ ﻋﺩﺩﻨﺎﻫﺎ‬
‫ﺴﺎﺒﻘﹰﺎ ﻤﺘﻔﻕ ﻋﻠﻴﻬﺎ‪ ،‬ﻭﻟﻜﻨﻬﺎ ﻟﻴﺱ ﻤﻘﺩﺴﺔ ﺒﺤﻴﺙ ﻻ ﻴﻤﻜﻥ ﺘﺠﺎﻭﺯﻫﺎ ﻓﻲ ﺤﺎﻻﺕ ﻤﻌﻴﻨﺔ ﺍﺴﺘﺜﻨﺎﺌﻴﺔ!‬

‫ﻭﻫﻜﺫﺍ‪ ،‬ﻏﺎﻟﺒﹰﺎ ﺘﺘﻴﺢ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻬﻴﻜﻠﺔ ﺘﻌﻠﻴﻤﺎﺕ ﺘﺤﻜﻡ ﺒﺈﻤﻜﺎﻨﻬﺎ ﻜﺴﺭ ﻗﻭﺍﻋﺩ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻬﻴﻜﻠﺔ‬
‫ﺒﺤﻴﺙ ﺘﺴﻤﺢ ﺒﺎﻟﺨﺭﻭﺝ ﻤﻥ ﻜﺘﻠﺔ ﺘﻌﻠﻴﻤﺎﺕ ﻗﺒل ﺍﻨﺘﻬﺎﺌﻬﺎ‪ .‬ﻭﻟﻜﻥ ﻴﻨﺼﺢ ﺩﻭﻤﹰﺎ ﺒﺎﺴﺘﺨﺩﺍﻤﻬﺎ ﻓﻲ‬
‫ﺍﻟﺤﺎﻻﺕ ﺍﻻﺴﺘﺜﻨﺎﺌﻴﺔ‪.‬‬

‫ﺘﻌﻠﻴﻤﺎﺕ ﻜﺴﺭ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻬﻴﻜﻠﺔ ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‬

‫ﻜﻨﺎ ﻗﺩ ﻨﻭﻫﻨﺎ ﺃﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻬﻴﻜﻠﺔ ﻫﻲ ﺍﻟﺘﻲ ﺘﻘﺩﻡ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺤﻜﻡ ﺍﻷﺴﺎﺴﻴﺔ ﺍﻟﺘﻲ ﻋﺭﻓﻨﺎﻫﺎ‬
‫ﻼ ﻟﻠﺘﻌﺒﻴﺭ ﻋﻥ ﻤﺴﺎﺭ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺤﻴﺙ ﻨﺴﺘﻐﻨﻲ ﺘﻤﺎﻤﹰﺎ‬
‫ﻓﻲ ﻟﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ‪ ،‬ﻭﺍﻟﺘﻲ ﺘﻜﻔﻲ ﻜﺎﻤ ﹰ‬
‫ﺍﻟﺘﻲ ﻜﺎﻨﺕ ﻫﻲ ﺍﻷﺴﺎﺱ ﻟﻠﺘﺤﻜﻡ ﻓﻲ ﺍﻷﺠﻴﺎل ﺍﻷﻭﻟﻰ ﻟﻠﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‬ ‫)‪(GOTO‬‬ ‫ﻋﻥ ﺘﻌﻠﻴﻤﺔ ﺍﻟﻘﻔﺯ‬
‫ﻋﺎﻟﻴﺔ ﺍﻟﻤﺴﺘﻭﻯ‪ .‬ﺇﻻ ﺃﻥ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻬﻴﻜﻠﺔ ﻗﺩ ﺍﺤﺘﻔﻅﺕ ﺒﻬﺎ ﻟﺘﺒﻘﻰ ﻤﺘﻭﺍﻓﻘﺔ ﻤﻊ‬
‫ﺍﻹﺼﺩﺍﺭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ‪ ،‬ﺃﻭ ﻭﻀﻌﺕ ﻤﺎ ﻴﻜﺎﻓﺌﻬﺎ ﺍﻟﺫﻱ ﻴﺴﻤﺢ ﻓﻘﻁ ﺒﺎﻟﺨﺭﻭﺝ ﺇﻟﻰ ﻤﺎﺒﻌﺩ ﻨﻬﺎﻴﺔ ﻜﺘﻠﺔ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻬﻴﻜﻠﺔ‪.‬‬
‫ﻓﻲ ‪:Visual Basic‬‬
‫ﻟﻠﺨﺭﻭﺝ ﺇﻟﻰ ﻨﻬﺎﻴﺔ ﻜﺘﻠﺔ ﺘﻌﻠﻴﻤﺎﺕ‪.‬‬ ‫‪Exit‬‬ ‫ﺍﻷﺴﺎﺴﻴﺔ ﺍﻟﻘﺩﻴﻤﺔ‪ .‬ﻭﺘﻭﺠﺩ ﺘﻌﻠﻴﻤﺔ‬ ‫‪Goto‬‬ ‫ﺘﻭﺠﺩ ﺘﻌﻠﻴﻤﺔ‬
‫ﻓﻲ ‪:Pascal, Fortran‬‬
‫‪Goto‬‬ ‫ﺘﻭﺠﺩ ﺘﻌﻠﻴﻤﺔ‬
‫ﻓﻲ ‪:Ada‬‬
‫ﻟﻠﺨﺭﻭﺝ ﺇﻟﻰ ﻨﻬﺎﻴﺔ ﻜﺘﻠﺔ ﺘﻌﻠﻴﻤﺎﺕ‪.‬‬ ‫‪Exit‬‬ ‫ﺘﻭﺠﺩ ﺘﻌﻠﻴﻤﺔ‬
‫ﻓﻲ ‪:C, Java‬‬
‫ﺇﻟﻰ ﺍﻟﺨﺭﻭﺝ ﺇﻟﻰ ﻤﺎ ﺒﻌﺩ ﻨﻬﺎﻴﺔ ﻜﺘﻠﺔ ﺘﻌﻠﻴﻤﺎﺕ‪.‬‬ ‫‪break‬‬ ‫ﺘﺅﺩﻱ ﺍﻟﺘﻌﻠﻴﻤﺔ‬

‫ﻤﺜﺎل‬
‫ﻟﻠﺨﺭﻭﺝ ﻤﻥ ﻜﺘﻠﺔ ﺘﻌﻠﻴﻤﺎﺕ‪.‬‬ ‫‪break‬‬ ‫ﺇﻨﻪ ﻤﺜﺎل ﺒﺴﻴﻁ ﻴﻬﺩﻑ ﻓﻘﻁ ﺇﻟﻰ ﺘﻭﻀﻴﺢ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ‬
‫ﺍﻟﻤﻁﻠﻭﺏ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺘﻜﺭﺍﺭ ﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺎﺕ ﻤﺎﺩﺍﻤﺕ ﻗﻴﻡ ‪ i‬ﺃﺼﻐﺭ ﺃﻭ ﻴﺴﺎﻭﻱ ﻗﻴﻤﺔ ﻤﻌﻴﻨﺔ )ﺍﻟﻘﻴﻤﺔ‬
‫ﻓﻲ ﻤﺜﺎﻟﻨﺎ(‪ ،‬ﻭﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻁﻠﻭﺏ ﺘﻜﺭﺍﺭ ﺘﻨﻔﻴﺫﻫﺎ‪ ،‬ﻓﻲ ﻤﺜﺎﻟﻨﺎ ﻭﻟﻠﺘﺒﺴﻴﻁ‪ ،‬ﺘﻘﺘﺼﺭ ﻋﻠﻰ ﺘﻌﻠﻴﻤـﺔ‬ ‫‪13‬‬

‫ﺇﻅﻬﺎﺭ ﻗﻴﻤﺔ ‪.i‬‬

‫‪9‬‬
‫ﻫﺫﺍ ﻫﻭ ﺍﻟﻤﺴﺎﺭ ﺍﻷﺴﺎﺴﻲ ﻟﻌﻤل ﺒﺭﻨﺎﻤﺠﻨﺎ‪ .‬ﺃﻤﺎ ﺍﻻﺴﺘﺜﻨﺎﺀ ﻓﻬﻭ ﻗﻴﻡ ﺨﺎﺼﺔ ﻟﻠﻤﺘﺤﻭل ‪ ،i‬ﻨﺭﻴﺩ ﺇﻴﻘـﺎﻑ‬
‫ﻤﻥ ﻤﻀﺎﻋﻔﺎﺕ ‪ .4‬ﻭﻤـﺎ ﻨﻘـﺼﺩﻩ ﻫﻨـﺎ‬ ‫‪i‬‬ ‫ﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺒﺴﺒﺒﻬﺎ‪ .‬ﺍﻟﻘﻴﻡ ﺍﻟﺨﺎﺼﺔ ﻓﻲ ﻤﺜﺎﻟﻨﺎ ﻫﻲ‬
‫ﺘﺴﺎﻭﻱ ‪. (0‬‬ ‫‪4‬‬ ‫ﺒﻼ ﺒﺎﻗﻲ ) ﺒﺎﻗﻲ ﻗﺴﻤﺘﻪ ﻋﻠﻰ‬ ‫‪4‬‬ ‫‪ ،‬ﻫﻭ ﺃﻱ ﻋﺩﺩ ﺃﻜﺒﺭ ﻤﻥ ‪ ،4‬ﻭﻴﻘﺴﻡ‬ ‫‪4‬‬ ‫ﺒﻤﻀﺎﻋﻔﺎﺕ‬
‫ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ ﻤﻜﺘﻭﺏ ﺒﻠﻐﺔ ‪:Java‬‬

‫ﻧﺘﻴﺠﺔ ﺗﻨﻔﻴﺬ‬

‫‪i=0‬‬
‫‪i=1‬‬
‫‪i=2‬‬
‫‪i=3‬‬
‫‪i=4‬‬
‫‪i=5‬‬
‫‪i=6‬‬
‫‪i=7‬‬

‫ﻤﻼﺤﻅﺎﺕ ﻋﻠﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ‬

‫‪ ،‬ﻷﻨﻬﺎ ﻤﻥ‬ ‫‪8‬‬ ‫ﺘﻭﻗﱠﻑ ﻋﻨﺩ ﺍﻟﻘﻴﻤﺔ‬ ‫‪while‬‬ ‫ﻻﺤﻅ ﺃﻥ ﺘﻜﺭﺍﺭ ﺘﻨﻔﻴﺫ ﻤﺠﻤﻭﻋﺔ‪/‬ﻜﺘﻠﺔ ﺘﻌﻠﻴﻤﺎﺕ‬
‫ﻟﻠﺨﺭﻭﺝ ﺇﻟﻰ ﻤﺎﺒﻌﺩ‬ ‫‪break‬‬ ‫ﻤﻀﺎﻋﻔﺎﺕ ‪ ،4‬ﻓﻘﺩ ﻭﻀﻌﻨﺎ ﺫﻟﻙ ﺸﺭﻁﹰﺎ ﻨﻨﻔﺫ ﻋﻨﺩﻩ ﺘﻌﻠﻴﻤﺔ‬
‫ﻜﺘﻠﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ‪.‬‬
‫ﻻﺤﻅ ﺃﻨﻪ ﺒﺈﻤﻜﺎﻨﻨﺎ ﺘﺤﻘﻴﻕ ﺍﻟﻨﺘﻴﺠﺔ ﻨﻔﺴﻬﺎ ﺒﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺘﻌﻠﻴﻤﺔ ﻜﺴﺭ‬
‫ﺍﻟﺤﻠﻘﺔ ‪ ،break‬ﻜﻴﻑ؟ ﺒﺒﺴﺎﻁﺔ ﻻ ﻨﺭﻴﺩ ﺍﺴﺘﻤﺭﺍﺭ ﺘﻜﺭﺍﺭ ﺍﻟﺘﻨﻔﻴﺫ ﻋﻨﺩﻤﺎ ﻴﻜﻭﻥ ﺍﻟﺸﺭﻁ‬
‫ﺍﻟﺫﻱ ﺍﺴﺘﺨﺩﻤﻨﺎﻩ ﻟﻜﺴﺭ ﺍﻟﺤﻠﻘﺔ ﺼﺤﻴﺤﺎﹰ‪ ،‬ﻨﻀﻴﻑ ﺫﻟﻙ ﻜﺸﺭﻁ ﺇﻟﻰ ﺸﺭﻁ ﺘﻜﺭﺍﺭ ﺍﻟﺤﻠﻘﺔ‪.‬‬
‫ﻤﻥ ﺍﻟﻭﺍﻀﺢ ﺃﻴﻀﹰﺎ ﺃﻥ ﺍﻟﺤﻠﻘﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻫﻲ ﺤﻠﻘﺔ ﺘﻜﺭﺍﺭﻴﺔ ﻤﺸﺭﻭﻁﺔ‬
‫ﺒﻌﺩﺍﺩ‪ .‬ﻟﺫﻟﻙ ﻴﻤﻜﻥ ﺃﻥ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪.for‬‬

‫ﻤﻼﺤﻅـﺔ‪ :‬ﻭﻀﻌﻨﺎ ﺘﻌﻠﻴﻤﺔ ﺍﻟﺨﺭﻭﺝ ﻤﻥ ﺍﻟﻜﺘﻠﺔ ﻜﺘﻌﻠﻴﻕ‪ ،‬ﻭﻭﻀﻌﻨﺎ ﺸﺭﻁﻬﺎ ﻓﻲ ﺘﺭﻭﻴـﺴﺔ ﺍﻟﺘﻌﻠﻴﻤـﺔ‬
‫ﺍﻟﻤﻬﻴﻜﻠﺔ ‪.while‬‬

‫‪10‬‬
‫‪،‬‬ ‫‪for‬‬ ‫‪ ،‬ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﻌﻠﻴﻤـﺔ‬ ‫‪C, Java‬‬ ‫ﻤﻼﺤﻅﺔ‪ :‬ﻨﻌﺭّﻓﻙ ﻫﻨﺎ ﻋﻠﻰ ﺸﻜل‪ ،‬ﻤﺄﻟﻭﻑ ﻟﺩﻯ ﻤﺒﺭﻤﺠﻲ‬
‫ﺤﻴﺙ ﻴﺠﺭﻱ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﻤﺘﺤﻭل ﺍﻟﺤﻠﻘﺔ ‪ i‬ﻭﺇﻋﻁﺎﺅﻩ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺒﺩﺍﺌﻴـﺔ ﻤﺒﺎﺸـﺭ ﹰﺓ ﻓـﻲ ﺘﺭﻭﻴـﺴﺔ‬
‫ﺘﺴﻤﺤﺎﻥ ﺒﺎﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﺤﻭﻻﺕ ﺩﺍﺨل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺃﻴﻀﺎﹰ‪ ،‬ﻭﻟـﻴﺱ‬ ‫‪Java, C‬‬ ‫ﺍﻟﺘﻌﻠﻴﻤﺔ‪ .‬ﺫﻜﺭﻨﺎ ﺃﻥ‬
‫ﺒﺎﻟﻀﺭﻭﺭﺓ ﻓﻲ ﺃﻭﻟﻪ ﻓﻘﻁ‪.‬‬

‫‪C, Java‬‬ ‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ continue‬ﻓﻲ‬

‫ﺃﺭﻴﺩ ﺍﻟﻘﻴﺎﻡ ﺒﻨﻔﺱ ﺍﻟﻌﻤل ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﻪ ﺍﻟﻤﺜﺎل ﺍﻟﺒﺭﻤﺠﻲ ﺍﻟﺴﺎﺒﻕ‪ ،‬ﻭﻟﻜﻥ ﺃﺭﻴﺩ ﻟﺒﺭﻨﺎﻤﺠﻲ ﺃﻻ ﻴﺘﻭﻗـﻑ‬
‫ﻋﻥ ﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺤﻠﻘﺔ )ﺇﻅﻬﺎﺭ ‪ (i‬ﻋﻨﺩﻤﺎ ﻴﺼل ﺇﻟﻰ ﺍﻻﺴﺘﺜﻨﺎﺀ ﺍﻟﺫﻱ ﻋﺭﻓﺘﻪ )‪ i‬ﻤﻥ ﻤـﻀﺎﻋﻔﺎﺕ‬
‫‪ ،(4‬ﺃﻱ ﻻ ﺃﺭﻴﺩ ﺍﻟﺨﺭﻭﺝ ﻤﻥ ﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭ‪ ،‬ﺒل ﺃﺭﻴﺩ ﻤﻨﻪ ﺍﻻﻨﺘﻘﺎل ﺒﺎﻟﺘﻨﻔﻴﺫ ﺇﻟﻰ ﺍﻟﺘﻜﺭﺍﺭ ﺍﻟﺘـﺎﻟﻲ‬
‫ﻤﺒﺎﺸﺭ ﹰﺓ ﺩﻭﻥ ﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺤﻠﻘﺔ‪.‬‬
‫ﺍﻟﻤﻁﻠﻭﺏ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺘﻜﺭﺍﺭ ﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺎﺕ ﻤﺎﺩﺍﻤﺕ ﻗﻴﻡ ‪ i‬ﺃﺼﻐﺭ ﺃﻭ ﻴﺴﺎﻭﻱ ﻗﻴﻤﺔ ﻤﻌﻴﻨﺔ )ﺍﻟﻘﻴﻤﺔ‬
‫ﻓﻲ ﻤﺜﺎﻟﻨﺎ(‪ ،‬ﻭﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻁﻠﻭﺏ ﺘﻜﺭﺍﺭ ﺘﻨﻔﻴﺫﻫﺎ‪ ،‬ﻓﻲ ﻤﺜﺎﻟﻨﺎ ﻭﻟﻠﺘﺒﺴﻴﻁ‪ ،‬ﺘﻘﺘﺼﺭ ﻋﻠﻰ ﺘﻌﻠﻴﻤـﺔ‬ ‫‪13‬‬

‫ﺇﻅﻬﺎﺭ ﻗﻴﻤﺔ ‪.i‬‬

‫ﻫﺫﺍ ﻫﻭ ﺍﻟﻤﺴﺎﺭ ﺍﻷﺴﺎﺴﻲ ﻟﻌﻤل ﺒﺭﻨﺎﻤﺠﻨﺎ‪ .‬ﺃﻤﺎ ﺍﻻﺴﺘﺜﻨﺎﺀ ﻓﻬﻭ ﻗﻴﻡ ﺨﺎﺼﺔ ﻟﻠﻤﺘﺤﻭل ‪ ،i‬ﻨﺭﻴﺩ ﺇﻴﻘـﺎﻑ‬
‫ﻤﻥ ﻤﻀﺎﻋﻔﺎﺕ ‪ .4‬ﻭﻤـﺎ ﻨﻘـﺼﺩﻩ ﻫﻨـﺎ‬ ‫‪i‬‬ ‫ﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺒﺴﺒﺒﻬﺎ‪ .‬ﺍﻟﻘﻴﻡ ﺍﻟﺨﺎﺼﺔ ﻓﻲ ﻤﺜﺎﻟﻨﺎ ﻫﻲ‬
‫ﺘﺴﺎﻭﻱ ‪. (0‬‬ ‫‪4‬‬ ‫ﺒﻼ ﺒﺎﻗﻲ ) ﺒﺎﻗﻲ ﻗﺴﻤﺘﻪ ﻋﻠﻰ‬ ‫‪4‬‬ ‫‪ ،‬ﻫﻭ ﺃﻱ ﻋﺩﺩ ﺃﻜﺒﺭ ﻤﻥ ‪ ،4‬ﻭﻴﻘﺴﻡ‬ ‫‪4‬‬ ‫ﺒﻤﻀﺎﻋﻔﺎﺕ‬
‫ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ‪:‬‬
‫ﻧﺘﻴﺠﺔ ﺗﻨﻔﻴﺬ‬
‫‪i=0‬‬
‫‪i=1‬‬
‫‪i=2‬‬
‫‪i=3‬‬
‫‪i=4‬‬
‫‪i=5‬‬
‫‪i=6‬‬
‫‪i=7‬‬
‫‪i=9‬‬
‫‪i = 10‬‬
‫‪i = 11‬‬
‫‪i = 13‬‬

‫‪11‬‬
 ‫ﻤﻼﺤﻅﺎﺕ ﻋﻠﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ‬
‫ﺤﺘﻰ ‪،7‬‬ ‫‪1‬‬ ‫ﻻﺤﻅ ﺃﻥ ﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺤﻠﻘﺔ )ﺇﻅﻬﺎﺭ ﻗﻴﻤﺔ ‪ (i‬ﺠﺭﻯ ﻤﻥ ﺃﺠل ﺍﻟﻘﻴﻡ ﻤﻥ‬
‫)ﻤﻀﺎﻋﻔﺎﺕ ‪ (4‬ﻟﻡ ﻴﺘﻡ ﺍﻟﺘﻨﻔﻴﺫ‪/‬ﺍﻹﻅﻬﺎﺭ ﺒل ﺘﺎﺒﻌﻨﺎ ﻤﺒﺎﺸﺭ ﹰﺓ ﺍﺨﺘﺒﺎﺭ‬ ‫‪8‬‬ ‫ﻭﻟﻜﻥ ﻋﻨﺩ ﺍﻟﻘﻴﻤﺔ‬
‫‪ ،‬ﺸﺭﻁ ﺍﻟﺤﻠﻘﺔ ﺼﺤﻴﺢ‪ ،‬ﺇﺫﻥ‬ ‫‪i=9‬‬ ‫ﺸﺭﻁ ﺍﻟﺘﻜﺭﺍﺭ ﻨﺘﻴﺠﺔ ﺘﻨﻔﻴﺫ ‪ ،continue‬ﻫﻨﺎ ﺼﺎﺭﺕ‬
‫‪i‬‬ ‫‪.‬ﺜﻡ‪ ،‬ﺘﺄﺨﺫ‬ ‫‪11 ،10‬‬ ‫‪،‬‬ ‫‪9‬‬ ‫ﻨﻨﻔﺫ ﺘﻌﻠﻴﻤﺔ ﺍﻟﺤﻠﻘﺔ ﺃﻱ ﺇﻅﻬﺎﺭ ‪ ،i‬ﻭﻫﻜﺫﺍ ﻴﺘﻜﺭﺭ ﺍﻹﻅﻬﺎﺭ ﻟﻠﻘﻴﻡ‬
‫ﺍﻟﻘﻴﻤﺔ ‪)12‬ﻋﺩﺩ ﻤﻥ ﻤﻀﺎﻋﻔﺎﺕ ‪ ،(4‬ﺇﺫﻥ ﺘﻨﻔﱠﺫ ‪ ،continue‬ﻓﻨﻨﺘﻘل ﻤﺒﺎﺸﺭ ﹰﺓ ﺇﻟﻰ ﺍﺨﺘﺒﺎﺭ‬
‫ﺸﺭﻁ ﺍﻟﺤﻠﻘﺔ ﻤﻊ ﺍﻟﻘﻴﻤﺔ ‪…13‬‬
‫ﻤﻥ ﺍﻟﻭﺍﻀﺢ ﺃﻴﻀﹰﺎ ﺃﻥ ﺍﻟﺤﻠﻘﺔ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻫﻲ ﺤﻠﻘﺔ ﺘﻜﺭﺍﺭﻴﺔ ﻤﺸﺭﻭﻁﺔ‬
‫ﺒﻌﺩﺍﺩ‪ .‬ﻟﺫﻟﻙ ﻴﻤﻜﻥ ﺃﻥ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪.for‬‬

‫ﺍﻷﺸﻜﺎل ﺍﻷﺨﺭﻯ ﻟﻠﺘﻌﻠﻴﻤﺔ ﺍﻟﺸﺭﻁﻴﺔ‪ ،‬ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺸﺭﻁﻴﺔ ﻤﺘﻌﺩﺩﺓ ﺍﻻﺨﺘﻴﺎﺭ‬

‫ﻻ ﻨﻘﺭﺭ ﻭﻓﻘﹰﺎ ﻟﻘﻴﻤﺘﻪ ﺍﺨﺘﻴﺎﺭﺍﺕ ﻤﺘﻌﺩﺩﺓ‪ .‬ﺃﻱ ﻜﺎﻥ ﻟﺩﻴﻨﺎ ﺘﺠﻤﻴـﻊ ﺍﻟﺘﻌﻠﻴﻤـﺎﺕ ﻋﻠـﻰ‬
‫ﻤﺘﺤﻭ ﹰ‬ ‫‪c‬‬ ‫ﺇﺫﺍ ﻜﺎﻥ‬
‫ﺍﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ‪:‬‬

‫ﻴﻤﻜﻥ ﺃﻥ ﻨﻌﺒ‪‬ﺭ ﻋﻥ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺎﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ‪:‬‬ ‫ﺇﺫﺍ )‪ = c‬ﺍﻟﻘﻴﻤﺔ‪-‬ﺍﻟﺜﺎﺒﺘﺔ‪ (1-‬ﻨﻔﺫ‬

‫ﻗﻴﻤﺔ ﺘﺴﺎﻭﻱ )ﺍﻟﻘﻴﻤﺔ‪-‬‬ ‫‪c‬‬ ‫ﻓﻲ ﺍﻟﺤﺎﻟﺔ ﺍﻟﺘﻲ ﻴﺄﺨﺫ ﻓﻴﻬﺎ‬ ‫|>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ‪<1‬‬

‫ﺍﻟﺜﺎﺒﺘﺔ‪ (1-‬ﻨﻔﺫ >ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ‪ ،<1‬ﻭﻓﻲ ﺍﻟﺤﺎﻟﺔ‬

‫ﺇﺫﺍ )‪ = c‬ﺍﻟﻘﻴﻤﺔ‪-‬ﺍﻟﺜﺎﺒﺘﺔ‪ (2-‬ﻨﻔﺫ‬
‫ﺍﻟﺘﻲ ﺘﺄﺨﺫ ﻗﻴﻤﺔ ﺘﺴﺎﻭﻱ )ﺍﻟﻘﻴﻤـﺔ‪-‬ﺍﻟﺜﺎﺒﺘـﺔ‪ (2-‬ﻨﻔـﺫ‬
‫|>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ‪<2‬‬
‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ‪ ... <2‬ﻭﻫﻜﺫﺍ ﺩﻭﺍﻟﻴﻙ ﺇﻟـﻰ ﺃﻥ‬
‫‪.......................‬‬
‫ﻨﺼل ﺇﻟﻰ ﻤﻌﺎﻟﺠﺔ ﺤﺎﻟﺔ )ﺍﻟﻘﻴﻤﺔ‪-‬ﺍﻟﺜﺎﺒﺘﺔ‪.( n-‬‬

‫ﺇﺫﺍ )‪ = c‬ﺍﻟﻘﻴﻤﺔ‪-‬ﺍﻟﺜﺎﺒﺘﺔ‪ (n-‬ﻨﻔﺫ‬

‫|>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ‪<n‬‬

‫‪12‬‬
 ‫ﻭﻴﻤﻜﻥ ﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﻋﻠﻰ ﻨﺤﻭ ﻤﻬﻴﻜل ﻭﻤﺅﻁﺭ ﻜﻤﺎ ﻴﻠﻲ‪:‬‬
‫ﺘﺄﺨﺫ‬ ‫ﻓﻲ ﺤﺎﻟﺔ ‪c‬‬

‫ﺍﻟﻘﻴﻤﺔ‪-‬ﺍﻟﺜﺎﺒﺘﺔ‪ 1-‬ﻨﻔﱢﺫ‬
‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ‪<1‬‬
‫ﺍﻟﻘﻴﻤﺔ‪-‬ﺍﻟﺜﺎﺒﺘﺔ‪ 2-‬ﻨﻔﱢﺫ‬
‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ‪<2‬‬

‫ﻨﻔﱢﺫ‬ ‫‪.....‬‬
‫‪.....‬‬
‫ﻨﻔﱢﺫ‬ ‫‪.....‬‬
‫‪.....‬‬
‫ﺍﻟﻘﻴﻤﺔ‪-‬ﺍﻟﺜﺎﺒﺘﺔ‪ n-‬ﻨﻔﱢﺫ‬
‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ‪< n‬‬

‫‪Single-selection structure‬‬ ‫ﻴﻤﻜﻨﻨﺎ ﺘﺴﻤﻴﺔ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺇﺫﺍ "ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺸﺭﻁﻴﺔ ﻭﺤﻴﺩﺓ ﺍﻻﺨﺘﻴﺎﺭ"‬
‫ﻷﻨﻬﺎ ﺘﺴﻤﺢ ﺒﺎﺨﺘﻴﺎﺭ ﺃﻭ ﺘﺠﺎﻫل ﻓﻌل ﻭﺤﻴﺩ‪ .‬ﻭﻨﺴﻤﻲ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺇﺫﺍ ‪..‬ﻭﺇﻷ " ﺒﺎﻟﺘﻌﻠﻴﻤﺔ‬
‫ﻷﻨﻬﺎ ﺘﺴﻤﺢ ﺒﺎﻻﺨﺘﻴﺎﺭ ﻤﺎ ﺒﻴﻥ‬ ‫‪double-selection structure‬‬ ‫ﺍﻟﺸﺭﻁﻴﺔ ﻤﻀﺎﻋﻔﺔ ﺍﻻﺨﺘﻴﺎﺭ"‬
‫‪multiple-‬‬ ‫ﻓﻌﻠﻴﻥ ﻤﺨﺘﻠﻔﻴﻥ‪ .‬ﻓﻲ ﺤﻴﻥ ﺘﺴﻤﺢ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻓﻲ ﺤﺎﻟﺔ " ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ﻤﺘﻌﺩﺩﺓ ﺍﻻﺨﺘﻴﺎﺭ"‬
‫ﻷﻨﻬﺎ ﺘﺴﻤﺢ ﺒﺎﺨﺘﻴﺎﺭ ﻓﻌل ﻤﺤﺩﺩ ﻤﻥ ﺒﻴﻥ ﻤﺠﻤﻭﻋﺔ ﻤﻤﻜﻨﺔ ﻤﻥ ﺍﻷﻓﻌﺎل‬ ‫‪selection structure‬‬

‫ﺍﻟﻤﺨﺘﻠﻔﺔ‪ ،‬ﻭﺫﻟﻙ ﺤﺴﺏ ﻗﻴﻤﺔ ﺘﻌﺒﻴﺭ ﻤﻌﻴﻥ‪.‬‬

‫ﻭﺭﺒﻤﺎ ﺘﻜﻭﻥ ﻤﻌﺎﻟﺠﺘﻨﺎ ﻟﻼﺨﺘﻴﺎﺭ ﺍﻟﻤﺘﻌﺩﺩ‪ ،‬ﺒﺄﻥ ﺘﻜﻭﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﻲ ﺴﺘﻨﻔﱢﺫ ﻫﻲ ﻨﻔﺴﻬﺎ ﻤﻥ‬
‫ﺃﺠل ﻋﺩﺓ ﻗﻴﻡ ﺜﺎﺒﺘﺔ‪.‬‬
‫ﻭﻟﻜﻲ ﺘﻜﻭﻥ ﻤﻌﺎﻟﺠﺘﻨﺎ ﺸﺎﻤﻠﺔ ﻟﻠﺤﺎﻻﺕ ﺍﻟﻤﺨﺘﻠﻔﺔ ﻟﻘﻴﻡ ‪ ،c‬ﻴﻤﻜﻥ ﺃﻥ ﻴﻜﻭﻥ ﻟﺩﻴﻨﺎ ﻤﻌﺎﻟﺠﺔ ﺨﺎﺼﺔ‬
‫>ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ﺃﺨﺭﻯ< ﻋﻨﺩﻤﺎ ﺘﺄﺨﺫ ‪ c‬ﻗﻴﻡ ﺃﺨﺭﻯ ﻤﺨﺘﻠﻔﺔ ﻋﻥ ﺠﻤﻴﻊ ﺍﻟﻘﻴﻡ ﺍﻟﺜﺎﺒﺘﺔ ﺍﻟﺘﻲ ﻤﻴّﺯﻨﺎ‬
‫ﺤﺎﻻﺘﻬﺎ‪.‬‬

‫‪13‬‬
 ‫ﻨﻌﻁﻲ ﺍﻟﺼﻴﺎﻏﺔ ﺍﻟﻌﺎﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻠﺘﻌﺒﻴﺭ ﻋﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻤﺘﻌﺩﺩ ﺍﻻﺨﺘﻴﺎﺭ ﻓﻲ ﺤﺎﻟﺔ ‪:‬‬
‫ﻓﻲ ﺣﺎﻟﺔ ‪ c‬ﺗﺄﺧﺬ‬

‫ﻧﻔﱢﺬ‬ ‫اﻟﻘﻴﻤﺔ‪-‬اﻟﺜﺎﺑﺘﺔ‪1-‬‬
‫>ﻣﺠﻤﻮﻋﺔ ﺗﻌﻠﻴﻤﺎت ‪<1‬‬
‫اﻟﻘﻴﻤﺔ‪-‬اﻟﺜﺎﺑﺘﺔ‪،2-‬‬
‫=‬ ‫اﻟﻘﻴﻤﺔ‪-‬اﻟﺜﺎﺑﺘﺔ‪،3-‬‬
‫‪،.................‬‬
‫ﻧﻔﱢﺬ‬ ‫اﻟﻘﻴﻤﺔ‪-‬اﻟﺜﺎﺑﺘﺔ‪i-‬‬
‫>ﻣﺠﻤﻮﻋﺔ ﺗﻌﻠﻴﻤﺎت ‪<i‬‬
‫ﻧﻔﱢﺬ‬ ‫‪.....‬‬
‫‪.....‬‬
‫اﻟﻘﻴﻤﺔ‪-‬اﻟﺜﺎﺑﺘﺔ‪،k-‬‬
‫اﻟﻘﻴﻤﺔ‪-‬اﻟﺜﺎﺑﺘﺔ‪،..-‬‬
‫‪،.................‬‬
‫ﻧﻔﱢﺬ‬ ‫اﻟﻘﻴﻤﺔ‪-‬اﻟﺜﺎﺑﺘﺔ‪m-‬‬
‫>ﻣﺠﻤﻮﻋﺔ ﺗﻌﻠﻴﻤﺎت ‪<m‬‬

‫ﻧﻔﱢﺬ‬ ‫‪.....‬‬
‫‪.....‬‬
‫ﻧﻔﱢﺬ‬ ‫اﻟﻘﻴﻤﺔ‪-‬اﻟﺜﺎﺑﺘﺔ‪n-‬‬
‫>ﻣﺠﻤﻮﻋﺔ ﺗﻌﻠﻴﻤﺎت ‪< n‬‬
‫ﻗﻴﻢ أﺧﺮى‬
‫ﻧﻔﱢﺬ‬
‫>ﻣﺠﻤﻮﻋﺔ ﺗﻌﻠﻴﻤﺎت أﺧﺮى <‬

‫ﺇﻥ ﺼﻴﺎﻏﺔ ﺍﻟﺤل ﺒﺎﻟﺒﻨﻴﺔ ﺍﻟﺠﺩﻴﺩﺓ "ﺍﻟﺘﻌﻠﻴﻤﺔ ﻤﺘﻌﺩﺩ ﺍﻻﺨﺘﻴﺎﺭ" ‪ ،‬ﻤﻊ ﻜﻭﻨﻪ ﻤﻜﺎﻓﺌﹰﺎ ﻟﺘﺠﻤﻊ ﺘﻌﻠﻴﻤﺎﺕ‬
‫ﺒﺎﺴﺘﺨﺩﺍﻡ ﺇﺫﺍ ‪ ،‬ﺇﻻ ﺃﻨﻪ ﺃﻜﺜﺭ ﺍﻨﺘﻅﺎﻤﺎ ﻓﻲ ﺍﻟﺘﻌﺒﻴﺭ ﻋﻥ ﻤﺎﻫﻴﺔ ﻤﺎ ﻨﺭﻴﺩ ﻋﻤﻠﻪ‪ .‬ﺇﺫ ﺒﻬﺫﻩ ﺍﻟﺒﻨﻴﺔ )ﻓﻲ‬
‫ﺤﺎﻟﺔ ﻤﺘﺤﻭل ﻴﺄﺨﺫ ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ﻨﻔﱢﺫ ﻭﻓﻘﹰﺎ ﻟﻜل ﻗﻴﻤﺔ‪ (...‬ﻨﺤﺩﺩ ﺘﻤﺎﻤﺎ ﺃﻥ ﺘﻔﺭﻴﻌﺎﺕ ﺍﻟﻤﻌﺎﻟﺠﺔ ﻫﻨﺎ‬
‫ﺃﻱ ﻋﻠﻰ ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﻴﺄﺨﺫﻫﺎ ‪.c‬‬ ‫‪c‬‬ ‫ﻤﺘﻭﻗﻔﺔ ﻋﻠﻰ ﺤﺎﻟﺔ‬
‫ﺘﻭﺠﺩ ﻫﺫﻩ ﺍﻟﺒﻨﻴﺔ ﺍﻟﺸﺭﻁﻴﺔ ﻤﺘﻌﺩﺩﺓ ﺍﻻﺨﺘﻴﺎﺭ‪ ،‬ﺍﻟﺘﺤﻜﻡ ﻭﺍﺨﺘﻴﺎﺭ ﺍﻟﺘﻨﻔﻴﺫ ﺤﺴﺏ ﺤﺎﻟﺔ ﻤﺘﺤﻭل‪ ،‬ﻓﻲ‬
‫‪. (Visual Basic,‬‬ ‫)‪Ada, Pascal, C, Java‬‬ ‫ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‬
‫ﻭﻤﺘﺤﻭل ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺫﻱ ﻨﻔﺭّﻉ ﺍﻟﺘﻨﻔﻴﺫ ﺤﺴﺏ ﻗﻴﻤﺘﻪ‪/‬ﺤﺎﻟﺘﻪ ﻴﻤﻜﻥ ﺃﻥ ﻴﻜﻭﻥ ﻤـﻥ ﻨﻤـﻁ‬
‫ﻋﺩﺩ ﺼﺤﻴﺢ ﺃﻭ ﻨﻤﻁ ﻤﺤﺭﻓﻲ‪.‬‬
‫ﻓﻲ ‪:Pascal‬‬
‫‪Case c of‬‬
‫‪1,3,5,7,8,10,12‬‬ ‫;‪: mdays := 31‬‬
‫‪2‬‬ ‫;‪: mdays := 28‬‬
‫‪4, 6, 9, 11‬‬ ‫;‪: mdays := 30‬‬
‫;‪end‬‬

‫‪14‬‬
 ‫ﻓﻲ ‪:C, Java‬‬
‫ﻭ ‪ .case‬ﺘﻨﻔﱠﺫ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤـﺔ ﻜﺎﻟﺘـﺎﻟﻲ‪:‬‬ ‫‪switch‬‬ ‫ﺘﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﻤﻌﺭ‪‬ﻓﺔ ﺒﺎﻟﻜﻠﻤﺘﻴﻥ ﺍﻟﻤﻔﺘﺎﺤﻴﺘﻴﻥ‬
‫ﻋﻨﺩﻤﺎ ﻴﺄﺨﺫ ﻤﺘﺤﻭل ﺍﻟﺘﻌﻠﻴﻤﺔ ﻗﻴﻤﺔ ﺃﺤﺩ ﺍﻟﺜﻭﺍﺒﺕ‪ ،‬ﺘﻘﻭﻡ ﺒﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻭﺍﻓﻘﺔ ﻟـﻪ‪ ،‬ﻭ ﻟﻜﻨﻬـﺎ ‪،‬‬
‫ﺒﺨﻼﻑ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﻻ ﺘﻨﻬﻲ ﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺔ ﺍﻻﺨﺘﻴﺎﺭ ﺍﻟﻤﺘﻌﺩﺩ ﺁﻟﻴﹰﺎ ﺒﻌﺩ ﺫﻟﻙ‪ ،‬ﻟﺫﺍ ﻻ ﺒﺩ‬
‫ﺒﻌﺩ ﻜل ﺘﻔﺭﻴﻊ‪.‬‬ ‫‪break‬‬ ‫ﻤﻥ ﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺔ‬
‫ﺇﻟﻰ ﺍﻟﺨﺭﻭﺝ ﺇﻟﻰ ﻤﺎ ﺒﻌﺩ ﻨﻬﺎﻴﺔ ﻜﺘﻠﺔ ﺘﻌﻠﻴﻤﺎﺕ‪.‬‬ ‫‪break‬‬ ‫ﺘﺫﻜﱠﺭ‪ :‬ﺘﺅﺩﻱ ﺍﻟﺘﻌﻠﻴﻤﺔ‬

‫ﻤﺜﺎل‪ :‬ﻨﺭﻴﺩ ﻜﺘﺎﺒﺔ ﻋﺩﺩ ﺍﻷﻴﺎﻡ ﺍﻟﻤﻭﺍﻓﻕ ﻟﻜل ﺸﻬﺭ‪.‬‬

‫ﺍﻟﺨﺭﺝ‪ :‬ﻋﺩﺩ ﺍﻷﻴﺎﻡ‪.‬‬ ‫ﺍﻟﺩﺨل‪ :‬ﺭﻗﻡ ﺍﻟﺸﻬﺭ‬
‫ﻻ ﻴﻭﺠﺩ ﺃﻱ ﻋﻼﻗﺔ ﺤﺴﺎﺒﻴﺔ ﺒﻴﻥ ﺍﻟﺨﺭﺝ ﻭﺍﻟﺩﺨل‪ ،‬ﻭﻻ ﺒﺩ ﻤﻥ ﻭﻀﻊ ﺘﻌﺩﺍﺩ ﺍﻟﺤﺎﻻﺕ ﺍﻟﺘﻲ ﻴﻜﻭﻥ ﻓﻴﻬﺎ‬
‫ﻴﻭﻡ‪.‬‬ ‫‪28‬‬ ‫)ﺸﺒﺎﻁ(‬ ‫‪2‬‬ ‫ﻴﻭﻡ‪ ،‬ﻭﺤﺎﻟﺔ ﺍﻟﺸﻬﺭ‬ ‫‪30‬‬ ‫ﻴﻭﻡ‪ ،‬ﻭﺍﻟﺤﺎﻻﺕ‬ ‫‪31‬‬ ‫ﺍﻟﺸﻬﺭ ﻤﺴﺎﻭﻴﹰﺎ‬
‫ﻨﺹ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻜﺘﻭﺏ ﺒﻠﻐﺔ ‪:Java‬‬

‫‪15‬‬
‫ﻤﺜﺎل‪ :‬ﻨﺭﻴﺩ ﻜﺘﺎﺒﺔ ﺍﻻﺴﻡ ﺍﻟﻤﺨﺘﺼﺭ )ﺍﻟﺤﺭﻭﻑ ﺍﻟﺜﻼﺜﺔ ﺍﻷﻭﻟﻰ( ﻟﺸﻬﻭﺭ ﺍﻟﺴﻨﺔ ﺒﺎﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴـﺔ‪:‬‬
‫…‪.‬‬ ‫‪Jan‬‬ ‫ﺘﻜﺘﺏ‬ ‫‪January‬‬

‫ﺍﻟﺨﺭﺝ‪ :‬ﺍﺴﻡ ﺍﻟﺸﻬﺭ ﺍﻟﻤﺨﺘﺼﺭ‪.‬‬ ‫ﺍﻟﺩﺨل‪ :‬ﺭﻗﻡ ﺍﻟﺸﻬﺭ‬

‫ﻨﺹ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻜﺘﻭﺏ ﺒﻠﻐﺔ ‪:Java‬‬

‫ﻤﻼﺤﻅﺎﺕ ﻋﻠﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ‪:‬‬

‫ﻤﻊ ﺘﻤﻴﻴﺯ ﺍﻟﺤﺎﻻﺕ ﺍﻷﺨـﺭﻯ ﺒﺎﻟﻜﻠﻤـﺔ ﺍﻟﻤﻔﺘﺎﺤﻴـﺔ‬ ‫‪switch case‬‬ ‫ﻨﺴﺘﺨﺩﻡ ﻫﻨﺎ ﺘﻌﻠﻴﻤﺔ‬
‫‪.default‬‬
‫ﻻﺤﻅ ﺃﻥ ﻫﺫﺍ ﺍﻟﻌﻤل ﺍﻟﺒﺴﻴﻁ‪ ،‬ﺍﻟﺫﻱ ﻨﺭﻴﺩﻩ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ‪ ،‬ﻴﺴﺘﺩﻋﻲ ﻤﻨﺎ ﻜل ﻫﺫﻩ ﺍﻷﺴﻁﺭ‬
‫ﺍﻟﺒﺭﻤﺠﻴﺔ‪ .‬ﻭﻟﻜﻥ ﺒﻤﺎ ﻨﻌﺭﻓﻪ ﺤﺘﻰ ﺍﻵﻥ ﻤﻥ ﺒﻨﻰ ﻤﻌﻁﻴﺎﺕ ﻻ ﻴﻤﻜﻥ ﻟﻨﺎ ﺍﻟﻜﺘﺎﺒﺔ ﺒﺸﻜل‬
‫ﺃﻓﻀل‪ .‬ﺴﻨﺭﻯ ﻋﻨﺩ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ )ﺍﻟﺠﺩﺍﻭل( ﺃﻨﻪ ﻴﻤﻜﻨﻨﺎ ﺘﺤﻘﻴﻕ ﺫﻟﻙ‪ ،‬ﻋﻠﻰ ﻨﺤﻭ‬
‫ﻤﻭﺠﺯ ﻭﻭﺍﻀﺢ‪.‬‬

‫‪16‬‬
 ‫ﺘﻤﺎﺭﻴﻥ‬
‫‪1‬‬ ‫‪ -1‬ﺒﺎﺴﺘﺨﺩﻡ ﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻜﺭﺍﺭ ﺒﺨﻁﻭﺓ‪ ،‬ﺍﻜﺘﺏ ﺒﺭﻨﺎﻤﺠﹰﺎ ﻴﻘﻭﻡ ﺒﻜﺘﺎﺒﺔ ﺠﻤﻴﻊ ﺠﺩﺍﻭل ﺍﻟـﻀﺭﺏ ﻤـﻥ‬
‫ﺤﺘﻰ ‪.10‬‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻻ ﻴﺄﺨﺫ ﺃﻱ ﺩﺨل‪.‬‬
‫‪menu‬‬ ‫‪ -2‬ﺍﻜﺘﺏ ﺒﺭﻨﺎﻤﺠﹰﺎ ﻴﻘﻭﻡ ﺒﻘﺭﺍﺀﺓ ﻋﺩﺩﻴﻥ ﺼﺤﻴﺤﻴﻥ‪ ،‬ﺜﻡ ﻴﻜﺭﺭ ﺇﻅﻬـﺎﺭ ﻻﺌﺤـﺔ ﺨﻴـﺎﺭﺍﺕ‬
‫ﻹﺩﺨﺎل ﺤﺭﻑ ﻴﺩل ﻋﻠﻰ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﺤﺴﺎﺒﻴﺔ ﺍﻟﺘﻲ ﻴﺭﻴﺩ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺘﻨﻔﻴﺫﻫﺎ ﻋﻠـﻰ ﺍﻟﻌـﺩﺩﻴﻥ‪ .‬ﻴﻘـﻭﻡ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﻘﺭﺍﺀﺓ )ﺍﻟﺤﺭﻑ( ﺍﺨﺘﻴﺎﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﻴﻨﻔﺫ ﺍﻟﻌﻤﻠﻴﺔ ﺤﺴﺏ ﻗﻴﻤﺔ ﺍﻟﺤﺭﻑ ﺍﻟﻤﺩﺨل ﻭﻴﻅﻬﺭ‬
‫ﺍﻟﻨﺘﻴﺠﺔ‪ .‬ﻴﺘﻜﺭﺭ ﻨﻔﺱ ﺍﻟﻌﻤل ﺤﺘﻰ ﻴﻌﻁﻲ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﺨﺘﻴﺎﺭ ﺍﻟﺨﺭﻭﺝ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.q‬‬

‫‪17‬‬