‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.

com‬ﺻﻔﺤـﻪ ‪1‬‬

‫ﺑﺮﻧﺎﻣـﻪ ﻧﻮﯾﺴﯽ ﺑﻪ زﺑـﺎن‬

‫ﭘﺎﺳـﮑﺎل‬
‫ﻣﻬﻨـﺪس ﻣﻬﺪي ﻣﺤﻤ‪‬ـﺪي‬ ‫ﺗﺎﻟﯿـﻒ ‪:‬‬

‫ﻪ آزﻣﺎ ﯽ‬
‫داد ﻣﺎه ‪۱۳۸۸‬‬
‫ار ﺒﺎط ﺑﺎ ﻣﺎ ‪:‬‬
‫‪WWW.PASCAL4U.BLOGFA.COM‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪2‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﻭ ﻓﻠﻮﭼﺎﺭﺕ‪:‬‬
‫ﺑﺮﺍﻱ ﺍﺭﺍﺋﺔ ﻳﻚ ﺭﺍﻩ ﺣﻞ ﺑﺮﺍﻱ ﻳﻚ ﻣﺴﺎﻟﻪ ﺳﻪ ﻋﺎﻣﻞ ﻣﻬﻢ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪:‬‬
‫‪ -١‬ﺷﻨﺎﺧﺖ ﺩﻗﻴﻖ ﻣﺴﺎﻟﻪ‬
‫• ﺩﺍﺩﻩ ﻫﺎ‬
‫• ﻣﺠﻬﻮﻻﺕ‬
‫• ﺍﺭﺗﺒﺎﻁ ﺑﻴﻦ ﺩﺍﺩﻩ ﻫﺎ ﻭ ﻣﺠﻬﻮﻻﺕ‬
‫ﻣﺜﺎﻝ( ﻣﻴﺎﻧﮕﻴﻦ ‪ ٥‬ﻋﺪﺩ ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻛﻨﻴﺪ؟ ﺩﺍﺩﻩ ﻫﺎ ‪ ٥‬ﻋﺪﺩ ﻭﺭﻭﺩﻱ ﺍﺳﺖ ﻭ ﻣﺠﻬﻮﻝ ﻣﻴﺎﻧﮕﻴﻦ ﺍﻋﺪﺍﺩ ﺍﺳﺖ ﻭ ﺭﺍﺑﻄﺔ ﺁﻥ ﺣﺎﺻﻞ ﺟﻤـﻊ ‪ ٥‬ﻋـﺪﺩ ﺭﺍ‬
‫ﺗﻘﺴﻴﻢ ﺑﺮ ‪ ٥‬ﻣﻲ ﻛﻨﻴﻢ ﺗﺎ ﻣﺠﻬﻮﻝ ﺑﺪﺳﺖ ﺁﻳﺪ‪.‬‬
‫ﻣﻌﻤﻮﻻ ﺑﺪﺳﺖ ﺁﻭﺭﺩﻥ ﺭﺍﺑﻄﺔ ﺑﻴﻦ ﻣﺠﻬﻮﻝ ﻭﺩﺍﺩﻩ ﻫﺎ ﺑﻪ ﺍﻳﻦ ﺁﺳﺎﻧﻲ ﻧﻴﺴﺖ ﺑﺎﻳﺪ ﺩﺭ ﻣﻮﺭﺩ ﺁﻥ ﻓﻜﺮ ﻭ ﺗﺎﻣﻞ ﻛﺮﺩ!‬
‫‪ -٢‬ﻃﺮﺡ ﻧﻘﺸﻪ ﺣﻞ ﻣﺴﺎﻟﻪ) ﺍﺭﺍﺋﻪ ﺭﺍﻩ ﺣﻞ(‪ :‬ﺑﻌﺪ ﺍﺯﺍﻳﻦ ﻛﻪ ﻣﺴﺎﻟﻪ ﺭﺍ ﺑﻪ ﺩﻗﺖ ﺷﻨﺎﺧﺘﻴﻢ ﺑﺎﻳﺪ ﺑﺮﺍﻱ ﺁﻥ ﺭﺍﻩ ﺣﻞ ﺍﺭﺍﺋﻪ ﻛﻨﻴﻢ‪.‬‬
‫ﺭﺍﻩ ﺣﻞ ﻫﺎﻳﻲ ﻛﻪ ﺑﺮﺍﻱ ﻳﻚ ﻣﺴﺎﻟﻪ ﺍﺭﺍﺋﻪ ﻣﻲ ﺷﻮﺩ ﺑﻪ ﺩﻭ ﺩﺳﺘﻪ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ‪ -١ :‬ﺭﺍﻩ ﺣﻞ ﻏﻴﺮ ﻣﻨﻄﻘﻲ ‪ -٢‬ﺭﺍﻩ ﺣﻞ ﻣﻨﻄﻘـﻲ‪).‬ﺍﻟﮕـﻮﺭﻳﺘﻤﻲ ﻭ‬
‫ﻏﻴﺮ ﺍﻟﮕﻮﺭﻳﺘﻤﻲ(‬
‫ﺭﺍﻩ ﺣﻠﻬﺎﻱ ﻏﻴﺮﻣﻨﻄﻘﻲ ﺭﺍ ﻧﻤﻲ ﺗﻮﺍﻥ ﻓﺮﻣﻮﻟﻪ ﻛﺮﺩ ﻭ ﻫﻴﭻ ﻣﻨﻄﻘﻲ ﻧﺪﺍﺭﻧﺪ‪ .‬ﺍﻧﺴﺎﻧﻬﺎ ﺑﺮﺍﻱ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻫﻮﺵ ﻭ ﺣﻮﺍﺱ ﺧﻮﺩ ﺍﺯ ﺍﻳـﻦ ﺭﺍﻩ ﺣﻠﻬـﺎ ﺑـﺮﺍﻱ‬
‫ﺣﻞ ﻣﺴﺎﻟﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻨﺪ ﺍﻣﺎ ﻳﻚ ﺭﺍﻳﺎﻧﻪ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺑﻪ ﺍﻳﻦ ﺻﻮﺭﺕ ﻣﺴﺎﻟﻪ ﺭﺍ ﺣﻞ ﻛﻨﺪ‪ .‬ﻣﺜﻼ ﻋﺪﺩ ‪ ٤٥٢٩‬ﭼﻨﺪ ﺭﻗﻤﻲ ﺍﺳﺖ؟ ﺍﻧﺴﺎﻥ ﺑـﺎ ﻳـﻚ‬
‫ﻧﮕﺎﻩ ﺑﻪ ﺁﻥ ﻣﺘﻮﺟﻪ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﭼﻬﺎﺭ ﺭﻗﻤﻲ ﺍﺳﺖ ﺍﻣﺎ ﺭﺍﻳﺎﻧﻪ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺍﺭﻗﺎﻡ ﺭﺍ ﺑﺒﻴﻨﺪ! ﻳﺎ ﺍﻳﻨﻜﻪ ﻋﺪﺩ ‪ ٢٤٦‬ﺯﻭﺝ ﺍﺳﺖ ﻳﺎ ﻓﺮﺩ؟‬
‫ﺭﺍﻩ ﺣﻞ ﻫﺎﻱ ﻣﻨﻄﻘﻲ ﺭﺍﻩ ﺣﻠﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﻣﺴﺎﻟﻪ ﮔﺎﻡ ﺑﻪ ﮔﺎﻡ ﺣﻞ ﻣﻲ ﺷﻮﺩ ﻭ ﺭﺍﺑﻄﻪ ﺍﻳﻲ ﺑـﻴﻦ ﺩﺍﺩﻩ ﻫـﺎ ﻭ ﻣﺠﻬـﻮﻻﺕ ﻭﺟـﻮﺩ ﺩﺍﺭﺩ؟ ﻣـﺜﻼ ﺍﮔـﺮ‬
‫ﻋﺪﺩﻱ ﺭﺍ ﺗﻘﺴﻴﻢ ﺑﺮ ﺩﻭ ﻛﻨﻴﻢ ﻭ ﺑﺎﻗﻴﻤﺎﻧﺪﻩ ﺻﻔﺮ ﺷﻮﺩ ﭘﺲ ﺯﻭﺝ ﺍﺳﺖ‪ .‬ﺑﺮﺍﻱ ﺗﺸﺨﻴﺺ ﺗﻌﺪﺍﺩ ﺍﺭﻗﺎﻡ ﻳﻚ ﻋـﺪﺩ ﭼـﻪ ﺭﺍﻩ ﺣـﻞ ﻣﻨﻄﻘـﻲ ﺍﺭﺍﺋـﻪ ﻣـﻲ‬
‫ﻛﻨﻴﺪ؟‬
‫ﺑﻨﺎﺑﺮﺍﻳﻦ ﺑﺮﺍﻱ ﻃﺮﺡ ﻳﻚ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻳﺪ ﺭﺍﻩ ﺣﻞ ﻣﻨﻄﻘﻲ ﻣﺴﺎﻟﻪ ﺭﺍ ﺑﺪﺳﺖ ﺁﻭﺭﻳﺪ‪.‬‬
‫‪ -٣‬ﺗﺤﻠﻴﻞ ﺭﺍ ﺣﻞ ﻣﺴﺎﻟﻪ‪ :‬ﺑﻌﺪ ﺍﺯﺍﻳﻨﻜﻪ ﺑﺮﺍﻱ ﻣﺴﺎﻟﻪ ﺭﺍﻩ ﺣﻞ ﻣﻨﻄﻘﻲ ﻳﺎﻓﺘﻴﻢ ﺑﺎﻳﺪ ﺁﻥ ﺭﺍ ﺗﺠﺰﻳﻪ ﻭ ﺗﺤﻠﻴﻞ ﻛﻨﻴﻢ ﻛﻪ ﺁﻳﺎ ﺟﻮﺍﺏ ﻣﻲ ﺩﻫﺪ ﻳﺎ ﻧـﻪ؟ ﻳـﺎ‬
‫ﺍﻳﻨﻜﻪ ﺁﻧﺮﺍ ﺗﻌﻤﻴﻢ ﺩﻫﻴﻢ ﺗﺎ ﻣﺴﺎﺋﻞ ﺑﺰﺭﮔﺘﺮﻱ ﺣﻞ ﺷﻮﻧﺪ‪ .‬ﻳﺎ ﺍﻳﻨﻜﻪ ﻣﺴﺎﻟﻪ ﺭﺍ ﺑﻪ ﻣﺴﺎﺋﻞ ﻛﻮﭼﻜﺘﺮﻱ ﺗﻘﺴﻴﻢ ﻛﻨﻴﻢ‪.‬‬
‫ﺍﻟﮕﻮﺭﻳﻨﻢ‪ :‬ﻛﻠﻤﺔ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺍﺯ ﻧﺎﻡ ﺭﻳﺎﺿﻲ ﺩﺍﻥ ﺑﺰﺭﮒ ﺍﻳﺮﺍﻧﻲ ﻣﺤﻤﺪ ﺑﻦ ﻣﻮﺳﻲ ﺍﻟﺨﻮﺍﺭﺯﻣﻲ ﮔﺮﻓﺘﻪ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬
‫ﺑﻪ ﻣﺠﻤﻮﻋﻪ ﺩﺳﺘﻮﺭﺍﻟﻌﻤﻠﻬﺎ ﻛﻪ ﻣﺮﺍﺣﻞ ﻣﺨﺘﻠﻒ ﺍﻧﺠﺎﻡ ﻛﺎﺭﻱ)ﺣﻞ ﻳﻚ ﻣﺴﺎﻟﻪ( ﺭﺍ ﺑﻪ ﺯﺑﺎﻥ ﺩﻗﻴﻖ ﻭﺑﺎ ﺟﺰﻳﻴﺎﺕ ﻛﺎﻓﻲ ﺑﻴﺎﻥ ﻛﺮﺩﻩ ﻭ ﺩﺭ ﺁﻥ ﺗﺮﺗﻴﺐ‬
‫ﻣﺮﺍﺣﻞ ﻭ ﺷﺮﻭﻉ ﻭ ﺧﺎﺗﻤﻪ ﭘﺬﻳﺮ ﺑﻮﺩﻥ ﻋﻤﻠﻴﺎﺕ ﻣﺸﺨﺺ ﺑﺎﺷﺪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﻲ ﮔﻮﻳﻨﺪ‪.‬‬
‫ﺧﺼﻮﺻﻴﺎﺕ ﻳﻚ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﺩﺭ ﺗﻌﺮﻳﻒ ﺁﻥ ﻣﺸﺎﻫﺪﻩ ﻣﻲ ﻛﻨﻴﺪ‪ .‬ﻣﻨﻈﻮﺭ ﺍﺯ ﺯﺑﺎﻥ ﺩﻗﻴﻖ ﻭ ﺟﺰﻳﻴﺎﺕ ﻛﺎﻓﻲ ﭼﻴﺴﺖ؟‬
‫ﻣﻨﻈﻮﺭ ﺍﺯ ﺍﺟﺮﺍﻱ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﻧﺒﺎﻝ ﻛﺮﺩﻥ ﻣﺮﺍﺣﻞ ﻣﺨﺘﻠﻒ ﺁﻥ ﺍﺳﺖ‪ .‬ﺷﺨﺼﻲ ﻳﺎ ﻣﺎﺷﻴﻨﻲ ﻛﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﺍﺟﺮﺍ ﻣﻲ ﻛﻨﺪ ﻣﺠﺮﻱ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﻧﺎﻣﻴـﺪﻩ‬
‫ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻳﻚ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻓﻘﻂ ﻭ ﻓﻘﻂ ﻳﻚ ﻧﻘﻄﺔ ﺷﺮﻭﻉ ﺑﺎﻳﺪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﺍﻣﺎ ﻣﻲ ﺗﻮﺍﻧﺪ ﭼﻨﺪﻳﻦ ﻧﻘﻄﺔ ﭘﺎﻳﺎﻥ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ ).‬ﺣﺪﺍﻗﻞ ﻳـﻚ ﻧﻘﻄـﻪ ﭘﺎﻳـﺎﻥ ﺑﺎﻳـﺪ‬
‫ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ(‪.‬‬
‫ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﻱ ﺫﻛﺮ ﺷﺪﻩ ﺩﺭ ﺑﻌﻀﻲ ﺍﺯ ﻛﺘﺎﺑﻬﺎ ﻋﺒﺎﺭﺕ ‪ R= N-[N \ M] * M‬ﺭﺍ ﺩﺭ ﻣﺸﺎﻫﺪﻩ ﻣﻲ ﻛﻨﻴﺪ ﻛﻪ ﻣﻨﻈﻮﺭ ﺍﺯ ﺁﻥ‬
‫‪ R= N Mod M‬ﺍﺳﺖ‪ .‬ﻣﻨﻈﻮﺭ ﺍﺯ ﻋﻼﻣﺖ \ ﺗﻘﺴﻴﻢ ﺻﺤﻴﺢ ﺍﺳـﺖ ﻭ ﻣﻨﻈـﻮﺭ ﺍﺯ ] [ ﺟﺰﺻـﺤﻴﺢ ﻳـﻚ ﻋـﺪﺩ ﺍﺳـﺖ‪ Mod ).‬ﻭ ‪ DIV‬ﺑـﻪ‬
‫ﺗﺮﺗﻴﺐ ﺑﺎﻗﻴﻤﺎﻧﺪﺓ ﻳﻚ ﺗﻘﺴﻴﻢ ﻭ ﺧﺎﺭﺝ ﻗﺴﻤﺖ ﺻﺤﻴﺢ ﻳﻚ ﺗﻘﺴﻴﻢ ﺭﺍ ﻧﻤﺎﻳﺶ ﻣﻲ ﺩﻫﻨﺪ‪(.‬‬

‫ﺑﺮﺍﻱ ﻳﺎﺩ ﮔﺮﻓﺘﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻫﺎ ﻓﻘﻂ ﺗﻤﺮﻳﻦ ﻭ ﺗﻼﺵ ﺑﻪ ﺷﻤﺎ ﻛﻤﻚ ﻣﻲ ﻛﻨﺪ‪ .‬ﺩﺭ ﺍﺩﺍﻣﻪ ﭼﻨﺪ ﻣﺜﺎﻝ ﺑﺮﺍﻱ ﺗﻌﺪﺍﺩﻱ ﻣﺴﺎﻟﻪ ﺑﻴﺎﻥ ﻣﻲ ﺷﻮﺩ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪3‬‬
‫‪ -١‬ﺧﺮﻭﺟﻲ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺯﻳﺮ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫‪R=N – [ N \ M ] * M -٣‬‬ ‫‪M=2 -٢‬‬ ‫‪ -١‬ﻋﺪﺩ ‪ N‬ﺭﺍ ﺑﮕﻴﺮ‬ ‫‪ -٠‬ﺷﺮﻭﻉ‬
‫‪ -٦‬ﺍﮔﺮ ‪ M<N‬ﺑﺮﻭ ﻣﺮﺣﻠﻪ ‪٣‬‬ ‫‪M= M+1 -٥‬‬ ‫‪ -٤‬ﺍﮔﺮ ‪ R=0‬ﺁﻧﮕﺎﻩ ﺑﺮﻭ ﺑﻪ ﻣﺮﺣﻠﺔ ‪٨‬‬
‫‪ -٨‬ﭘﺎﻳﺎﻥ‬ ‫‪ N -٧‬ﺭﺍ ﭼﺎﭖ ﻛﻦ‬

‫ﺏ( ﻣﻘﺴﻮﻡ ﻋﻠﻴﻪ ﻫﺎﻱ ﻋﺪﺩ ‪ N‬ﺭﺍ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‬ ‫ﺍﻟﻒ( ﺩﺭﺻﻮﺭﺗﻴﻜﻪ ‪ N‬ﻓﺮﺩ ﺑﺎﺷﺪ ﺁﻥ ﺭﺍ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‬
‫ﺩ( ﺩﺭ ﺻﻮﺭﺗﻴﻜﻪ ‪ N‬ﺩﺍﺭﺍﻱ ﺑﻴﺶ ﺍﺯ ﺩﻭ ﻣﻘﺴﻮﻡ ﻋﻠﻴﻪ ﺑﺎﺷﺪ ﺁﻧﺮﺍ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‪.‬‬ ‫ﺝ( ﺩﺭ ﺻﻮﺭﺗﻴﻜﻪ ‪ N‬ﻋﺪﺩ ﺍﻭﻝ ﺑﺎﺷﺪ ﺁﻥ ﺭﺍ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫‪ -٢‬ﺧﺮﻭﺟﻲ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺯﻳﺮ ﻛﺪﺍﻣﺴﺖ؟‬

‫‪ -٤‬ﺍﮔﺮ ‪ A<=0‬ﺑﺮﻭﻱ ﺑﻪ ﻣﺮﺣﻠﻪ ‪١٠‬‬ ‫‪ C=0 -٣‬ﻭ ‪B=0‬‬ ‫‪ A -٢‬ﺭﺍ ﺑﮕﻴﺮ‬ ‫‪ -١‬ﺷﺮﻭﻉ‬
‫‪A=A \ 10 -٨‬‬ ‫‪B=B+1 -٧‬‬ ‫‪C= C+D*10^B -٦‬‬ ‫‪D= A Mod 10 -٥‬‬
‫‪ -١١‬ﭘﺎﻳﺎﻥ‬ ‫‪ - ١٠‬ﭼﺎﭖ ‪C‬‬ ‫‪ -٩‬ﺑﺮﻭ ﺑﻪ ﻣﺮﺣﻠﻪ ‪٤‬‬

‫ﺩ( ﻋﺪﺩ ﻭﺭﻭﺩﻱ‬ ‫ﺝ( ﺣﺎﺻﻞ ﺟﻤﻊ ﺍﺭﻗﺎﻡ ﻳﻚ ﻋﺪﺩ‬ ‫ﺏ( ﺣﺎﺻﻠﻀﺮﺏ ﺍﺭﻗﺎﻡ ﻳﻚ ﻋﺪﺩ‬ ‫ﺍﻟﻒ( ﻣﻌﻜﻮﺱ ﻳﻚ ﻋﺪﺩ‬

‫‪ -٣‬ﺣﺎﺻﻞ ﺍﺟﺮﺍﻱ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺯﻳﺮ ﭼﻴﺴﺖ؟‬

‫‪b=y+4*3 \ a -٤‬‬ ‫‪a=(x+12) mod 5‬‬ ‫‪-٣‬‬ ‫‪ x=6 -٢‬ﻭ ‪y=2‬‬ ‫ﺍ‪ -‬ﺷﺮﻭﻉ‬
‫‪ -٧‬ﭘﺎﻳﺎﻥ‬ ‫‪ b-٦‬ﺭﺍ ﭼﺎﭖ ﻛﻦ‪.‬‬ ‫‪ -٥‬ﺍﮔﺮ ‪ a>b‬ﺁﻧﮕﺎﻩ ‪ a‬ﺭﺍ ﭼﺎﭖ ﻛﻦ ﻭ ﺑﻪ ﻣﺮﺣﻠﻪ ‪ ٧‬ﺑﺮﻭ‬

‫ﺩ( ‪١‬‬ ‫ﺝ(‪٤‬‬ ‫ﺏ(‪٦‬‬ ‫ﺍﻟﻒ( ‪٣‬‬

‫‪ -٤‬ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﻭﺑﺮﻭ‪ ،‬ﻣﺮﺣﻠﻪ ‪ ٥‬ﭼﻨﺪ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ؟ )‪( X=5‬‬
‫‪ Y -٥‬ﺭﺍ ﺑﻨﻮﻳﺲ‬ ‫‪Y=C+X-٤‬‬ ‫‪ -٣‬ﻋﺪﺩ‪ X‬ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﻛﻦ‬ ‫‪C=1 -٢‬‬ ‫‪ -١‬ﺷﺮﻭﻉ‬
‫‪ – ٨‬ﭘﺎﻳﺎﻥ‬ ‫‪ -٧‬ﺍﮔﺮ ‪ C<50‬ﺑﺮﻭ ﺑﻪ ﻣﺮﺣﻠﻪ ‪٤‬‬ ‫‪C=3*C -٦‬‬

‫ﺩ(‪18‬‬ ‫ﺝ(‪17‬‬ ‫ﺏ(‪4‬‬ ‫ﺍﻟﻒ( ‪3‬‬

‫‪ -٥‬ﺟﺎﻱ ﺧﺎﻟﻲ ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﻃﻮﺭﻱ ﺗﻜﻤﻴﻞ ﻛﻨﻴﺪ ﺗﺎ ﺣﺎﺻﻞ ﭼﺎﭖ ﺍﻋﺪﺍﺩ ﻣﻀﺮﺏ ‪ ٣‬ﺩﻭﺭﻗﻤﻲ ﺑﺎﺷﺪ؟‬
‫ﺍﻟﻒ( ﺑﻪ ﻣﺮﺣﻠﻪ ‪ ٢‬ﺑﺮﻭ‬
‫ﺷﺮﻭﻉ‬ ‫‪(٠‬‬
‫‪K=12‬‬ ‫‪(١‬‬ ‫ﺏ( ﺑﻪ ﻣﺮﺣﻠﻪ ‪ ٣‬ﺑﺮﻭ‬
‫‪ K‬ﺭﺍ ﭼﺎﭖ ﻛﻦ‬ ‫‪(٢‬‬ ‫ﺝ( ﺑﻪ ﻣﺮﺣﻠﻪ ‪ ٦‬ﺑﺮﻭ‬
‫‪K=K+3‬‬ ‫‪(٣‬‬ ‫ﺩ( ‪ K‬ﺭﺍ ﭼﺎﭖ ﻛﻦ ﻭ ﻣﺮﺣﻠﻪ ‪ ٦‬ﺑﺮﻭ‬
‫ﺍﮔﺮ ‪ K>99‬ﺁﻧﮕﺎﻩ …………‬ ‫‪(٤‬‬
‫ﺑﻪ ﻣﺮﺣﻠﻪ ‪ ٢‬ﺑﺮﻭ‬ ‫‪(٥‬‬
‫ﭘﺎﻳﺎﻥ‬ ‫‪(٦‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪4‬‬
‫‪ -٦‬ﻛﺎﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬
‫‪ -٥‬ﺍﮔﺮ ‪ X>A‬ﺁﻧﮕﺎﻩ ‪X=A‬‬ ‫‪ A -٤‬ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﻛﻦ‬ ‫‪X=A -٣‬‬ ‫‪K=2‬‬ ‫‪-٢‬‬ ‫‪ A -١‬ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﻛﻦ‬
‫‪ X -٨‬ﺭﺍ ﺍﻋﻼﻡ ﻛﻦ ‪ -٩‬ﭘﺎﻳﺎﻥ‬ ‫‪ K=K+1 -٧‬ﻭ ﺑﺮﻭ ﺑﻪ ﻣﺮﺣﻠﻪ ‪٤‬‬ ‫‪ -٦‬ﺍﮔﺮ‪ K=10‬ﺑﺮﻭ ﺑﻪ ﻣﺮﺣﻠﻪ ‪٨‬‬

‫ﺏ(ﻳﺎﻓﺘﻦ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﺪﺩ ﺑﻴﻦ ‪ ١٠‬ﻋﺪﺩ ﺩﺭﻳﺎﻓﺘﻲ‬ ‫ﺍﻟﻒ( ﭼﺎﭖ ﺟﻤﻊ ﺍﻋﺪﺍﺩ ﻛﻮﭼﻜﺘﺮ ﺍﺯ ‪10‬‬
‫ﺩ( ﻳﺎﻓﺘﻦ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﺪﺩ ﺑﻴﻦ ‪ ٩‬ﻋﺪﺩ ﺩﺭﻳﺎﻓﺘﻲ‬ ‫ﺝ( ﻳﺎﻓﺘﻦ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﺪﺩ ﺑﻴﻦ ﺩﻭﻋﺪﺩ ﺩﺭﻳﺎﻓﺘﻲ ﺑﺎ ﺗﻜﺮﺍﺭ ‪ ١٠‬ﺑﺎﺭ‬

‫ﻧﻤﻮﺩﺍﺭ ﮔﺮﺩﺷﻲ ) ‪:( flowchart‬‬

‫ﺩﻧﺒﺎﻝ ﻛﺮﺩﻥ ﺟﻤﻼﺕ ﻳﻚ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺰﺭﮒ ﻛﺎﺭ ﻣﺸﻜﻠﻲ ﺍﺳﺖ ﻭ ﺟﻤﻼﺕ ﺑﻪ ﺯﺑﺎﻧﻬﺎﻱ ﻣﺨﺘﻠﻔﻲ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺑـﺮﺍﻱ ﻫﻤـﻪ ﺍﻓـﺮﺍﺩ ﻗﺎﺑـﻞ‬
‫ﺍﺳﺘﻔﺎﺩﻩ ﻧﻴﺴﺖ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺑﺮﺍﻱ ﺑﻴﺎﻥ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺍﺯ ﻧﻤﺎﺩﻫﺎﻱ ﺧﺎﺻﻲ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻨﺪ ﻛﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﺑـﻪ ﺻـﻮﺭﺕ ﺗـﺼﻮﻳﺮﻱ ﻧﻤـﺎﻳﺶ‬
‫ﻣﻲ ﺩﻫﺪ‪ .‬ﺑﻪ ﻣﺠﻤﻮﻋﻪ ﺍﻱ ﺍﺯ ﻋﻼﻳﻢ ﺳﺎﺩﻩ ﻛﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﻧﻤﺎﺩ )ﺗﺼﻮﻳﺮ( ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﻨﺪ ﻧﻤﻮﺩﺍﺭ ﮔﺮﺩﺷﻲ ﮔﻔﺘﻪ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻤﻮﺩﺍﺭ ﮔﺮﺩﺷﻲ ﺑﻪ ﺯﺑﺎﻥ ﺧﺎﺻﻲ ﺑﺴﺘﮕﻲ ﻧﺪﺍﺭﺩ‪ .‬ﻭﺟﻮﺩ ﻧﻤﻮﺩﺍﺭ ﮔﺮﺩﺷﻲ ﺍﻣﻜﺎﻥ ﺍﺻﻼﺡ ﻭ ﺗﻐﻴﻴﺮ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﺳﺎﺩﻩ ﺗﺮ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫ﻋﻼﺋﻢ ﻧﻤﻮﺩﺍﺭ ﮔﺮﺩﺷﻲ‪ :‬ﺩﺭ ﺍﺩﺍﻣﻪ ﻋﻼﻣﺘﻬﺎﻱ ﺍﺳﺘﺎﻧﺪﺍﺭﺩﻱ ﻛﻪ ﺩﺭ ﺭﺳﻢ ﻓﻠﻮﭼﺎﺭﺕ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ ﺭﺍ ﺑﻴﺎﻥ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﺧﻂ ﺟﺮﻳﺎﻥ‪ :‬ﺧﻄﻮﻃﻲ ﻛﻪ ﺑﻪ ﺻﻮﺭﺕ ﭘﻠﻴﻜﺎﻥ ﻣﺸﺨﺺ ﻣﻲ ﺷﻮﻧﺪ ﻭ ﻣﺴﻴﺮ ﻋﻤﻠﻴﺎﺗﻲ ﻛﻪ ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﺑﻪ ﺗﺮﺗﻴﺐ ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ‪è .‬‬
‫ﻋﻼﻣﺖ ﺷﺮﻭﻉ ﻭ ﭘﺎﻳﺎﻥ‪ :‬ﺑﺼﻮﺭﺕ ﺑﻴﻀﻲ ﻣﺸﺨﺺ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﻫﺮ ﻓﻠﻮﭼﺎﺭﺕ ﺣﺪﺍﻛﺜﺮ ﻳﻚ ﺷﺮﻭﻉ ﻭ ﺣﺪﺍﻗﻞ ﻳﻚ ﭘﺎﻳـﺎﻥ ﺩﺍﺭﺩ‪).‬ﺷـﺮﻭﻉ ﻫـﺮ ﻧﻤـﻮﺩﺍﺭ‬
‫ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮﺩ ﺍﺳﺖ(‬
‫‪STOP‬‬ ‫‪Start‬‬ ‫ﺩﺭ ﻣﻮﺭﺩ ﺑﻴﻀﻲ ﺷﺮﻭﻉ)‪ (Start‬ﺧﻂ ﺟﺮﻳﺎﻥ ﺑﻪ ﺁﻥ ﻭﺍﺭﺩ ﻧﻤﻲ ﺷﻮﺩ ﻭ ﺩﺭ ﻣﻮﺭﺩ ﺑﻴﻀﻲ ﭘﺎﻳﺎﻥ‬
‫ﺍﺯ ﺁﻥ ﺧﻂ ﺟﺮﻳﺎﻥ ﺧﺎﺭﺝ ﻧﻤﻲ ﺷﻮﺩ‪ .‬ﺍﻣﺎ ﺑﻪ ﺑﻴﻀﻲ ﭘﺎﻳﺎﻥ ﻣﻲ ﺗﻮﺍﻧﺪ ﭼﻨﺪﻳﻦ ﺧﻂ ﺟﺮﻳﺎﻥ ﻭﺍﺭﺩ ﺷﻮﺩ‪.‬‬
‫ﻋﻼﻣﺖ ﭘﺮﺩﺍﺯﺵ‪ :‬ﺍﺯ ﺷﻜﻞ ﻣﺴﺘﻄﻴﻞ ﺑﺮﺍﻱ ﺍﻧﺠﺎﻡ ﻭ ﻣﺤﺎﺳﺒﺎﺕ ﻭ ﺍﻧﺘﺴﺎﺏ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﺩﺭﻭﻥ ﻣﺴﺘﻄﻴﻞ ﻣﻲ ﺗﻮﺍﻥ ﻳﻚ ﻳﺎ ﻋﻤﻞ ﻣﺤﺎﺳﺒﺎﺗﻲ‬
‫ﻳﺎ ﺍﻧﺘﺴﺎﺏ ﻧﻮﺷﺖ ) ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﺗﺮﺗﻴﺐ ﺍﺟﺮﺍ ﺍﺯ ﺑﺎﻻ ﺑﻪ ﭘﺎﻳﻴﻦ ﺍﺳﺖ(‪ .‬ﺍﺯ ﻣﺴﺘﻄﻴﻞ ﻓﻘﻂ ﻳﻚ ﭘﻠﻴﻜﺎﻥ ﺧﺎﺭﺝ ﻣﻲ ﺷﻮﺩ ﻭﻟﻲ ﻣﻲ ﺗﻮﺍﻧـﺪ ﭼﻨـﺪﻳﻦ‬
‫ﺍﻧﺘﺴﺎﺏ ﻳﺎ ﻣﺤﺎﺳﺒﻪ‬ ‫ﭘﻠﻴﻜﺎﻥ ﺑﻪ ﺁﻥ ﻭﺍﺭﺩ ﺷﻮﺩ‪.‬‬

‫ﻋﻼﻣﺖ ﺗﺼﻤﻴﻢ ﮔﻴﺮﻱ‪ :‬ﺍﺯ ﺷﻜﻞ ﻫﻨﺪﺳﻲ ﻟﻮﺯﻱ ﺑﺮﺍﻱ ﺗﺼﻤﻴﻢ ﮔﻴﺮﻱ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﺩﺭ ﺩﺍﺧﻞ ﻟﻮﺯﻱ ﻳﻚ ﺷﺮﻁ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺟﻮﺍﺏ‬
‫ﺁﻥ ﻳﺎ ﺩﺭﺳﺖ)‪(TRUE‬ﻳﺎ ﻧﺎﺩﺭﺳﺖ)‪ (FALSE‬ﺍﺳﺖ‪ .‬ﺍﺯ ﻟﻮﺯﻱ ﺣﺘﻤﺎ ﻓﻘﻂ ﺩﻭ ﭘﻠﻴﻜـﺎﻥ ) ‪ (YES , NO‬ﺧـﺎﺭﺝ ﻣـﻲ ﺷـﻮﺩ ﻭﻟـﻲ ﻣـﻲ ﺗﻮﺍﻧـﺪ‬
‫ﭼﻨﺪﻳﻦ ﭘﻠﻴﻜﺎﻥ ﺑﻪ ﺁﻥ ﻭﺍﺭﺩ ﺷﻮﺩ‪.‬‬
‫ﻋﻼﻣﺖ ﻭﺭﻭﺩﻱ ﻭ ﺧﺮﻭﺟﻲ‪:‬‬
‫ﺷﺮﻁ‬ ‫ﺍﺯ ﻋﻼﻣﺖ ﻣﺘﻮﺍﺯﻱ ﺍﻻﺿﻼﻉ ﺑﺮﺍﻱ ﻭﺭﻭﺩﻱ ﻭ ﻫﻢ ﺧﺮﻭﺟﻲ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﺍﮔﺮ ﺑﻪ ﻋﻨﻮﺍﻥ ﻭﺭﻭﺩﻱ‬
‫ﻣﻮﺭﺩ ﻧﻈﺮﺑﺎﺷﺪ ﻋﺒﺎﺭﺕ ﻭﺭﻭﺩﻱ ﻳﺎ ‪ Input‬ﺩﺭ ﺁﻥ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﺩ ﻭ ﺍﮔﺮ ﺑﻪ ﻣﻨﻈﻮﺭ ﺧﺮﻭﺟﻲ ﺍﺳﺘﻔﺎﺩﻩ‬
‫ﺷﻮﺩ ﻋﺒﺎﺭﺕ ﺧﺮﻭﺟﻲ ﻳﺎ ‪ OutPut‬ﺩﺭ ﺁﻥ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﺩ‪.‬‬

‫ﻭﺭﻭﺩﻱ ‪A,B‬‬ ‫ﺧﺮﻭﺟﻲ ‪F‬‬

‫ﺩﺭ ﻣﺘﻮﺍﺯﻱ ﺍﻻﺿﻼﻉ ﻭﺭﻭﺩﻱ)‪ ( Input‬ﻧﻤﻲ ﺗﻮﺍﻥ ﺛﺎﺑﺖ ﻳﺎ ﻋﺒﺎﺭﺕ ﻧﻮﺷﺖ ﻓﻘﻂ ﺑﺎﻳﺪ ﻣﺘﻐﻴﺮ ﻧﻮﺷﺖ‪.‬‬
‫‪R,K‬‬ ‫ﺑﻪ ﻣﺘﻮﺍﺭﻱ ﺍﻻﺿﻼﻉ ﻣﻲ ﺗﻮﺍﻧﺪ ﭼﻨﺪﻳﻦ ﭘﻠﻴﻜﺎﻥ ﻭﺍﺭﺩ ﺷﻮﺩ ﺍﻣﺎ ﻓﻘﻂ ﻳﻚ ﭘﻠﻴﻜﺎﻥ ﺧﺎﺭﺝ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﺩﺭ ﺑﻌﻀﻲ ﺍﺯ ﻛﺘﺎﺑﻬﺎ ﻋﻼﻣﺖ ﺧﺮﻭﺟﻲ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﺭﻭﺑﺮﻭ ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﻨﺪ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪5‬‬
‫ﻋﻼﻣﺖ ﺭﺍﺑﻂ) ﺍﺩﺍﻣﻪ(‪ :‬ﺑﺮﺍﻱ ﻗﻄﻊ ﺍﺟﺮﺍﻱ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻭ ﺍﺩﺍﻣﻪ ﺩﺍﺩﻥ ﺁﻥ ﺍﺯ ﻣﺤﻠﻲ ﺩﻳﮕﺮ ﺍﺯ ﻋﻼﻣﺖ ﺭﺍﺑﻂ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﻋﻼﻣﺖ ﺭﺍﺑﻂ ﺑﻪ ﺻﻮﺭﺕ‬
‫ﻳﻚ ﺩﺍﻳﺮﻩ ﺍﺳﺖ‪ .‬ﺩﺍﺧﻞ ﺩﺍﻳﺮﻩ ﻳﻜﻲ ﺍﺯ ﺣﺮﻭﻑ ﺍﻧﮕﻠﻴﺴﻲ ﺭﺍ ﻧﻮﺷﺘﻪ ﻭ ﻳﻚ ﺩﺍﻳﺮﻩ ﺩﻳﮕﺮ ﻛﻪ ﻣﺤﻞ ﺑﻌـﺪﻱ ﺍﺟـﺮﺍﻱ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﺭﺍ ﻣـﺸﺨﺺ ﻣـﻲ ﻛﻨـﺪ‬
‫ﻫﻤﺎﻥ ﺣﺮﻑ ﺍﻧﮕﻠﻴﺴﻲ ﺭﺍ ﻣﻲ ﻧﻮﻳﺴﻴﻢ‪.‬‬
‫‪A‬‬
‫ﺯﻳﺮﺍﻟﮕﻮﺭﻳﺘﻢ‪:‬‬
‫ﮔﺎﻫﻲ ﺑﺮﺍﻱ ﺣﻞ ﻳﻚ ﻣﺴﺎﻟﻪ ﺑﺰﺭﮒ ﺑﺎﻳﺪ ﻣﺴﺎﻟﻪ ﺭﺍ ﺑﻪ ﻣﺴﺎﻳﻞ ﻛﻮﭼﻜﺘﺮﻱ ﺗﻘﺴﻴﻢ ﻛﻨﻴﻢ ﻭ ﺳﭙﺲ ﺑﺎ ﺣﻞ ﻣﺴﺌﻠﻪ ﻫﺎﻱ ﻛﻮﭼﻚ ﻣـﺴﺎﻟﺔ ﺑـﺰﺭﮒ‬
‫ﺣﻞ ﻣﻲ ﺷﻮﺩ‪ .‬ﻳﺎ ﮔﺎﻫﻲ ﺑﺨﺸﻲ ﺍﺯ ﻳﻚ ﺍﻟﮕﻮﺭﻳﺘﻢ ﭼﻨﺪﻳﻦ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺩﺭﺍﻳﻦ ﺻﻮﺭﺕ ﺷﻤﺎ ﻣﻲ ﺗﻮﺍﻧﻴﺪ ﻗﺴﻤﺖ ﺗﻜﺮﺍﺭ ﺷـﻮﻧﺪﻩ ﺭﺍ ﺑـﻪ‬
‫ﺻﻮﺭﺕ ﻳﻚ ﻗﺴﻤﺖ ﻣﺴﺘﻘﻞ ﻧﻮﺷﺘﻪ ﻭ ﺁﻥ ﺭﺍ ﺑﻪ ﺩﻓﻌﺎﺕ ﺻﺪﺍ ﺑﺰﻧﻴﺪ‪ .‬ﺯﻳﺮ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺨﺸﻲ ﺍﺯ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺍﺻﻠﻲ ﺍﺳﺖ ﻛﻪ ﺑﺮﺍﻱ ﺣـﻞ ﻗـﺴﻤﺘﻲ ﺍﺯ‬
‫ﻣﺴﺎﻟﻪ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻣﺰﺍﻳﺎﻱ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺯﻳﺮﺍﻟﮕﻮﺭﻳﺘﻢ ﻫﺎ‪ -١ :‬ﺳﺒﺐ ﻛﺎﻫﺶ ﺣﺠﻢ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺍﺻﻠﻲ ﻣﻲ ﺷﻮﻧﺪ ‪ -٢‬ﺑﺎ ﺍﻋﻤـﺎﻝ ﺗﻐﻴﺮﺍﺗـﻲ ﺩﺭ ﺯﻳـﺮ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﻣـﻲ ﺗـﻮﺍﻥ‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺍﺻﻠﻲ ﺭﺍ ﺗﻐﻴﻴﺮ ﻳﺎ ﺗﻌﻤﻴﻢ ﺩﺍﺩ‪ -٣ .‬ﺳﺒﺐ ﺳﺎﺩﻩ ﺗﺮ ﺷﺪﻥ ﺭﻭﺵ ﺣﻞ ﻳﻚ ﻣﺴﺎﻟﻪ ﻣﻲ ﺷﻮﺩ ﺯﻳﺮﺍ ﻣﺴﺎﻟﻪ ﺑﻪ ﻣـﺴﺎﻳﻞ ﻛـﻮﭼﻜﺘﺮﻱ ﺗﻘـﺴﻴﻢ‬
‫ﺷﺪﻩ ﺍﺳﺖ‪ -٤ .‬ﻭﺍﮔﺬﺍﺭﻱ ﻧﻮﺷﺘﻦ ﻫﺮ ﺯﻳﺮﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﻪ ﻳﻚ ﺷﺨﺺ ﺳﺒﺐ ﺻﺮﻓﻪ ﺟﻮﻳﻲ ﺩﺭ ﻭﻗﺖ ﻣﻲ ﺷﻮﺩ‪).‬ﻛﺎﺭﮔﺮﻭﻫﻲ(‬
‫ﺯﻳﺮﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ ﻫﻤﺎﻥ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻫﺴﺘﻨﺪ ﻛﻪ ﺩﺭ ﻣﺒﺎﺣﺚ ﭘﺎﺳﻜﺎﻝ ﺑﺤﺚ ﺧﻮﺍﻫﺪ ﺷﺪ‪.‬‬

‫ﺗﻌﺪﺍﺩﻱ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻳﺎ ﻓﻠﻮﭼﺎﺭﺕ ﺩﺭ ﺍﺩﺍﻣﻪ ﺁﻣﺎﺩﻩ ﺍﺳﺖ ﻛﻪ ﺍﻧﺘﻈﺎﺭ ﻣﻲ ﺭﻭﺩ ﺩﺭ ﻣﻮﺭﺩ ﺣﻞ ﺁﻧﻬﺎ ﻓﻜﺮ ﻛﻨﻴﺪ‪.‬‬
‫‪ -١‬ﻓﻠﻮﭼﺎﺭﺗﻲ ﺭﺳﻢ ﻛﻨﻴﺪ ﻛﻪ ﺍﻋﺪﺍﺩ ﺯﻭﺝ ﺩﻭﺭﻗﻤﻲ ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻭ ﭼﺎﭖ ﻛﻨﺪ‪.‬‬
‫‪ -٢‬ﻓﻠﻮﭼﺎﺭﺗﻲ ﺭﺳﻢ ﻛﻨﻴﺪ ﻛﻪ ﻣﻘﺴﻮﻡ ﻋﻠﻴﻪ ﻫﺎﻱ ﻳﻚ ﻋﺪﺩ ﻭﺭﻭﺩﻱ ﺭﺍ ﺟﻤﻊ ﻭ ﺣﺎﺻﻞ ﺟﻤﻊ ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ‪.‬‬
‫‪ -٣‬ﺍﻟﮕﻮﺭﻳﺘﻤﻲ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻚ ﻋﺪﺩ ﺍﺯ ﻭﺭﺩﻭﻱ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﺯﻭﺝ ﻭ ﻓﺮﺩ ﺑﻮﺩﻥ ﺁﻥ ﺭﺍ ﻣﺸﺨﺺ ﻛﻨﺪ‪.‬‬
‫‪ -٤‬ﻓﻠﻮﭼﺎﺭﺗﻲ ﺭﺳﻢ ﻛﻨﻴﺪ ﻛﻪ ﻳﻚ ﻋﺪﺩ ﺍﺯ ﻭﺭﻭﺩﻱ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﻓﺎﻛﺘﻮﺭﻳﻞ ﺁﻥ ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ‪5!=1*2*3*4*5 .‬‬
‫‪ -٥‬ﻓﻠﻮﭼﺎﺭﺗﻲ ﺭﺳﻢ ﻛﻨﻴﺪﻛﻪ ﻋﺪﺩ ﻭﺭﻭﺩﻱ ﻣﺎﻧﻨﺪ ‪ N‬ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﺣﺎﺻﻞ ﺯﻳﺮ ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ‪.‬‬

‫)‪S=1/2 + 3 / 4 + 5 / 6 + …+N/(N+1‬‬

‫‪ -٦‬ﻓﻠﻮﭼﺎﺭﺗﻲ ﺭﺳﻢ ﻛﻨﻴﺪ ﻛﻪ ﻳﻚ ﻋﺪﺩ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﻣﻌﻜﻮﺱ ﺁﻥ ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ‪4395 è 5934 .‬‬
‫‪ -٧‬ﻓﻠﻮﭼﺎﺭﺗﻲ ﺭﺳﻢ ﻛﻨﻴﺪ ﻛﻪ ﺍﻋﺪﺍﺩ ﭼﻬﺎﺭ ﺭﻗﻤﻲ ﻛﻪ ﺍﺯ ﭼﭗ ﻭ ﺍﺯ ﺭﺍﺳﺖ ﺑﻜﺠﻮﺭ ﺧﻮﺍﻧﺪﻩ ﻣﻲ ﺷﻮﻧﺪ ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ ﻣﺎﻧﻨﺪ ﺍﻋﺪﺍﺩ‪ 3223‬ﻳﺎ ‪4994‬‬
‫‪ -٨‬ﻓﻠﻮﭼﺎﺭﺗﻲ ﺭﺳﻢ ﻛﻨﻴﺪ ﻛﻪ ﻳﻚ ﻋﺪﺩ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﺭﻗﻢ ﺑﺰﺭﮔﺘﺮ ﺁﻥ ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ‪.‬‬
‫‪ -٩‬ﻓﻮﭼﺎﺭﺗﻲ ﺭﺳﻢ ﻛﻨﻴﺪ ﻛﻪ ﺳﺮﻱ ﺍﻋﺪﺍﺩ ﻓﻴﺒﻮﻧﺎﭼﻲ ﻛﻤﺘﺮ ﺍﺯ ‪ ١٠٠٠‬ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ‪.‬‬
‫‪ -١٠‬ﻓﻠﻮﭼﺎﺭﺗﻲ ﺭﺳﻢ ﻛﻨﻴﺪ ﻛﻪ ﻳﻚ ﻋﺪﺩ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﻣﺒﻨﺎﻱ ‪ ٨‬ﺁﻥ ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ‪.‬‬

‫ﺗﺴﺖ ‪:‬‬
‫‪ -٧‬ﻧﻤﻮﺩﺍﺭ ﮔﺮﺩﺷﻲ ﺭﻭﺑﺮﻭ ﭼﻪ ﻫﺪﻓﻲ ﺭﺍ ﺩﻧﺒﺎﻝ ﻣﻲ ﻛﻨﺪ؟ )‪ M‬ﻭ ‪ N‬ﺩﻭ ﻋﺪﺩ ﻃﺒﻴﻌﻲ ﻫﺴﺘﻨﺪ(‪.‬‬
‫ﺍﻟﻒ( ﺣﺎﺻﻞ ﺿﺮﺏ ‪ M‬ﻭ ‪ N‬ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻭ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﺏ(‪ M‬ﺭﺍ ﺑﻪ ﺗﻮﺍﻥ ‪ N‬ﺭﺳﺎﻧﺪﻩ ﻭ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﺝ(‪ N‬ﺭﺍ ﺑﻪ ﺗﻮﺍﻥ ‪ M‬ﺭﺳﺎﻧﺪﻩ ﻭ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﺩ(ﺣﺎﺻﻞ ﺗﻘﺴﻴﻢ ‪ M‬ﺑﺮ ‪ N‬ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻭ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪6‬‬
‫‪ -٨‬ﻫﺪﻑ ﺍﺯ ﻓﻠﻮﭼﺎﺭﺕ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬
‫ﺍﻟﻒ( ﭼﺎﭖ ﺍﻋﺪﺍﺩ ﺯﻭﺝ ﻛﻮﭼﻜﺘﺮ ﻳﺎ ﻣﺴﺎﻭﻱ ﻋﺪﺩ ﻭﺭﻭﺩﻱ‬
‫ﺏ(ﭼﺎﭖ ﻣﻘﺴﻮﻡ ﻋﻠﻴﻪ ﻫﺎﻱ ﺯﻭﺝ ﻋﺪﺩ ﻭﺭﻭﺩﻱ‬
‫ﺝ( ﭼﺎﭖ ﻭﺍﺭﻭﻥ ﻋﺪﺩ ﻭﺭﻭﺩﻱ‬
‫ﺩ( ﺩﺭ ﺣﻠﻘﺔ ﺩﺍﺋﻤﻲ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ‬

‫‪ -٩‬ﺧﺮﻭﺟﻲ ﻧﻤﻮﺩﺍﺭ ﮔﺮﺩﺷﻲ ﻣﻘﺎﺑﻞ ﻛﺪﺍﻣﺴﺖ؟ ‪N=4‬‬

‫ﺍﻟﻒ( ‪120‬‬
‫ﺏ( ‪1 , 1 , 2 , 6 , 24‬‬
‫ﺝ( ‪24‬‬
‫ﺩ(‪1‬‬

‫‪ -١٠‬ﺧﺮﻭﺟﻲ ﻧﻤﻮﺩﺍﺭ ﮔﺮﺩﺷﻲ ﻣﻘﺎﺑﻞ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫ﺍﻟﻒ( ‪8‬‬
‫ﺏ(‪17‬‬
‫ﺝ( ‪26‬‬
‫ﺩ( ‪5‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪7‬‬
‫‪-١١‬ﻛﺪﺍﻡ ﺷﻜﻞ ﻫﻨﺪﺳﻲ ﻋﻼﻣﺖ ﭘﺮﺩﺍﺯﺵ ﺩﺭ ﻳﻚ ﻧﻤﻮﺩﺍﺭ ﮔﺮﺩﺷﻲ ﺍﺳﺖ؟‬
‫ﺩ( ﻣﺴﺘﻄﻴﻞ‬ ‫ﺝ( ﻣﺘﻮﺍﺯﻱ ﺍﻻﺿﻼﻉ‬ ‫ﺏ( ﻟﻮﺯﻱ‬ ‫ﺍﻟﻒ( ﺩﺍﻳﺮﻩ‬

‫‪-١٢‬ﻛﺪﺍﻡ ﺷﻜﻞ ﻋﻼﻣﺖ ﺭﺍﺑﻂ ﺩﺭ ﻓﻠﻮﭼﺎﺭﺕ ﺍﺳﺖ؟‬

‫ﺩ( ﻣﺘﻮﺍﺯﻱ ﺍﻻﺿﻼﻉ‬ ‫ﺝ( ﻣﺴﺘﻄﻴﻞ‬ ‫ﺏ( ﺑﻴﻀﻲ‬ ‫ﺍﻟﻒ( ﺩﺍﻳﺮﻩ‬

‫‪ -١٣‬ﻫﺪﻑ ﺍﺯ ﻓﻠﻮﭼﺎﺭﺕ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬

‫ﺍﻟﻒ( ﭼﺎﭖ ﻣﻘﺴﻮﻡ ﻋﻠﻴﻪ ﻫﺎﻱ ﻋﺪﺩ ﻣﻮﺭﺩ ﻧﻈﺮ‬

‫ﺏ( ﭼﺎﭖ ﻭﺍﺭﻭﻥ ﻋﺪﺩ‬
‫ﺝ( ﭼﺎﭖ ﺍﻋﺪﺍﺩ ‪ ١‬ﺗﺎ ﻋﺪﺩ ﻣﻮﺭﺩ ﻧﻈﺮ‬
‫ﺩ( ﺍﻋﺪﺍﺩ ﺯﻭﺝ ‪ ١‬ﺗﺎ ﻋﺪﺩ ﻣﻮﺭﺩ ﻧﻈﺮ‬

‫‪ -١٤‬ﻓﻠﻮﭼﺎﺭﺕ ﻣﻘﺎﺑﻞ ﻣﺤﺎﺳﺒﻪ ﻛﺪﺍﻡ ﺳﺮﻱ ﺯﻳﺮ ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﺪ؟‬

‫ﺍﻟﻒ( ‪1/2 + 1/4 + 1/6 +….+ 1/98‬‬

‫ﺏ( ‪1/2 - 1/4 + 1/6 -….+ 1/98‬‬

‫ﺝ( ‪-1/2 + 1/4 - 1/6 +….- 1/98‬‬

‫ﺩ( ‪-1/2 - 1/4 - 1/6 -…..- 1/98‬‬

‫‪ -١٥‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺻﺤﻴﺢ ﻧﻴﺴﺖ؟‬

‫ﺩ(‬ ‫ﺝ(‬ ‫ﺏ(‬ ‫ﺍﻟﻒ(‬

‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪8‬‬
‫‪ -١٦‬ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﻭﺑﺮﻭ ﺟﻬﺖ ﻧﻤﺎﻳﺶ ﺍﻋﺪﺍﺩ‪ ١‬ﺍﻟﻲ ‪ ٥٠‬ﺭﻭﻱ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﺍﺳﺖ ﺩﺭ ﺧﻂ ‪ ٥‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺭﺍ ﺑﺎﻳﺪ ﻗﺮﺍﺭ ﺩﺍﺩ؟‬

‫ﺷﺮﻭﻉ‬ ‫‪-١‬‬
‫‪X= 0‬‬ ‫‪-٢‬‬ ‫ﺍﻟﻒ( ﺍﮔﺮ ‪ X<=50‬ﺁﻧﮕﺎﻩ ﺑﺮﻭ ﺑﻪ ‪٣‬‬
‫‪X=X+1‬‬ ‫‪-٣‬‬ ‫ﺏ( ﺍﮔﺮ ‪ X<50‬ﺁﻧﮕﺎﻩ ﺑﺮﻭ ﺑﻪ ‪٣‬‬
‫‪ X‬ﺭﺍ ﻧﻤﺎﻳﺶ ﺑﺪﻩ‬ ‫‪-٤‬‬
‫ﺝ( ﺍﮔﺮ ‪ X>=50‬ﺁﻧﮕﺎﻩ ﺑﺮﻭ ﺑﻪ ‪٣‬‬
‫؟‬ ‫‪-٥‬‬
‫ﺩ( ﺍﮔﺮ ‪ X=50‬ﺁﻧﮕﺎﻩ ﺑﺮﻭ ﺑﻪ ‪٣‬‬
‫ﭘﺎﻳﺎﻥ‬ ‫‪-٦‬‬

‫‪ -١٧‬ﻓﻠﻮﭼﺎﺭﺕ ﺭﻭﺑﺮﻭ ﭼﻪ ﺧﺮﻭﺟﻲ ﺩﺍﺭﺩ؟‬

‫ﺍﻟﻒ( ﭼﺎﭖ ﺗﻔﺎﺿﻞ ‪ X‬ﻭ‪Y‬‬

‫ﺏ(ﭼﺎﭖ ‪ X‬ﺗﻘﺴﻴﻢ ﺑﺮ‪Y‬‬
‫ﺝ(ﭼﺎﭖ ﻣﺠﻤﻮﻉ ‪ X‬ﻭ ‪Y‬‬
‫ﺩ(ﭼﺎﭖ ‪X*Y‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪9‬‬
‫ﭘﺎﺳـﮑﺎل‪:‬‬
‫ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺗﻮﺳﻂ ﭘﺮﻓﺴﻮﺭ ﻧﻴﻜﻼﺙ ﻭﻳﺮﺙ ﺍﺑﺪﺍﻉ ﺷﺪ‪ .‬ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺍﻳﻦ ﺯﺑﺎﻥ ﺍﺑﺪﺍﻉ ﺷﺪ ﻣﺘﺮﺟﻤﻬﺎﻱ ﻣﺘﻔﺎﻭﺗﻲ ﺑﺮﺍﻱ ﺁﻥ ﺍﺯ ﺳـﻮﻱ ﺷـﺮﻛﺘﻬﺎﻱ‬
‫ﻣﺘﻌﺪﺩﻱ ﻧﻮﺷﺘﻪ ﺷﺪ ﻣﺎﻧﻨﺪ‪):‬ﻟﻬﺠﻪ ﻫﺎﻱ ﻣﺨﺘﻠﻒ ﻳﻚ ﺯﺑﺎﻥ(‬
‫‪Ansi Pascal‬‬
‫‪Ms-Pascal‬‬
‫‪Borland Pascal‬‬
‫‪Turbo Pascal‬‬
‫ﺩﺭ ﺍﻳﻦ ﺟﺰﻭﻩ ﺳﻌﻲ ﺷﺪﻩ ﺍﺳﺖ ﺑﺎ ﻧﻜﺎﺕ ﻭ ﻗﻮﺍﻋﺪ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺁﺷﻨﺎ ﺷﻮﻳﺪ ﻭ ﺗﺎﻛﻴﺪ ﺍﺻﻠﻲ ﺑﺮ ﺭﻭﻱ ﻧﻜﺎﺕ ﺟﻬﺖ ﺗﺴﺖ ﺍﺳﺖ‪ .‬ﺑﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ‬
‫ﺑﺎﻳﺪ ﻋﻼﻭﻩ ﺑﺮ ﻳﺎﺩﮔﺮﻓﺘﻦ ﻗﻮﺍﻋﺪ ﻣﻲ ﺑﺎﻳﺴﺖ ﺗﻤﺮﻳﻦ ﻭ ﺗﻼﺵ ﺑﻴﺸﺘﺮﻱ ﺩﺍﺷﺖ‪.‬‬
‫ﻣﺰاﯾﺎ و ﻣﻌﺎﯾﺐ زﺑﺎن ﭘﺎﺳﮑﺎل‪:‬‬
‫ﺯﺑﺎﻧﻬﺎﻱ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻣﺘﻌﺪﺩﻱ ﺟﻬﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﺍﻣﺎ ﻫﺮ ﻛﺪﺍﻡ ﺑﺮﺍﻱ ﻳﻚ ﻫﺪﻑ ﺧﺎﺻﻲ ﺍﻳﺠﺎﺩ ﺷﺪﻩ ﺍﻧﺪ‪ .‬ﺑﻪ ﻋﻨـﻮﺍﻥ ﻣﺜـﺎﻝ ﺯﺑـﺎﻥ‬
‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺑﻴﺴﻴﻚ ﺟﻬﺖ ﺁﻣﻮﺯﺵ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺑﻪ ﺍﻓﺮﺍﺩ ﻣﺒﺘﺪﻱ ﺍﻳﺠﺎﺩ ﺷﺪﻩ ﺍﺳﺖ ﻭ ﻫﺪﻑ ﺁﻣﻮﺯﺷـﻲ ﺩﺍﺭﺩ‪ .‬ﺯﺑـﺎﻥ ﭘﺎﺳـﻜﺎﻝ ﺟﻬـﺖ ﺑﺮﻧﺎﻣـﻪ‬
‫ﻧﻮﻳﺴﻲ ﺳﺎﺩﻩ ﻭ ﺁﻣﻮﺯﺵ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺳﺎﺧﺖ ﻳﺎﻓﺘﻪ ﺍﻳﺠﺎﺩ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬
‫ﺍﻭﻟﻴﻦ ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺳﻄﺢ ﺑﺎﻻ‪ ،‬ﺯﺑﺎﻥ ‪ ALGOL‬ﺑﻮﺩ ﻭ ﺟﻬﺖ ﭘﻴﺎﺩﻩ ﺳﺎﺯﻱ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﻱ ﺭﻳﺎﺿﻲ ﺍﻳﺠﺎﺩ ﺷﺪ‪.‬‬
‫ﻣﺰاﯾﺎي زﺑﺎن ﭘﺎﺳﮑﺎل‪:‬‬
‫‪ -١‬ﻗﺎﺑﻞ ﻓﻬﻢ ﺑﻮﺩﻥ ﺩﺳﺘﻮﺭﺍﺕ)ﭼﻮﻥ ﺑﻪ ﺯﺑﺎﻥ ﻣﺤﺎﻭﺭﻩ ﺍﻱ ﻧﺰﺩﻳﻚ ﺍﺳﺖ( ‪ -٢‬ﺩﺍﺷﺘﻦ ﺗﻮﺍﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ ﺍﻱ‬
‫‪ -٣‬ﭘﺸﺘﻴﺒﺎﻧﻲ ﺍﺯ ﺍﻧﻮﺍﻉ ﺩﺍﺩﻩ ﻫﺎ)ﺍﻋﺸﺎﺭﻱ‪ -‬ﺻﺤﻴﺢ – ﺑﻮﻟﻴﻦ‪-‬ﺭﺷﺘﻪ ﺍﻳﻲ – ﻛﺎﺭﺍﻛﺘﺮﻱ ﻭ…( ‪ -٤‬ﺳﺎﺧﺖ ﻳﺎﻓﺘﻪ ﺑﻮﺩﻥ‬
‫ﺑﺮﻧﺎﻣﻪ ﺳﺎﺧﺖ ﻳﺎﻓﺘﻪ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﺍﻳﻲ ﮔﻔﺘﻪ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺍﺯ ﺑﻠﻮﻛﻬﺎﻱ ﭘﻲ ﺩﺭﭘﻲ ﻳﺎ ﻣﺘﺪﺍﺧﻞ ﺗﺸﻜﻴﻞ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺑﺮﻧﺎﻣﻪ ﻫﺎﻳﻲ ﻛﻪ ﺳﺎﺧﺖ ﻳﺎﻓﺘﻪ‬
‫ﺑﺎﺷﻨﺪ ﺳﻪ ﻣﺰﻳﺖ ﺩﺍﺭﻧﺪ‪ - ١ :‬ﺍﺷﻜﺎﻝ ﺯﺩﺍﻳﻲ ﺳﺎﺩﻩ ﺗﺮ ﺍﺳﺖ ‪ -٢‬ﺧﻮﺍﻧﺎﻳﻲ ﻭ ﺩﺭﻙ ﺑﺮﻧﺎﻣﻪ ﺳﺎﺩﻩ ﺗﺮ ﺍﺳﺖ‪ -٣ .‬ﺍﻋﻤﺎﻝ ﺗﻐﻴﻴﺮﺍﺕ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺳﺎﺩﻩ ﺗﺮ‬
‫ﺍﺳﺖ‪.‬‬
‫ﻣﻌﺎﯾﺐ زﺑﺎن ﭘﺎﺳﮑﺎل‪:‬‬
‫‪ -١‬ﻧﺪﺍﺷﺘﻦ ﻗﺎﺑﻠﻴﺖ ﺍﻧﻌﻄﺎﻑ‬
‫‪ -٢‬ﻧﺪﺍﺷﺘﻦ ﻗﺎﺑﻠﻴﺖ ﺍﻧﺘﻘﺎﻝ‬
‫‪ -٣‬ﻋﺪﻡ ﺍﻣﻜﺎﻥ ﺗﻌﺮﻳﻒ ﺭﻛﻮﺭﺩ ﺑﺎ ﻃﻮﻝ ﻣﺘﻐﻴﺮ‬
‫ﺩﻗﺖ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﻣﻌﺎﻳﺐ ﺷﺎﻳﺪ ﻓﻘﻂ ﺗﻮﺳﻂ ﺍﻓﺮﺍﺩ ﺣﺮﻓﻪ ﺍﻱ ﻗﺎﺑﻞ ﺩﺭﻙ ﻭﻓﻬﻢ ﺑﺎﺷﻨﺪ‪.‬‬

‫اﺟـﺰاي ﯾﮏ ﺑﺮﻧﺎﻣﻪ‪:‬‬
‫ﻫﻤﺎﻧﻄﻮﺭ ﻛﻪ ﻳﻚ ﻛﺘﺎﺏ ﺑﻪ ﺯﺑﺎﻥ ﻓﺎﺭﺳﻲ ﺍﺯ ﻓﺼﻞ ﻫﺎ ﻭ ﺻﻔﺤﺎﺕ ﻭ ﭘﺎﺭﺍﮔﺮﺍﻑ ﻫﺎ ﻭﺟﻤﻼﺕ‬
‫ﻭ ﻛﻠﻤﺎﺕ ﻭ ﺣﺮﻭﻑ ﺗﺸﻜﻴﻞ ﺷﺪﻩ ﺍﺳﺖ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﭘﺎﺳﻜﺎﻝ ﻧﻴﺰ ﺍﺯ ﺑﻠﻮﻙ ﻫﺎ ﻭ ﺩﺳﺘﻮﺭﺍﺕ ﻭ ﻛﻠﻤﺎﺕ ﺗﺸﻜﻴﻞ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺑﻪ ﻛـﻮﭼﻜﺘﺮﻳﻦ ﻭﺍﺣـﺪ‬
‫ﻣﻌﻨﻲ ﺩﺍﺭ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺗﻮﻛﻦ)‪ (Token‬ﻣﻲ ﮔﻮﻳﻨﺪ‪.‬‬
‫ﺑﻪ ﻃﻮﺭ ﻛﻠﻲ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﺍﺯ ﭼﻬﺎﺭ ﺩﺳﺘﻪ ﻛﻠﻤﻪ ﺗﺸﻜﻴﻞ ﻣﻲ ﺷﻮﺩ‪:‬‬
‫‪ -1‬ﮐﻠﻤﺎت رزرو ﺷـﺪه ‪ :‬ﻛﻠﻤﺎﺗﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﺩﺭ ﺯﺑﺎﻥ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺍﻧﺪﻭ ﺑﻪ ﻣﻨﻈﻮﺭ ﺧﺎﺻﻲ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﺷﺪﻩ ﺍﻧﺪ‪.‬‬
‫ﻣﺎﻧﻨﺪ ‪ Begin , End , For , Program‬ﻭ …‬
‫‪ -2‬ﺷﻨﺎﺳـﻪ ﻫﺎ ‪ :‬ﻛﻪ ﺑﻪ ﺩﻭ ﺩﺳﺘﻪ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﻭ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻏﻴﺮ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ‪ -‬ﺷﻨﺎﺳﻪ ﻫﺎي اﺳـﺘﺎﻧﺪارد‬
‫ﻛﻠﻤﺎﺗﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﺍﺯ ﻃﺮﻑ ﻣﺘﺮﺟﻢ ﭘﺎﺳﻜﺎﻝ ﺑﺮﺍﻱ ﻣﻨﻈﻮﺭ ﺧﺎﺻﻲ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺍﻧﺪ‪ .‬ﺗﻮﺟﻪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﺍﻳﻦ ﻛﻠﻤـﺎﺕ‪ ،‬ﺭﺯﺭﻭ ﺷـﺪﻩ‬
‫ﻧﻴﺴﺘﻨﺪ‪ .‬ﻣﺎﻧﻨﺪ ‪ Readln, Write,ABS‬ﻭ …‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪10‬‬
‫ﺷﻨﺎﺳﻪ ﻫﺎي ﻏﯿﺮ اﺳﺘﺎﻧﺪارد ﺷﻨﺎﺳﻪ ﻫﺎﻳﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﺧﻮﺩ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺁﻧﻬﺎ ﺭﺍ ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﺪ‪ .‬ﻣﺎﻧﻨﺪ ﻣﺘﻐﻴﺮﻫﺎ ‪ ،‬ﺛﺎﺑﺘﻬـﺎ ‪ ،‬ﺯﻳﺮﺑﺮﻧﺎﻣـﻪ ﻫـﺎ‬
‫;‪Program Ali‬‬ ‫ﻧﻮﻋﻬﺎ ﻭ …ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ ﺗﻮﺍﻧﺪ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺭﺍ ﻣﺠﺪﺩﺍ ﺗﻌﺮﻳﻒ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪Const‬‬ ‫‪-3‬ﺛﺎﺑﺘـﻬﺎ ‪ :‬ﻣﻘﺎﺩﻳﺮﻱ ﻫﺴﺘﻨﺪ ﻛﻪ ﺩﺭ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﻧﻤﻲ ﻛﻨﻨﺪ ﻣﺎﻧﻨﺪ ﻋﺪﺩ ‪ ٥‬ﻳﺎ‬
‫;‪F=13‬‬
‫‪Var‬‬ ‫ﺭﺷﺘﻪ ’‪ . ’ALI‬ﺛﺎﺑﺘﻬﺎ ﺍﻋﺪﺍﺩ ﻳﺎ ﺭﺷﺘﻪ ﻫﺎﻳﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫;‪A:integer‬‬ ‫‪-4‬ﻋـﻼﯾﻢ ‪ :‬ﻛﺎﺭﺍﻛﺘﺮ)ﻫﺎﯾﯽ( ﻫﺴﺘﻨﺪ ﻛﻪ ﻣﻌﻨﻲ ﺧﺎﺻﻲ ﻣﻲ ﺩﻫﻨﺪ‪.‬‬
‫;‪B:Real‬‬
‫ﻣﺜﻼ ﻋﻼﻣﺖ * ﺑﻪ ﻣﻌﻨﺎﻱ ﺿﺮﺏ ﺍﺳﺖ ﻭﻋﻼﻣﺖ ‪ $‬ﺑﺮﺍﻱ ﺍﻋﺪﺍﺩ ﺩﺭ ﻣﺒﻨﺎﻱ ‪ ١٦‬ﺑﻪ ﻛﺎﺭ ﻣﻲ ﺭﻭﺩ‪$A2=162 .‬‬
‫‪Begin‬‬
‫;)‪Read(A‬‬
‫;‪A:=A+1‬‬ ‫ﺷﻨﺎﺳﻪ ﻫﺎي ﻏﯿـﺮ اﺳﺘﺎﻧﺪارد ‪:‬‬
‫;‪B:=A/10‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺧﻮﺩ ﻧﻴﺎﺯ ﺑﻪ ﻣﺘﻐﻴﺮﻫﺎ ﻳﺎ ﺛﺎﺑﺘﻬﺎ ﻭ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻳﺎ ﺑﺮﭼﺴﺐ ﻳﺎ … ﺩﺍﺭﺩ ﻛﻪ ﺑﺎﻳﺪ ﺧﻮﺩ‬
‫;)‪Writeln(A,B‬‬
‫ﺗﻌﺮﻳﻒ ﻛﻨﺪ‪ .‬ﻫﻨﮕﺎﻣﯽ ﮐﻪ ﻣﯽ ﺧﻮاﻫﯿﺪ ﺑﺮاي ﯾﮏ ﺷﻨﺎﺳﻪ ﻧﺎم اﻧﺘﺨﺎب ﮐﻨﯿﺪ ﺑﺎﻳﺪ ﻣﻮﺍﺭﺩ ﺯﻳﺮ ﺭﺍ ﺭﻋﺎﻳﺖ ﻛﻨﻴﺪ‪:‬‬
‫‪End.‬‬
‫ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﭘﺎﺳﻜﺎﻝ‬
‫‪ -1‬ﻧﺎﻡ ﻣﺘﻐﻴﺮ ﺑﺎﻳﺪ ﺑﺎ ﻳﻜﻲ ﺍﺯ ﺣﺮﻭﻑ ﺍﻧﮕﻠﻴﺴﻲ ﻳﺎ ﻋﻼﻣﺖ ﺯﻳﺮﺧﻂ) _ ( ﺷﺮﻭﻉ ﺷﻮﺩ‪.‬‬
‫‪ -٢‬ﺣﺮﻑ ﺩﻭﻡ ﺑﻪ ﺑﻌﺪ ﻣﺘﻐﻴﺮ ﻣﻲ ﺗﻮﺍﻧﺪ ﺗﺮﻛﻴﺒﻲ ﺍﺯ ﺣﺮﻭﻑ ﺍﻧﮕﻠﻴﺴﻲ ﻳﺎﺍﻋﺪﺍﺩ ﻳﺎ ﻋﻼﻣﺖ ﺯﻳﺮﺧﻂ) _ ( ﺑﺎﺷﺪ‪.‬‬
‫‪ -٣‬ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﺎﺭﺍﻛﺘﺮﻫﺎﻱ ﻭﻳﮋﻩ ﺻﺤﻴﺢ ﻧﻴﺴﺖ ‪ .‬ﻣﺜﻞ ‪ ! $ & * + - ~ ( > %‬ﻭ ﻏﻴﺮﻩ ) ﺟﺎ ﺧﺎﻟﻲ ﻧﻴﺰ ﻣﺠﺎﺯ ﻧﻴﺴﺖ(‬
‫ﺗﻨﻬﺎ ﻛﺎﺭﺍﻛﺘﺮ ﻭﻳﮋﻩ ﻛﻪ ﻣﻲ ﺗﻮﺍﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ ﻫﻤﺎﻥ ﺯﻳﺮ ﺧﻂ ﺍﺳﺖ‪.‬‬
‫‪ -٤‬ﺣﺮﻭﻑ ﻛﻮﭼﻚ ﻭ ﺑﺰﺭﮒ ﻓﺮﻗﻲ ﺑﺎ ﻫﻢ ﻧﺪﺍﺭﻧﺪ ﻳﻌﻨﻲ ﺷﻨﺎﺳﻪ ‪ A‬ﻭ ﺷﻨﺎﺳﻪ ‪ a‬ﻓﺮﻗﻲ ﺑﺎﻫﻢ ﻧﺪﺍﺭﻧﺪ‪.‬‬
‫‪ -٥‬ﺩﺭ ﺗﻮﺭﺑﻮ ﭘﺎﺳﻜﺎﻝ ﺣﺪﺍﻛﺜﺮ ﻃﻮﻝ ﻳﻚ ﺷﻨﺎﺳﻪ ‪ ٦٣‬ﻛﺎﺭﺍﻛﺘﺮ ﺍﺳﺖ‪.‬‬
‫‪ -٦‬ﺍﺯ ﻛﻠﻤﺎﺕ ﺭﺯﺭﻭ ﺷﺪﻩ ﻧﻤﻲ ﺗﻮﺍﻧﻴﺪ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﺪ‪ .‬ﻣﺎﻧﻨﺪ ‪ For‬ﻳﺎ ‪ While‬ﻳﺎ ‪ Begin‬ﻭ …‬

‫ﺗﻮﺍﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ ﺍﻳﻲ‪ ،‬ﺭﺯﺭﻭ ﺷﺪﻩ ﻧﻴﺴﺘﻨﺪ‪ .‬ﺩﺭ ﺗﻮﺭﺑﻮﭘﺎﺳﻜﺎﻝ ﻫﻨﮕﺎﻡ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻛﻠﻤﺎﺕ ﺭﺯﺭﻭ ﺷﺪﻩ ﺑﺎ ﺭﻧﮓ ﺳﻔﻴﺪ ﻣﺸﺨﺺ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﻧﺎﻡ ﺷﻨﺎﺳﻪ ﻫﺎ ﺭﺍ ﺳﻌﻲ ﻛﻨﻴﺪ ﻛﻠﻤﺎﺕ ﺑﺎﻣﻌﻨﻲ ﺍﻧﺘﺨﺎﺏ ﻛﻨﻴﺪ ﺗﺎ ﺧﻮﺍﻧﺎﻳﻲ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺍﻓﺰﺍﻳﺶ ﺩﻫﺪ‪.‬‬

‫ﺳﺎﺧﺘـﺎر ﺑﺮﻧﺎﻣﻪ‪:‬‬
‫ﻋﻨﻮﺍﻥ‬
‫ﻫﺮ ﺑﺮﻧﺎﻣﻪ ﭘﺎﺳﻜﺎﻝ ﺍﺯ ﺳﻪ ﻗﺴﻤﺖ ﺍﺻﻠﻲ ﺗﺸﻜﻴﻞ ﺷﺪﻩ ﺍﺳﺖ‪:‬‬
‫ﺗﻌﺎﺭﻳﻒ ﻭ ﺍﻋﻼﻧﺎﺕ‬
‫‪ -3‬ﻗﺴﻤﺖ ﺑﻼك ﯾﺎ دﺳﺘﻮراﻟﻌﻤﻞ ﻫﺎ‬ ‫‪ -2‬ﻗﺴﻤﺖ ﺗﻌﺎرﯾﻒ و اﻋﻼﻧﺎت‬ ‫‪-1‬ﻗﺴﻤﺖ ﻋﻨﻮان‬
‫ﺩﺳﺘﻮﺭﺍﺕ ﻳﺎ ﺑﻠﻮﻙ ﺍﺻﻠﻲ‬
‫‪ -1‬ﻗﺴﻤﺖ ﻋﻨﻮان ‪ :‬ﺩﺭ ﺍﻳﻦ ﻗﺴﻤﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻧﺎﻡ ﺑﺮﻧﺎﻣﻪ ﺧﻮﺩ ﺭﺍﻳﺎﺩﺩﺍﺷﺖ ﻣﻲ ﻛﻨﺪ‪ .‬ﻧﺎﻡ ﺑﺮﻧﺎﻣﻪ ﺑﺎﻳﺪ ﺍﺯ‬
‫ﻗﻮﺍﻧﻴﻦ ﻧﺎﻡ ﮔﺬﺍﺭﻱ ﺷﻨﺎﺳﻪ ﻫﺎ ﭘﻴﺮﻭﻱ ﻛﻨﺪ‪.‬ﺑﺎ ﻛﻠﻤﻪ ﺭﺯﺭﻭ ﺷﺪﺓ ‪ PROGRAM‬ﻣﻲ ﺗﻮﺍﻥ ﻧﺎﻡ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﻣﺸﺨﺺ ﻛﺮﺩ‪.‬‬
‫;‪PROGRAM FM‬‬ ‫ﻣﺎﻧﻨﺪ‪:‬‬
‫ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺍﻳﻦ ﺧﻂ ﺍﺟﺒﺎﺭﻱ ﺍﺳﺖ ﺍﻣﺎ ﺩﺭ ﺗﻮﺭﺑﻮﭘﺎﺳﻜﺎﻝ ﻧﻮﺷﺘﻦ ﺍﻳﻦ ﺧﻂ ﺍﺧﺘﻴﺎﺭﻱ ﺍﺳﺖ‪.‬‬
‫‪ -2‬ﻗﺴﻤﺖ ﺗﻌﺎرﯾﻒ و اﻋﻼﻧﺎت ‪ :‬ﺩﺭ ﺍﻳﻦ ﻗﺴﻤﺖ ﺑﺎﻳﺪ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﺑﻪ ﻛﺎﺭ ﺭﻓﺘﻪ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻌﺮﻓﻲ ﺷﻮﻧﺪ ﻣﺜﻞ ﻣﺘﻐﻴﺮﻫﺎ‪،‬‬
‫ﺛﺎﺑﺘﻬﺎ ‪ ،‬ﺑﺮﭼﺴﺐ ﻫﺎ‪ ،‬ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻭ …‪.‬ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺍﺑﺘﺪﺍ ﺛﺎﺑﺘﻬﺎ ﺳﭙﺲ ﻧﻮﻉ ﺩﺍﺩﻩ ﻫﺎ ﻭ ﺩﺭ ﺁﺧﺮ‬
‫‪Program‬‬
‫‪USES‬‬ ‫ﻣﺘﻐﻴﺮﻫﺎ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﻧﻤﺎﺩ ﻛﻠﻲ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﭘﺎﺳﻜﺎﻝ ﺑﻪ ﺻﻮﺭﺕ ﺭﻭﺑﺮﻭ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪:‬‬
‫‪Label‬‬ ‫‪ -3‬ﻗﺴﻤﺖ دﺳﺘﻮرات ‪ :‬ﺍﻳﻦ ﻗﺴﻤﺖ ﺑﺎ ﻳﻚ ‪ BEGIN‬ﺷﺮﻭﻉ ﻣﻲ ﺷﻮﺩﻭ ﺑﺎ ﻳﻚ ‪ END.‬ﭘﺎﻳﺎﻥ ﻣﻲ ﻳﺎﺑﺪ ﻛﻪ‬
‫‪CONST‬‬
‫‪TYPE‬‬ ‫ﺑﻪ ﺁﻥ ﺑﻠﻮﻙ ﺍﺻﻠﻲ ﺑﺮﻧﺎﻣﻪ ﻣﻲ ﮔﻮﻳﻨﺪ ﻫﺮ ﺑﺮﻧﺎﻣﻪ ﻓﻘﻂ ﻳﻚ ﺑﻠﻮﻙ ﺍﺻﻠﻲ ﺩﺍﺭﺩ‪.‬‬
‫‪VAR‬‬
‫‪BEGIN‬‬
‫ﻣﺠﻤﻮﻋﻪ ﺩﺳﺘﻮﺭﺍﺕ‬
‫‪END.‬‬
‫ﻧﻤﺎﺩ ﻛﻠﻲ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﭘﺎﺳﻜﺎﻝ‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪11‬‬
‫اﻧﻮاع داده ﻫﺎ در زﺑﺎن ﭘﺎﺳـﮑﺎل‪:‬‬
‫‪ -1‬داده ﻫﺎي ﻋﺪدي ‪ :‬ﺍﻳﻦ ﺩﺍﺩﻩ ﻫﺎ ﺑﻪ ﺩﻭ ﺩﺳﺘﻪ ﺻﺤﻴﺢ ﻭ ﺍﻋﺸﺎﺭﻱ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﺩﺍﺩﻩ ﻫﺎﻱ ﻋﺪﺩﻱ ﺻﺤﻴﺢ ﺧﻮﺩ ﺩﺍﺭﺍﻱ ﺍﻧﻮﺍﻉ ﺯﻳـﺮ‬
‫ﻣﻲ ﺑﺎﺷﻨﺪ‪ .‬ﻫﺮﻛﺪﺍﻡ ﺍﺯﺁﻧﻬﺎ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻣﺤﺪﻭﺩﻩ ﺁﻧﻬﺎ ﻭ ﻣﻘﺪﺍﺭ ﻓﻀﺎﻳﻲ ﻛﻪ ﺩﺭ ﺣﺎﻓﻈﻪ ﺍﺷﻐﺎﻝ ﺧﻮﺍﻫﺪ ﻛﺮﺩ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺧﻮﺏ ﻫﻤﻴﺸﻪ ﺳﻌﻲ ﻣﻲ ﻛﻨﺪ ﺑﻬﺘﺮﻳﻦ ﻧﻮﻉ ﺭﺍ ﺑﺮﺍﻱ ﻣﺘﻐﻴﺮﻫﺎﻱ ﺧﻮﺩ ﺍﻧﺘﺨﺎﺏ ﻛﻨﺪ‪.‬‬
‫اﻧﻮاع ﺻﺤﯿـﺢ‬
‫ﻋﻼﻣﺘﺪﺍﺭ‬ ‫ﻣﺤﺪﻭﺩﻩ‬ ‫ﻇﺮﻓﻴﺖ‬ ‫ﻣﺨﻔﻒ‬ ‫ﻧﻮﻉ‬
‫ﻋﻼﻣﺖ ﻧﺪﺍﺭﺩ‬ ‫‪0 - 255‬‬ ‫‪ ١‬ﺑﺎﻳﺖ‬ ‫‪Byt‬‬ ‫‪Byte‬‬
‫ﻋﻼﻣﺘﺪﺍﺭ‬ ‫‪-128 - +127‬‬ ‫‪ ١‬ﺑﺎﻳﺖ‬ ‫‪Sht‬‬ ‫‪ShortINT‬‬
‫ﻋﻼﻣﺘﺪﺍﺭ‬ ‫‪-32768 - +32767‬‬ ‫‪ ٢‬ﺑﺎﻳﺖ‬ ‫‪Int‬‬ ‫‪Integer‬‬
‫ﻋﻼﻣﺖ ﻧﺪﺍﺭﺩ‬ ‫‪0 - 65535‬‬ ‫‪٢‬ﺑﺎﻳﺖ‬ ‫‪Wrd‬‬ ‫‪Word‬‬
‫ﻋﻼﻣﺘﺪﺍﺭ‬ ‫‪-231-1‬ﺗﺎ ‪+231‬‬ ‫‪ ٤‬ﺑﺎﻳﺖ‬ ‫‪Lng‬‬ ‫‪LongInt‬‬
‫ﻋﻼﻣﺘﺪﺍﺭ‬ ‫‪ ٨‬ﺑﺎﻳﺖ‬ ‫‪Cmp‬‬ ‫‪COMP‬‬

‫ﺩﺍﺩﻩ ﻫﺎﻱ ﺍﻋﺸﺎﺭﻱ ﺑﻪ ﺍﻧﻮﺍﻉ ﺯﻳﺮ ﻗﺴﻤﺖ ﻣﻲ ﺷﻮﻧﺪ ‪:‬‬

‫اﻧـﻮاع اﻋﺸﺎري‬
‫ﺩﻗﺖ ﺍﻋﺸﺎﺭ‬ ‫ﻓﻀﺎ‬ ‫ﻣﺨﻔﻒ‬ ‫ﻧﻮﻉ‬
‫‪٨-٧‬‬ ‫‪ ٤‬ﺑﺎﻳﺖ‬ ‫‪Sgl‬‬ ‫‪Single‬‬
‫‪١٢-١١‬‬ ‫‪ ٦‬ﺑﺎﻳﺖ‬ ‫‪Rl‬‬ ‫‪Real‬‬
‫‪١٦-١٥‬‬ ‫‪ ٨‬ﺑﺎﻳﺖ‬ ‫‪Dbl‬‬ ‫‪Double‬‬
‫‪٢٠-١٩‬‬ ‫‪ ١٠‬ﺑﺎﻳﺖ‬ ‫‪Xtd‬‬ ‫‪Extended‬‬

‫ﻧﺤﻮﺓ ﻧﻤﺎﻳﺶ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﻱ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺑﻪ ﺩﻭ ﺻﻮﺭﺕ ﺍﺳﺖ‪:‬‬

‫‪ -١‬ﻣﻤﻴﺰ ﺛﺎﺑﺖ‪ :‬ﻣﺎﻧﻨﺪ ‪ 3.45‬ﻳﺎ ‪–58.301‬‬

‫‪1.23E1‬‬ ‫‪0.32E-1‬‬ ‫‪21.2E2‬‬ ‫‪ -٢‬ﻣﻤﻴﺰ ﺷﻨﺎﻭﺭ ﻳﺎ ﻧﻤﺎﺩ ﻋﻠﻤﻲ‪ :‬ﻣﺜﻞ ‪34E-1‬‬

‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ ﺗﻮﺍﻧﺪ ﺍﺯ ﺍﻧﻮﺍﻉ ﺍﻋﺸﺎﺭﻱ ﻭ ﺻﺤﻴﺢ ﻣﺨﺘﻠﻒ ﺩﺭ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮﻫﺎﻱ ﺧﻮﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﺪ‪.‬‬
‫ﻣﺘﻐﻴﺮﻫﺎﻳﻲ ﻛﻪ ﺍﺯ ﻧﻮﻉ ﺻﺤﻴﺢ ﻫﺴﺘﻨﺪ ﺩﺭ ﻣﺤﺎﺳﺒﺎﺕ ﺳﺮﻋﺘﺸﺎﻥ ﺍﺯ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﻱ ﺑﻴﺸﺘﺮ ﺍﺳﺖ‪ .‬ﻋﻼﻭﻩ ﺑﺮﺍﻳﻦ ﻧﻤﺎﻳﺶ ﺍﻋﺪﺍﺩ ﺍﻋـﺸﺎﺭﻱ ﻛـﺎﻣﻼ‬
‫‪8 = 7.999999999999‬‬ ‫ﺩﻗﻴﻖ ﻧﻴﺴﺖ‪.‬‬
‫ﻧﻜﺘﻪ‪ :‬ﺍﮔﺮ ﻣﺘﻐﻴﺮﻱ ﺭﺍ ﺍﺯﻧﻮﻉ ‪ Byte‬ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ ﺩﺭ ﺍﻳﻦ ﻣﺘﻐﻴﺮ ﻧﻤﻲ ﺗﻮﺍﻧﻴﻢ ﻋﺪﺩ ‪ 300‬ﺭﺍ ﻗﺮﺍﺭ ﺩﻫﻴﻢ‪ .‬ﭼﺮﺍ؟‬
‫ﺗﺤﻘﻴﻖ‪ :‬ﺍﮔﺮ ﺩﺭ ﻣﺘﻐﻴﺮﻱ ﺍﺯ ﻧﻮﻉ ‪ Integer‬ﻋﺪﺩ ‪ 32767‬ﺑﺎﺷﺪ ﻭ ﻳﻚ ﻭﺍﺣﺪ ﺑﻪ ﺁﻥ ﺍﺿﺎﻓﻪ ﻛﻨﻴﻢ ﭼـﻪ ﺍﺗﻔـﺎﻗﻲ ﻣـﻲ ﺍﻓﺘـﺪ ﻭ ﺩﺭ ﺁﻥ ﻣﺘﻐﻴـﺮ ﭼـﻪ‬
‫ﻋﺪﺩﻱ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ؟‬
‫• ﺭﻭﺵ ﻧﻤﺎﻳﺶ ﺍﻋﺪﺍﺩ ﺻﺤﻴﺢ ﻣﻨﻔﻲ ﺩﺭ ﺣﺎﻓﻈﻪ ﺑﻪ ﺻﻮﺭﺕ ﻣﻜﻤﻞ ﺩﻭ ﺍﺳﺖ‪.‬‬
‫• ﻋﺪﺩ ‪ 4‬ﻳﻚ ﻋﺪﺩ ﺻﺤﻴﺢ ﻣﺤﺴﻮﺏ ﻣﻲ ﺷﻮﺩ ﺍﻣﺎ ﻋﺪﺩ ‪ 4.0‬ﻳﻚ ﻋﺪﺩ ﺍﻋﺸﺎﺭﻱ ﺍﺳﺖ‪.‬‬
‫ﭘﺪﻳﺪﺓ ﺳﺮﺭﻳﺰﻱ‪:‬‬
‫ﺍﮔﺮ ﺳﻪ ﻣﺘﻐﻴﺮ ﺍﺯ ﻧﻮﻉ ‪ Integer‬ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ)‪ (A,B,C‬ﺁﻧﮕﺎﻩ ﻫﺮ ﻛﺪﺍﻡ ﺍﺯ ﻣﺘﻐﻴﺮﻫﺎ ﻣﻲ ﺗﻮﺍﻧﻨﺪ ﺣﺪﺍﻛﺜﺮ ﺗـﺎ ﻋـﺪﺩ ‪ ٣٢٧٦٧‬ﺭﺍ ﺩﺭ ﺧـﻮﺩ ﺫﺧﻴـﺮﻩ‬
‫ﻣﻲ ﻛﻨﻨﺪ‪.‬ﺍﮔﺮ ;‪ A:=32000‬ﻭ ;‪ B:=25000‬ﺑﺎﺷﺪ ﻭ ﺑﻨﻮﻳﺴﻴﻢ ;‪ C:=A+B‬ﺁﻧﮕﺎﻩ ﺩﺭ ‪ C‬ﭼﻪ ﻋﺪﺩﻱ ﺫﺧﻴﺮﻩ ﻣﻲ ﺷﻮﺩ؟ ﭼﻮﻥ ﺣﺎﺻـﻞ ﺟﻤـﻊ‬
‫‪ 57000‬ﻣﻲ ﺷﻮﺩ ﻭ ﺍﻳﻦ ﻋﺪﺩ ﺩﺭ ﻣﺘﻐﻴﺮ ‪ C‬ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﻗﺮﺍﺭ ﮔﻴﺮﺩ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﻗﺴﻤﺘﻲ ﺍﺯ ﺟﻮﺍﺏ ﺩﺭ ‪ C‬ﺫﺧﻴﺮﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﺍﻟﺒﺘﻪ ﭘﻴﻐـﺎﻡ ﺧﻄـﺎ‬
‫ﺭﺥ ﻧﻤﻲ ﺩﻫﺪ‪ .‬ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﻣﻤﻜﻦ ﺍﺳﺖ ﺩﺭ ﻣﺘﻐﻴﺮ ‪ C‬ﻳﻚ ﻋﺪﺩ ﻣﻨﻔﻲ ﺑﺎﺷﺪ! ﺑﻪ ﺍﻳﻦ ﭘﺪﻳﺪﻩ ﺳﺮﺭﻳﺰﻱ ﻣﻲ ﮔﻮﻳﻨﺪ‪ .‬ﺍﻳـﻦ ﭘﺪﻳـﺪﻩ ﻫﻨﮕـﺎﻣﻲ ﺭﺥ‬
‫ﻣﻲ ﺩﻫﺪ ﻛﻪ ﻧﺘﻴﺠﻪ ﻣﺤﺎﺳﺒﻪ ﺍﻱ ﺑﻴﺶ ﺍﺯ ﻇﺮﻓﻴﺖ ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﺑﺎﺷﺪ‪ .‬ﺑﺮﺍﻱ ﺟﻠﻮﮔﻴﺮﻱ ﺍﺯ ﺍﻳﻦ ﭘﺪﻳﺪﻩ ﭼﻪ ﺭﺍﻩ ﺣﻠﻲ ﭘﻴﺸﻨﻬﺎﺩ ﻣﻲ ﻛﻨﻴﺪ؟‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪12‬‬
‫‪ -2‬ﻧﻮع ﮐﺎراﮐﺘﺮ‪ :‬ﻓﻘﻂ ﻳﻚ ﻧﻮﻉ ﺍﺯ ﺍﻳﻦ ﺩﺍﺩﻩ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻭ ﺁﻥ ﻧﻮﻉ ‪ CHAR‬ﺍﺳﺖ ﻛﻪ ﻣﻲ ﺗﻮﺍﻧﺪ ﻳﻚ ﻛﺎﺭﺍﻛﺘﺮ ﺭﺍ ﺩﺭ ﺧﻮﺩ ﺟـﺎﻱ ﺩﻫـﺪ ﻭ‬
‫ﻳﻚ ﺑﺎﻳﺖ ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨﺪ‪.‬ﻣﺨﻔﻒ ﺁﻥ ‪ Chr‬ﺍﺳﺖ‪ .‬ﻳﻚ ﻛﺎﺭﺍﻛﺘﺮ ﻣﻲ ﺗﻮﺍﻧﺪ ﻣﺜﺎﻝ ﻫﺎﻱ ﺯﻳﺮ ﺑﺎﺷﺪ‪:‬‬
‫’‪’A‬‬ ‫’ ’ ’(’‬ ‫’ ‪’#‬‬ ‫’ ’’ ’‬ ‫’‪’5‬‬
‫ﻳﻚ ﻛﺎﺭﺍﻛﺘﺮ ﺑﻴﻦ ﺁﭘﺴﺘﺮﻭﻑ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ‪( ’) .‬‬
‫ﻧﻜﺘﻪ‪ :‬ﻫﺮ ﻛﺎﺭﺍﻛﺘﺮ ﺩﺍﺭﺍﻱ ﻳﻚ ﻛﺪ ﺍﺳﺖ ﻛﻪ ﺑﻪ ﺁﻥ ﻛﺪ ﺍﺳﻜﻲ ﺁﻥ ﻛﺎﺭﺍﻛﺘﺮ ﻣﻲ ﮔﻮﻳﻨﺪ‪ .‬ﻣﺜﻼ ﻛﺪ ﻛﺎﺭﺍﻛﺘﺮ ‪ A‬ﻋﺪﺩ ‪ 65‬ﺍﺳـﺖ ﻭ ﻛـﺪ ﻛـﺎﺭﺍﻛﺘﺮ ‪B‬‬
‫ﻋﺪﺩ ‪ 66‬ﺍﺳﺖ‪ .‬ﺍﻳﻦ ﺟﺪﻭﻝ ﺩﺭ ﺍﻧﺘﻬﺎﻱ ﻛﺘﺎﺏ ﭘﺎﺳﻜﺎﻝ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪ .‬ﺍﻳﻦ ﺟﺪﻭﻝ ﺩﺍﺭﺍﻱ ‪ ١٢٧‬ﻛﺎﺭﺍﻛﺘﺮ ﺑﺎ ﻛﺪﻫﺎﻱ ﺁﻧﻬﺎ ﺍﺳﺖ‪.‬‬
‫ﻧﻜﺘﻪ‪ :‬ﺑﻌﻀﻲ ﺍﺯ ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﻗﺎﺑﻞ ﻣﺸﺎﻫﺪﻩ ﻧﻴﺴﺘﺪ‪ .‬ﻛﺪﻫﺎﻱ ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 31‬ﻛﺪﻫﺎﻱ ﻛﻨﺘﺮﻟﻲ ﻫﺴﺘﻨﺪ ﻭ ﻣﺮﺑـﻮﻁ ﺑـﻪ ﻛﺎﺭﺍﻛﺘﺮﻫـﺎﻳﻲ ﻫـﺴﺘﻨﺪ ﻛـﻪ‬
‫ﻣﺸﺎﻫﺪﻩ ﻧﻤﻲ ﺷﻮﻧﺪ‪ .‬ﻣﺎﻧﻨﺪ ﻛﺪ ‪ 7‬ﻛﻪ ﻣﺮﺑﻮﻁ ﺑﻪ ﺻﺪﺍﻱ ﺑﻴﭗ ﺍﺳﺖ‪ .‬ﻛﺪ ‪ 10‬ﻣﺮﺑﻮﻁ ﺑﻪ ﻛﺎﺭﺍﻛﺘﺮﻱ ﺍﺳﺖ ﻛﻪ ﻣﻜﺎﻥ ﻧﻤﺎ ﻳﻚ ﺳﻄﺮ ﭘﺎﻳﻴﻦ ﻣـﻲ ﺭﻭﺩ‬
‫) ﻛﺎﺭﺍﻛﺘﺮ ‪ .(LF‬ﻛﺪ ‪ 13‬ﻧﻴﺰ ﻣﺮﺑﻮﻁ ﺑﻪ ﻛﺎﺭﺍﻛﺘﺮﻱ ﺍﺳﺖ ﻛﻪ ﻣﻜﺎﻥ ﻧﻤﺎ ﺑﻪ ﺍﺑﺘﺪﺍﻱ ﺳﻄﺮ ﻓﻌﻠﻲ ﻣﻲ ﺭﻭﺩ)ﻛﺎﺭﺍﻛﺘﺮ ‪.(CR‬‬
‫ﻧﻜﺘﻪ‪ :‬ﻣﻨﻈﻮﺭ ﺍﺯ ‪ #67‬ﻛﺎﺭﺍﻛﺘﺮﻱ ﺍﺳﺖ ﻛﻪ ﻛﺪ ﺁﻥ ‪ 67‬ﺍﺳﺖ) ﻫﻤﺎﻥ ﻛﺎﺭﺍﻛﺘﺮ ‪ C‬ﺍﺳﺖ(‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﺍﮔﺮ ﺑﻌـﺪ ﺍﺯ ﻋﻼﻣـﺖ ‪ #‬ﻳـﻚ ﻋـﺪﺩ ﺑﻨﻮﻳـﺴﻴﻢ‬
‫ﻣﻨﻈﻮﺭ ﻳﻚ ﻛﺎﺭﺍﻛﺘﺮ ﺍﺳﺖ ﻛﻪ ﻛﺪ ﺁﻥ ﺭﺍ ﻣﺸﺨﺺ ﻛﺮﺩﻩ ﺍﻳﻢ‪.‬‬

‫‪ -3‬ﻧﻮع رﺷﺘﻪ اﯾﯽ‪ :‬ﻧﻮﻉ ﺭﺷﺘﻪ ﺍﻳﻲ ﺑﺎ ﻧﺎﻡ ‪ String‬ﺷﻨﺎﺧﺘﻪ ﻣﻲ ﺷﻮﺩ ﻭ ﺩﺭ ﺁﻥ ﻣﻲ ﺗﻮﺍﻥ ﻳﻚ ﺭﺷﺘﻪ ﺍﺯ ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﺭﺍ ﻗﺮﺍﺭ ﺩﺍﺩ‪ .‬ﻣﺨﻔـﻒ‬
‫ﺁﻥ ‪ STR‬ﺍﺳﺖ‪ .‬ﻣﻘﺪﺍﺭ ﻓﻀﺎﻳﻲ ﻛﻪ ﺁﻥ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨﺪ ﺑﻪ ﻧﺤﻮﻩ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻳﻦ ﻧﻮﻉ ﺑﺴﺘﮕﻲ ﺩﺍﺭﺩ‪ .‬ﺩﺭ ﺍﺩﺍﻣﻪ ﺍﻳﻦ ﻣﻮﺿﻮﻉ ﺑﺤﺚ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫’‪’235‬‬ ‫ﺭﺷﺘﻪ ﺗﻬﻲ ’’‬ ‫ﺭﺷﺘﻪ ﻫﺎﻱ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺩﺭ ﺁﭘﺴﺘﺮﻭﻑ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﻧﺪ‪’ALIREZA’ .‬‬
‫ﺭﺷﺘﻪ ﺷﺎﻣﻞ ﻳﻚ ﻛﺎﺭﺍﻛﺘﺮ ﺑﻴﭗ ﻭ ﺭﺷﺘﻪ‪ALI‬‬ ‫’‪#7’ALI‬‬ ‫ﺭﺷﺘﻪ ﺷﺎﻣﻞ ‪AB‬‬ ‫‪#65#66‬‬
‫• ﺣﺪﺍﻛﺜﺮ ﻃﻮﻝ ﻳﻚ ﺭﺷﺘﻪ ﻣﻲ ﺗﻮﺍﻧﺪ ‪ ٢٥٥‬ﻛﺎﺭﺍﻛﺘﺮ ﺑﺎﺷﺪ‪.‬‬

‫‪ -4‬ﻧﻮع ﺑﻮﻟﯿﻦ‪ ( BOOLEAN) :‬ﺍﻳﻦ ﻧﻮﻉ ﺩﺍﺩﻩ ﺍﺯ ﻭﻳﮋﮔﻲ ﻫﺎﻱ ﻣﻬﻢ ﭘﺎﺳﻜﺎﻝ ﺍﺳـﺖ‪ .‬ﺩﺭ ﺍﻳـﻦ ﻧـﻮﻉ ﺩﺍﺩﻩ ﻓﻘـﻂ ﺩﻭ ﻣﻘـﺪﺍﺭ ‪ TRUE‬ﻭ‬
‫‪ FALSE‬ﻣﻲ ﺗﻮﺍﻧﺪ ﻗﺮﺍﺭ ﮔﻴﺮﺩ‪ .‬ﻳﻚ ﺑﺎﻳﺖ ﺩﺭ ﺣﺎﻓﻈﻪ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨﺪ ﻭ ﻣﺨﻔﻒ ﺁﻥ ‪ Bln‬ﺍﺳﺖ‪.‬‬

‫ﻣﺘﻐﯿـﺮﻫﺎ و ﺗﻌﺮﯾﻒ آﻧﻬﺎ‪ :‬ﻣﺘﻐﻴﺮ ﻣﻜﺎﻧﻲ ﺍﺯ ﺣﺎﻓﻈﻪ ﺍﺻﻠﻲ ﺍﺳﺖ ﻛﻪ ﻣﻘﺪﺍﺭﺵ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺩﺭ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﺩﺍﺩ‪.‬‬
‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺑﺎﻳﺪ ﻫﻤﻪ ﻣﺘﻐﻴﺮﻫﺎﻳﻲ ﻛﻪ ﺩﺭ ﻃﻮﻝ ﺑﺮﻧﺎﻣﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﺪ ﺭﺍ ﺩﺭ ﻗﺴﻤﺖ ﺗﻌﺎﺭﻳﻒ ﺗﻌﺮﻳﻒ ﻛﻨﺪ‪.‬ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮﻫﺎ ﺍﺑﺘـﺪﺍ ﻛﻠﻤـﺔ‬
‫ﺭﺯﺭﻭ ﺷﺪﺓ ‪ VAR‬ﺭﺍ ﺑﻨﻮﻳﺴﻴﺪ ﻭ ﺩﺭ ﺍﺩﺍﻣﻪ ﻣﺘﻐﻴﺮﻫﺎ ﻭ ﻧﻮﻉ ﺁﻧﻬﺎ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺑﻨﻮﻳﺴﻴﺪ‪.‬‬
‫‪VAR‬‬
‫; ﻧﻮﻉ ﻣﺘﻐﻴﺮ ‪ :‬ﻧﺎﻡ ﻣﺘﻐﻴﺮ‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪VAR‬‬
‫;‪A:INTEGER‬‬
‫;‪F,H:CHAR‬‬
‫;‪S:STRING‬‬ ‫;‪N:BOOLEAN‬‬
‫;‪D:Single‬‬ ‫;]‪K:STRING[15‬‬
‫ﻧﻜﺘﻪ‪ :‬ﺩﺭ ﻣﺜﺎﻝ ﺑﺎﻻ ﭼﻨﺪ ﺑﺎﻳﺖ ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﺷﺪﻩ ﺍﺳﺖ؟‬

‫ﺩﺭ ﻣﺜﺎﻝ ﺑﺎﻻ ﻣﺘﻐﻴﺮ ‪ S‬ﺍﺯ ﻧﻮﻉ ﺭﺷﺘﻪ ﺍﻱ ﺍﺳﺖ ﺍﻣﺎ ﻃﻮﻝ ﺭﺷﺘﻪ ﻣﺸﺨﺺ ﻧﺸﺪﻩ ﺍﺳﺖ‪ .‬ﺍﮔﺮ ﻃﻮﻝ ﺭﺷﺘﻪ ﻣﺸﺨﺺ ﻧﺸﻮﺩ‪ ،‬ﺑﻄﻮﺭ ﭘـﻴﺶ ﻓـﺮﺽ ﻃـﻮﻝ‬
‫ﺭﺷﺘﻪ ‪ ٢٥٥‬ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮﺩ ﻭ ﺍﻳﻦ ﻣﺘﻐﻴﺮ ‪ ٢٥٦‬ﺑﺎﻳﺖ ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨﺪ‪ .‬ﻣﺘﻐﻴﺮ ‪ K‬ﻃﻮﻝ ﺁﻥ ‪ ١٥‬ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﺩﺭ ﺍﻳـﻦ‬
‫ﻣﺘﻐﻴﺮ ﻣﻲ ﺗﻮﺍﻥ ﻳﻚ ﺭﺷﺘﻪ ﺑﺎ ﻃﻮﻝ ‪ ١٥‬ﺭﺍ ﻗﺮﺍﺭ ﺩﺍﺩ‪ .‬ﺍﻳﻦ ﻣﺘﻐﻴﺮ ‪ ١٦‬ﺑﺎﻳﺖ ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨﺪ‪ .‬ﻫﻤﻴﺸﻪ ﺭﺷﺘﻪ ﻫﺎ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﻳﻚ ﺑﺎﻳﺖ ﺑﻴﺸﺘﺮ‬
‫ﺍﺯ ﻃﻮﻝ ﺭﺷﺘﻪ‪ ،‬ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨﻨﺪ‪.‬‬
‫ﺗﻌﺪاد ﺑﺎﯾﺖ ﻓﻀﺎي اﺷﻐﺎﻟﯽ ﯾﮏ رﺷﺘﻪ= ﻃﻮل رﺷﺘﻪ ‪1+‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪13‬‬
‫;’‪K:=’ALIREZA‬‬
‫‪#7‬‬ ‫‪A‬‬ ‫‪L‬‬ ‫‪I‬‬ ‫‪R‬‬ ‫‪E‬‬ ‫‪Z‬‬ ‫‪A‬‬
‫ﻧﻜﺘﻪ‪ :‬ﺍﮔﺮ ﺩﺭ ﻣﺘﻐﻴﺮ ‪ K‬ﻳﻚ ﺭﺷﺘﻪ ﺑﺎ ﻃﻮﻝ ﺑﻴﺸﺘﺮ ﺍﺯ ‪١٥‬ﻛﺎﺭﺍﻛﺘﺮ ﻗﺮﺍﺭ ﺩﻫﻴﻢ ﻫﻴﭻ ﺧﻄﺎﻳﻲ ﺭﺥ ﻧﻤﻲ ﺩﻫﺪ ﺑﻠﻜﻪ ﺍﺿﺎﻓﻪ ﺁﻥ ﺩﺭ ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻧﻤـﻲ‬
‫ﺷﻮﺩ‪.‬‬
‫;’‪K:=’ABCDEFGHIJKLMNPQRSXY‬‬

‫ﻧﻜﺘﻪ‪ :‬ﻧﺎﻡ ﮔﺬﺍﺭﻱ ﻣﺘﻐﻴﺮﻫﺎ ﺑﺎﻳﺪ ﺍﺯ ﻗﻮﺍﻧﻴﻦ ﻧﺎﻡ ﮔﺬﺍﺭﻱ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻏﻴﺮ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﭘﻴﺮﻭﻱ ﻛﻨﺪ‪.‬‬
‫‪ Z21‬ﻭ ‪ FOR_IF‬ﻭ ‪ INT‬ﻭ …‬ ‫‪ AB‬ﻭ‬ ‫ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﺭﻭﺑﺮﻭ ﻣﺠﺎﺯ ﻫﺴﺘﻨﺪ‪:‬‬
‫ﻭ ‪ FOR‬ﻭ ‪ #A‬ﻭ *‪ G‬ﻭ …‬ ‫‪END‬‬ ‫ﻭ‬ ‫‪4B‬‬ ‫ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﺭﻭﺑﺮﻭ ﻏﻴﺮ ﻣﺠﺎﺯﻧﺪ‪:‬‬

‫ﻧﻜﺘﻪ‪ :‬ﻧﻤﻲ ﺗﻮﺍﻥ ﺩﻭ ﻣﺘﻐﻴﺮ ﻫﻢ ﻧﺎﻡ ﺩﺍﺷﺖ‪ ،‬ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﺻﺎﺩﺭ ﻣﻲ ﺷﻮﺩ‪ .‬ﺑﻄﻮﺭ ﻛﻠﻲ ﻧﻤﻲ ﺗﻮﺍﻥ ﺩﻭ ﺷﻨﺎﺳﻪ ﻏﻴﺮﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﻫﻢ ﻧﺎﻡ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺩﺍﺷﺘﻪ‬
‫;‪Program H‬‬ ‫ﺑﺎﺷﻴﻢ‪.‬‬
‫‪VAR‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﺩﺍﺭﺍﻱ ﺩﻭ ﺧﻄﺎ ﺍﺳﺖ‪.‬‬
‫;‪A,B,H:Real‬‬ ‫ﻧﻜﺘﻪ‪ :‬ﺩﺭ ﺗﻮﺭﺑﻮﭘﺎﺳﻜﺎﻝ ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﻳﻚ ﻣﺘﻐﻴﺮ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﺩ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﺩﺍﺧﻞ ﺁﻥ ﺍﮔﺮ ﻋﺪﺩﻱ‬
‫;‪B,M:Boolean‬‬
‫ﺑﺎﺷﺪ ﺻﻔﺮ ﺍﺳﺖ ﻭ ﺍﮔﺮ ﺭﺷﺘﻪ ﺍﻳﻲ ﺑﺎﺷﺪ ﺗﻬﻲ ﺍﺳﺖ‪.‬‬
‫ﺛﺎﺑﺘـﻬﺎ و ﺗﻌﺮﯾﻒ آﻧﻬﺎ‪:‬‬
‫ﺍﺯ ﺛﺎﺑﺘﻬﺎ ﻣﻌﻤﻮﻻ ﺑﺮﺍﻱ ﺑﺎﻻ ﺑﺮﺩﻥ ﺧﻮﺍﻧﺎﻳﻲ ﺑﺮﻧﺎﻣﻪ ﻭ ﺳﺎﺩﮔﻲ ﺩﺭ ﻭﻳﺮﺍﻳﺶ ﻣﻘﺎﺩﻳﺮ ﺛﺎﺑﺖ ﺑﺮﻧﺎﻣﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﺛﺎﺑﺘﻬﺎ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺑﻪ ﺩﻭ ﺩﺳﺘﻪ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ‪:‬‬
‫‪ -2‬ﺛﺎﺑﺖ ﻧـﻮع دار )ﺑﺎ ﻧﻮع(‬ ‫‪ -1‬ﺛﺎﺑﺖ ﺑـﺪون ﻧﻮع‬

‫‪ -1‬ﺛﺎﺑﺖ ﺑﺪون ﻧﻮع‪ :‬ﺍﻳﻦ ﻧﻮﻉ ﺛﺎﺑﺖ ﻣﻘﺪﺍﺭﺵ ﺩﺭ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺗﻐﻴﻴﺮ ﻛﻨﺪ‪ .‬ﺑﺮﺍﻱ ﺗﻌﺮﻳـﻒ ﺛﺎﺑﺘﻬـﺎ ﺍﺯ ﻛﻠﻤـﻪ ﺭﺯﺭﻭ ﺷـﺪﻩ‬
‫‪ Const‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﻣﺜﺎﻝ‪:‬‬
‫‪Const‬‬ ‫;‪F=14‬‬
‫;’‪P=’AMIN‬‬

‫;‪Program MB‬‬ ‫ﺗﺤﻘﻴﻖ‪ :‬ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻨﺪ ﺧﻄﺎ ﺩﺍﺭﺩ؟‬

‫‪Var‬‬
‫;‪Z=Byte‬‬
‫‪Const‬‬
‫;‪MB=2.4E-1‬‬
‫‪Begin‬‬
‫;‪Z:=-12‬‬
‫;‪MB:=MB+3‬‬
‫‪End.‬‬

‫‪ -2‬ﺛﺎﺑﺖ ﻧـﻮع دار‪ :‬ﺍﻳﻦ ﻧﻮﻉ ﺛﺎﺑﺖ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﻧﻮﻋﻲ ﻣﺘﻐﻴﺮ ﻓﺮﺽ ﻛﺮﺩ‪ .‬ﻳﻌﻨﻲ ﻣﻲ ﺗﻮﺍﻥ ﻣﻘﺪﺍﺭ ﺁﻥ ﺭﺍ ﺩﺭ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﺩﺍﺩ‪ .‬ﺑﻪ‬
‫ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ ﺛﺎﺑﺖ ﻧﻮﻉ ﺩﺍﺭ ﻣﺘﻐﻴﺮﻱ ﺍﺳﺖ ﻛﻪ ﻣﻘﺪﺍﺭﺩﻫﻲ ﺍﻭﻟﻴﻪ ﻣﻲ ﺷﻮﺩ‪ .‬ﻣﺜﺎﻝ‪:‬‬
‫‪Const‬‬
‫;‪R:integer =12‬‬
‫;‪T=25.7‬‬
‫ﺩﺭ ﻣﺜﺎﻝ ﺑﺎﻻ ‪ R‬ﻳﻚ ﺛﺎﺑﺖ ﻧﻮﻉ ﺩﺍﺭ )ﺍﺯ ﻧﻮﻉ ﺻﺤﻴﺢ( ﺍﺳﺖ ﺍﻣﺎ ‪ T‬ﻳﻚ ﺛﺎﺑﺖ ﺑﺪﻭﻥ ﻧﻮﻉ ﺍﺳﺖ‪ .‬ﻣﻘﺪﺍﺭ ‪ R‬ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺩﺭ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴـﺮ‬
‫ﺩﺍﺩ ﺍﻣﺎ ﻣﻘﺪﺍﺭ ‪ T‬ﺭﺍ ﻧﻤﻲ ﺗﻮﺍﻥ ﺗﻐﻴﻴﺮ ﺩﺍﺩ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪14‬‬
‫ﻣﺜﺎﻝ ‪:‬‬
‫‪Const‬‬
‫;‪A=2+3‬‬
‫;‪W:Boolean=False‬‬
‫;‪H=A*2‬‬
‫;‪P:Integer=3‬‬
‫‪Var‬‬
‫;‪T:Shortint‬‬
‫‪Begin‬‬
‫;)‪Write(A , H, W,P‬‬
‫;‪P:=15‬‬ ‫;‪T:=4‬‬
‫;‪P:=P+T‬‬ ‫;‪W:=12>8‬‬
‫;)‪Write(P‬‬
‫‪End.‬‬
‫ﻧﻜﺘﻪ‪ :‬ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ; )ﺳﻴﻤﻴﻜﻠﻮﻥ( ﺟﺪﺍ ﻛﻨﻨﺪﺓ ﺩﺳﺘﻮﺭﺍﺕ ﺍﺯ ﻳﻜﺪﻳﮕﺮ ﺍﺳﺖ‪.‬‬

‫ﻋﻼﻣﺖ =‪) :‬اﻧﺘﺴﺎب(‬

‫ﺍﺯ ﺍﻳﻦ ﻋﻼﻣﺖ ﺟﻬﺖ ﻗﺮﺍﺭ ﺩﺍﺩﻥ ﻳﻚ ﻋﺒﺎﺭﺕ ﺩﺭ ﻳﻚ ﻣﺘﻐﻴﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫; ﻋﺒـﺎرت =‪ :‬ﻣﺘﻐﯿﺮ‬
‫ﻧﻜﺘﻪ‪ :‬ﻋﺒﺎﺭﺕ ﺑﺎﻳﺪ ﺑﺎ ﻧﻮﻉ ﻣﺘﻐﻴﺮ ﻫﻤﺨﻮﺍﻧﻲ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﻣﺜﻼ ﺍﮔﺮ ﻋﺒﺎﺭﺕ ﺍﺯ ﻧﻮﻉ ﺑﻮﻟﻲ ﺍﺳﺖ ﺑﺎﻳﺪ ﻣﺘﻐﻴﺮ ﻧﻴﺰ ﺍﺯ ﻧﻮﻉ ﺑﻮﻟﻴﻦ ﺑﺎﺷﺪ‪.‬‬
‫ﻧﻜﺘﻪ‪ :‬ﻳﻚ ﻋﺒﺎﺭﺕ ﻛﻪ ﺣﺎﺻﻞ ﺁﻥ ﻋﺪﺩ ﺻـﺤﻴﺢ ﻣـﻲ ﺷـﻮﺩ ﺭﺍ ﻣـﻲ ﺗـﻮﺍﻥ ﺩﺭ ﻳـﻚ ﻣﺘﻐﻴـﺮ ﺍﻋـﺸﺎﺭﻱ ﺭﻳﺨـﺖ ﺍﻣـﺎ ﻋﻜـﺲ ﺁﻥ ﺻـﺤﻴﺢ ﻧﻴـﺴﺖ‪.‬‬
‫;‪ A ) A:=25+4‬ﻣﻲ ﺗﻮﺍﻧﺪ ﺻﺤﻴﺢ ﻳﺎ ﺍﻋﺸﺎﺭﻱ ﺑﺎﺷﺪ(‪.‬‬
‫ﺩﺭﺻﻮﺭﺗﻲ ﻛﻪ ﻧﻮﻉ ﻣﺘﻐﻴﺮ ﺑﺎ ﻧﻮﻉ ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﻳﻜﻲ ﻧﺒﺎﺷﺪ ﺩﺭ ﺯﻣﺎﻥ ﺗﺮﺟﻤﻪ ﭘﻴﻐﺎﻡ ﺧﻄﺎﻱ ‪Type Mismatch‬ﺻﺎﺩﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ ( ﺍﺯ ﻋﻼﻣﺖ ﺍﻧﺘﺴﺎﺏ ﻓﻘﻂ ﺩﺭ ﻗﺴﻤﺖ ﺩﺳﺘﻮﺭﺍﺕ )ﺑﺪﻧﻪ ﺑﺮﻧﺎﻣﻪ(ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬‬

‫اﻧﻮاع ﻋﺒـﺎرات در زﺑﺎن ﭘﺎﺳﮑﺎل‪:‬‬

‫ﻳﻚ ﻋﺒﺎﺭﺕ ﻣﺠﻤﻮﻋﻪ ﺍﻱ ﺍﺯ ﻋﻤﻠﮕﺮﻫﺎ ﻭ ﻋﻤﻠﻮﻧﺪﻫﺎ ﺍﺳﺖ ﻣﺜﻞ ‪ A+2*B‬ﻳﺎ ‪A/3 > 5‬‬

‫‪ - ١‬ﻋﺒﺎﺭﺍﺕ ﺭﻳﺎﺿﻲ ‪ :‬ﺣﺎﺻﻞ ﺍﻳﻦ ﻋﺒﺎﺭﺍﺕ ﻳﻚ ﻋﺪﺩ ﺻﺤﻴﺢ ﻳﺎ ﺍﻋﺸﺎﺭﻱ ﺧﻮﺍﻫﺪ ﺷﺪ‪ .‬ﻣﺜﻞ ‪B*8+2 And 12‬‬

‫‪ - ٢‬ﻋﺒﺎﺭﺍﺕ ﺭﺷﺘﻪ ﺍﻱ ‪ :‬ﺭﺷﺘﻪ ﻫﺎ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺩﺍﺧﻞ ﺩﻭ ﻋﻼﻣﺖ ﺁﭘﺴﺘﺮﻭﻑ )’( ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﻧﺪ‪ .‬ﻣﺜﻞ ’‪’ALI‬‬
‫ﺣﺎﺻﻞ ﺍﻳﻦ ﻋﺒﺎﺭﺍﺕ ﻧﻴﺰ ﻳﻚ ﺭﺷﺘﻪ ﺧﻮﺍﻫﺪ ﺷﺪ ﻣﺜﻞ ’‪’Ali’+’Reza’=’AliReza‬‬
‫ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﻃﻮﻝ ﻳﻚ ﺭﺷﺘﻪ ﺣﺪﺍﻛﺜﺮ ‪ ٢٥٥‬ﻛﺎﺭﺍﻛﺘﺮ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬

‫‪ - ٣‬ﻋﺒﺎﺭﺍﺕ ﺑﻮﻟﻲ ‪ :‬ﺣﺎﺻﻞ ﺍﻳﻦ ﻋﺒﺎﺭﺍﺕ ﻣﻲ ﺗﻮﺍﻧﺪ ‪ True‬ﻳﺎ ‪ False‬ﺑﺎﺷﺪ‪ .‬ﻣﺎﻧﻨﺪ )‪(5 > 8) OR (9>4‬‬

‫ﻋﺒﺎﺭﺍﺕ ﺳﺎﺩﻩ ‪ :‬ﺑﻪ ﻋﺒﺎﺭﺍﺗﻲ ﻛﻪ ﺩﺭ ﺁﻥ ﺗﻌﺪﺍﺩﻱ ﻋﻤﻠﮕﺮ ﺍﺯ ﻳﻚ ﻧﻮﻉ ﺑﻪ ﻛﺎﺭ ﺭﻭﺩ ﻋﺒﺎﺭﺕ ﺳﺎﺩﻩ ﻣﻲ ﮔﻮﻳﻨﺪ‪A*2+4-8/2 .‬‬
‫ﻋﺒﺎﺭﺍﺕ ﻣﺮﻛﺐ ‪ :‬ﻋﺒﺎﺭﺗﻲ ﺍﺳﺖ ﻛﻪ ﻋﻤﻠﮕﺮﻫﺎﻱ ﺑﻪ ﻛﺎﺭ ﺭﻓﺘﻪ ﺩﺭﺁﻥ ﺑﻴﺶ ﺍﺯ ﻳﻚ ﻧﻮﻉ ﺑﺎﺷﺪ‪A+5 > 8 AND 4 .‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪15‬‬
‫ﺟﺪول ﺗﻘـﺪم ﻋﻤﻠﮕﺮﻫﺎ ‪:‬‬
‫) (‬
‫‪NOT ±‬‬
‫‪* / DIV‬‬ ‫‪MOD AND SHL SHR‬‬
‫‪+‬‬ ‫‪-‬‬ ‫‪OR XOR‬‬
‫< > =‬ ‫><‬ ‫=>‬ ‫=<‬
‫ﻧﻜﺘﻪ‪ :‬ﺗﻘﺪﻡ ﻫﺎ ﺍﺯ ﺑﺎﻻ ﺑﺎ ﭘﺎﻳﻴﻦ ﺍﺳﺖ‪.‬‬
‫ﻧﻜﺘﻪ‪ :‬ﻋﻤﻠﮕﺮﻫﺎﻳﻲ ﻛﻪ ﺩﺍﺭﺍﻱ ﺗﻘﺪﻡ ﻳﻜﺴﺎﻧﻲ ﻫﺴﻨﺘﺪ‪ ،‬ﻋﻤﻠﮕﺮﻱ ﻛﻪ ﺳﻤﺖ ﭼﭗ ﺗﺮ)ﺩﺭ ﻋﺒﺎﺭﺕ( ﺍﺳﺖ ﻣﻘﺪﻡ ﺗﺮ ﺍﺳﺖ‪.‬‬
‫ﻧﻜﺘﻪ‪ :‬ﭘﺮﺍﻧﺘﺰﻫﺎ ﺗﻘﺪﻡ ﻋﻤﻠﮕﺮﻫﺎ ﺭﺍ ﺗﻐﻴﻴﺮ ﻣﻲ ﺩﻫﻨﺪ‪.‬‬

‫اﻧـﻮاع ﻋﻤﻠﮕﺮﻫﺎ در زﺑﺎن ﭘﺎﺳﮑﺎل ‪:‬‬

‫‪-+‬‬ ‫‪DIV‬‬ ‫‪MOD‬‬ ‫‪/‬‬ ‫*‬ ‫‪-+‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎي رﯾﺎﺿﯽ ‪:‬‬

‫ﻧﻜﺘﻪ‪ :‬ﺣﺎﺻﻞ ﻋﻤﻠﮕﺮﻫﺎﻱ ﺟﻤﻊ ﻭ ﺗﻔﺮﻳﻖ)‪ +‬ﻭ‪ (-‬ﻭ ﺿﺮﺏ ﺑﺴﺘﮕﻲ ﺑﻪ ﻋﻤﻠﻮﻧﺪﻫﺎ ﺩﺍﺭﺩ‪.‬‬
‫‪12+3=15‬‬ ‫‪12.5+1.5=14.0‬‬ ‫‪2.5*2=5.0‬‬ ‫‪3*6=18‬‬ ‫‪15.8-2.8=13.0‬‬

‫ﻧﻜﺘﻪ‪ :‬ﺣﺎﺻﻞ ﻋﻤﻠﮕﺮ ﺗﻘﺴﻴﻢ) ‪ ( /‬ﻫﻤﻴﺸﻪ ﻳﻚ ﻋﺪﺩ ﺍﻋﺸﺎﺭﻱ ﺍﺳﺖ‪.‬‬

‫‪20/5=4.0‬‬ ‫‪12/5=2.4‬‬

‫ﻧﻜﺘﻪ‪ :‬ﻋﻤﻠﻮﻧﺪﻫﺎﻱ ﻣﺮﺑﻮﻁ ﺑﻪ ‪ DIV‬ﻭ ‪ MOD‬ﺑﺎﻳﺪ ﺍﺯ ﻧﻮﻉ ﻋﺪﺩ ﺻﺤﻴﺢ ﺑﺎﺷﻨﺪ ﻭ ﺣﺎﺻﻞ ﺁﻥ ﻧﻴﺰ ﻳﻚ ﻋﺪﺩ ﺻﺤﻴﺢ ﺍﺳﺖ‪.‬‬
‫ﺧﻄﺎ ﺩﺍﺭﺩ‪.‬‬ ‫‪15 Mod 3.5‬‬
‫‪24 mod 3 = 0‬‬ ‫‪25 div -3 = -8‬‬
‫‪24 Div 3 = 8‬‬ ‫‪-25 div -3 = 8‬‬
‫‪25 mod -3 = 1‬‬ ‫‪7 mod 14 =7‬‬
‫‪-25 mod -3 = -1‬‬ ‫‪7 div 14 = 0‬‬
‫ﻧﻜﺘﻪ‪ :‬ﻋﻼﻣﺖ ﺣﺎﺻﻞ ﻋﻤﻠﮕﺮ ‪ Mod‬ﺑﻪ ﻋﻼﻣﺖ ﻋﻤﻠﻮﻧﺪ ﺍﻭﻝ ﺑﺴﺘﮕﻲ ﺩﺍﺭﺩ‪.‬‬
‫ﻧﻜﺘﻪ‪ Mod :‬ﻭ ‪ Div‬ﻛﻠﻤﺎﺕ ﺭﺯﺭﻭ ﺷﺪﻩ ﻫﺴﺘﻨﺪ‪.‬‬
‫‪4+35 mod 2 *12 –(6-2) /4‬‬ ‫ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﺭﻭﺑﺮﻭ ﭼﻨﺪ ﺍﺳﺖ؟‬

‫‪SHR SHL‬‬ ‫‪XOR‬‬ ‫‪OR‬‬ ‫‪AND‬‬ ‫‪Not‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎي ﻣﻨﻄﻘـﯽ‪:‬‬

‫ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ ﻋﻤﻠﻴﺎﺕ ﻫﺎﻱ ﺧﻮﺩ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﺑﻴﺖ ﺑﻪ ﺑﻴﺖ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﻨﺪ‪ .‬ﺣﺎﺻﻞ ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ ﻳﻚ ﻋﺪﺩ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬
‫ﺟﺪﻭﻝ ﻣﺮﺑﻮﻁ ﺑﻪ ﻋﻤﻠﮕﺮﻫﺎ‪:‬‬

‫‪X‬‬ ‫‪Y‬‬ ‫‪X OR Y‬‬ ‫‪X‬‬ ‫‪Y X AND Y‬‬ ‫‪X‬‬ ‫‪Y‬‬ ‫‪X Xor Y‬‬ ‫‪X‬‬ ‫‪Not X‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪ OR‬ﺷﺒﻴﻪ ﺟﻤﻊ ﺍﺳﺖ‪.‬‬ ‫‪ And‬ﻣﺎﻧﻨﺪ ﺿﺮﺏ ﺍﺳﺖ‪.‬‬ ‫ﺩﻭﻋﻤﻠﻮﻧﺪﻫﻢ ﺍﺭﺯﺵ‪ ،‬ﺣﺎﺻﻞ ﺻﻔﺮ ﺍﺳﺖ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪16‬‬
‫ﻧﻜﺘﻪ‪ :‬ﺍﻳﻦ ﺟﺪﺍﻭﻝ ﺑﺮﺍﻱ ﻋﻤﻠﮕﺮﻫﺎﻱ ﺑﻮﻟﻲ ﻧﻴﺰ ﺑﻪ ﻫﻤﻴﻦ ﺻﻮﺭﺕ ﺍﺳﺖ ﺑﺎ ﺍﻳﻦ ﺗﻔﺎﻭﺕ ﻛﻪ ﺑﺠﺎﻱ ‪ 0‬ﻋﺒﺎﺭﺕ ‪ False‬ﻭ ﺑﺠﺎﻱ ‪ 1‬ﻋﺒﺎﺭﺕ ‪ True‬ﺭﺍ‬
‫ﺑﻪ ﻛﺎﺭ ﻣﻲ ﺑﺮﻳﻢ‪.‬‬
‫ﻧﻜﺘﻪ‪ :‬ﺣﺎﺻﻞ ﻋﻤﻠﮕﺮ ‪) Xor‬ﻳﺎﻱ ﺍﻧﺤﺼﺎﺭﻱ( ﻫﻨﮕﺎﻣﻲ ‪ False‬ﺍﺳﺖ )ﺻﻔﺮ ﺍﺳﺖ( ﻛﻪ ﻫﺮ ﺩﻭ ﻋﻤﻠﻮﻧﺪ ﺁﻥ ﻳﻜﺴﺎﻥ ﺑﺎﺷﻨﺪ‪ .‬ﻳﺎ ﺑﻪ ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ‬
‫ﻫﻨﮕﺎﻣﻲ ‪ True‬ﺍﺳﺖ )ﻳﻚ ﺍﺳﺖ( ﻛﻪ ﺩﻭ ﻋﻤﻠﻮﻧﺪ ﺁﻥ ﻳﻜﺴﺎﻥ ﻧﺒﺎﺷﻨﺪ‪.‬‬
‫‪16 AND 27 = 16‬‬ ‫ﻣﺜﺎﻝ‪:‬‬
‫‪00010000‬‬
‫‪27=(00011011)2‬‬ ‫‪16= (00010000)2‬‬
‫‪00011011‬‬
‫‪00010000 = 16‬‬
‫‪19‬‬ ‫‪XOR 35=48‬‬ ‫ﻣﺜﺎﻝ‪:‬‬
‫‪00010011‬‬ ‫‪35=(00100011)2‬‬ ‫‪19=(00010011)2‬‬
‫‪00100011‬‬
‫‪00110000‬‬ ‫‪=48‬‬
‫‪14 Xor 25 And Not 21 =6‬‬ ‫ﻣﺜﺎﻝ‪:‬‬
‫‪14=(00001110)2‬‬ ‫‪25=(00011001)2‬‬ ‫‪Not 21 =(11101010)2‬‬ ‫‪21=(00010101)2‬‬
‫‪14 XOR (00001000)2=(00000110)2 =6‬‬ ‫‪25‬‬ ‫‪And‬‬ ‫‪(11101010) =(00001000)2‬‬
‫ﻧﻜﺘﻪ‪ :‬ﻫﻤﻴﺸﻪ ﺍﻋﺪﺍﺩ ﺭﺍ ﻭﻗﺘﻲ ﺑﻪ ﻣﺒﻨﺎﻱ ﺩﻭ ﻣﻲ ﺑﺮﻳﺪ ﺁﻧﻬﺎ ﺭﺍ ﻫﺸﺖ ﺭﻗﻤﻲ ﻳﺎ ‪ ١٦‬ﺭﻗﻤﻲ ﻛﻨﻴﺪ‪.‬‬
‫ﻧﻜﺘﻪ ‪ :‬ﺍﮔﺮ ﻳﻚ ﻋﺪﺩ ﻓﺮﺩ ﺭﺍ ﺑﻪ ﻣﺒﻨﺎﻱ ﺩﻭ ﺑﺒﺮﻳﻢ ﺍﻭﻟﻴﻦ ﺭﻗﻢ ﺁﻥ ﺍﺯ ﺳﻤﺖ ﺭﺍﺳﺖ ﻳﻚ ﺧﻮﺍﻫﺪ ﺑﻮﺩ ﻭ ﺍﮔﺮ ﻳﻚ ﻋﺪﺩ ﺯﻭﺝ ﺭﺍ ﺑﻪ ﻣﺒﻨﺎﻱ ﺩﻭ ﺑﺒﺮﻳﻢ‬
‫ﺍﻭﻟﻴﻦ ﺭﻗﻢ ﺍﻥ ﺍﺯ ﺳﻤﺖ ﺭﺍﺳﺖ ﺻﻔﺮ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬
‫‪27=(11011)2‬‬ ‫‪14=(1110)2‬‬

‫ﺳﺌﻮﺍﻝ‪ :‬ﺍﮔﺮ ﺩﻭ ﻋﺪﺩ ﻓﺮﺩ ﺭﺍ ﺑﺎﻫﻢ ‪ OR‬ﻛﻨﻴﻢ ﺣﺎﺻﻞ ﻓﺮﺩ ﺍﺳﺖ ﻳﺎ ﺯﻭﺝ؟‬
‫ﺟﻮﺍﺏ ‪ :‬ﭼﻮﻥ ﻫﺮ ﺩﻭ ﻋﺪﺩ ﻓﺮﺩ ﺑﻮﺩﻩ ﺍﻧﺪﺑﻨﺎﺑﺮﺍﻳﻦ ﺭﻗﻢ ﻛﻢ ﺍﺭﺯﺵ ﺁﻧﻬﺎ ﻳﻚ ﺑﻮﺩﻩ ﺍﺳﺖ ﻛﻪ ﻭﻗﺘﻲ ﺑﺎﻫﻢ ‪ OR‬ﻣﻲ ﺷﻮﻧﺪ ﺣﺎﺻـﻞ ﻳـﻚ ﺧﻮﺍﻫـﺪ ﺷـﺪ‬
‫ﭘﺲ ﺣﺎﺻﻞ ﻓﺮﺩ ﺍﺳﺖ‪.‬‬
‫ﺳﺌﻮﺍﻝ‪ :‬ﺍﮔﺮ ﺩﻭﻋﺪﺩ ﻓﺮﺩ ﺭﺍ ﺑﺎﻫﻢ ‪ Xor‬ﻛﻨﻴﻢ ﺣﺎﺻﻞ ﺯﻭﺝ ﺍﺳﺖ ﻳﺎ ﻓﺮﺩ؟‬
‫ﺳﺌﻮﺍﻝ‪ :‬ﺍﮔﺮ ﻳﻚ ﻋﺪﺩ ﻓﺮﺩ ﺭﺍ ‪ NOT‬ﻛﻨﻴﻢ ﺣﺎﺻﻞ ﻓﺮﺩ ﺍﺳﺖ ﻳﺎ ﺯﻭﺝ؟‬
‫ﺳﺌﻮﺍﻝ‪ :‬ﺍﮔﺮ ﻳﻚ ﻋﺪﺩ ﻓﺮﺩ ﻭ ﻳﻚ ﻋﺪﺩ ﺯﻭﺝ ﺭﺍ ﺑﺎﻫﻢ ‪ AND‬ﻛﻨﻴﻢ ﺣﺎﺻﻞ ﺯﻭﺝ ﺍﺳﺖ ﻳﺎ ﻓﺮﺩ؟‬
‫ﺳﺌﻮﺍﻝ‪ :‬ﺍﮔﺮ ﻳﻚ ﻋﺪﺩ ﻓﺮﺩ ﺭﺍ ﺑﺎ ﻳﻚ ﻋﺪﺩ ﺯﻭﺝ ﺑﺎﻫﻢ ‪ Xor‬ﻛﻨﻴﻢ ﺣﺎﺻﻞ ﺯﻭﺝ ﺍﺳﺖ ﻳﺎ ﻓﺮﺩ؟‬

‫ﻣﺜﺎﻝ‪2*6 OR 12 = :‬‬
‫ﺍﺑﺘﺪﺍ * ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﺳﭙﺲ ﺣﺎﺻﻞ ﺑﺎ ‪ OR ، 12‬ﻣﻲ ﺷﻮﺩ‪12 OR 12 =12 .‬‬
‫‪X Or X =X‬‬ ‫ﻧﻜﺘﻪ‪ :‬ﻫﺮ ﻋﺪﺩﻱ ﺑﺎ ﺧﻮﺩﺵ ‪ OR‬ﻳﺎ ‪ AND‬ﺷﻮﺩ ﺣﺎﺻﻞ ﺧﻮﺩﺵ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪X And‬‬ ‫‪X=X‬‬

‫‪X XOR 0 =X‬‬ ‫ﺑﻪ ﺭﻭﺍﺑﻂ ﺯﻳﺮ ﺩﻗﺖ ﻛﻨﻴﺪ ﻭ ﺑﺮﺍﻱ ﺁﻧﻬﺎ ﺩﻟﻴﻞ ﺑﻴﺎﻭﺭﻳﺪ‪.‬‬
‫‪Not ( Not (X))=X‬‬
‫‪X OR NOT X= 255‬‬
‫‪X AND NOT X = 0‬‬
‫‪X XOR X =0‬‬
‫‪0≤X ≤ 255‬‬ ‫‪==è Not( X) = 255 –X‬‬ ‫‪NOT(0)=255-0=255‬‬
‫‪NOT(1)=255-1=254‬‬ ‫‪Not(120)=255-120=135‬‬

‫‪42 OR‬‬ ‫‪13 AND 20*2‬‬ ‫ﻣﺜﺎﻝ‪ :‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﺭﻭﺑﺮﻭ ﭼﻨﺪ ﺍﺳﺖ؟‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪17‬‬
‫ﻋﻤﻠﮕﺮﻫﺎﻱ ‪ SHL‬ﻭ ‪ SHR‬ﺑﻪ ﻣﻌﻨﺎﻱ ﺷﻴﻔﺖ ﺑﻪ ﭼﭗ ﻳﺎ ﺷﻴﻔﺖ ﺑﻪ ﺭﺍﺳﺖ ﻫﺴﺘﻨﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪14 SHL 1 = ? :‬‬
‫‪14=(00001110)2‬‬
‫‪14 SHL 1 = (00011100)2=28‬‬

‫‪19 = (00010011)2‬‬ ‫?=‪19 SHR 2‬‬ ‫ﻣﺜﺎﻝ‪:‬‬

‫‪(00010011)2 è (00000100)2 = 4‬‬
‫ﻧﻜﺘﻪ‪ :‬ﺩﺭ ﺍﺯﺍﻱ ﺻﻔﺮﻫﺎ ﻳﺎ ﻳﻚ ﻫﺎﻳﻲ ﻛﻪ ﺑﻴﺮﻭﻥ ﺭﻳﺨﺘﻪ ﻣﻲ ﺷﻮﻧﺪ ﺩﺭ ﺳﻤﺖ ﺩﻳﮕﺮ ﺻﻔﺮ ﺍﺿﺎﻓﻪ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ‪ :‬ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﻋﺪﺩﻱ ﻳﻚ ﺑﺎﺭ ‪ SHL‬ﻣﻲ ﺷﻮﺩ ﻣﺎﻧﻨﺪ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺿﺮﺏ ﺩﺭ ‪ ٢‬ﺷﺪﻩ ﺍﺳﺖ‪.‬‬
‫ﻧﻜﺘﻪ‪ :‬ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﻋﺪﺩﻱ ﻳﻚ ﺑﺎﺭ ‪ SHR‬ﻣﻲ ﺷﻮﺩ ﻣﺎﻧﻨﺪ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ‪ DIV‬ﺑﺮ ‪ ٢‬ﺷﺪﻩ ﺍﺳﺖ‪.‬‬

‫‪127‬‬ ‫‪SHR‬‬ ‫‪3‬‬ ‫=‬ ‫‪127 DIV 2 DIV 2 DIV 2=15‬‬

‫‪19‬‬ ‫‪SHR‬‬ ‫‪2‬‬ ‫=‬ ‫‪19 DIV 2 DIV 2 = 4‬‬
‫‪15‬‬ ‫‪SHL‬‬ ‫‪3‬‬ ‫=‬ ‫‪15*2*2*2=120‬‬
‫‪9‬‬ ‫‪SHL‬‬ ‫‪5‬‬ ‫=‬ ‫‪9*2*2*2*2*2‬‬

‫ﺳﺌﻮﺍﻝ‪ :‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﺭﻭﺑﺮﻭ ﭼﻨﺪ ﺍﺳﺖ؟‬

‫‪115 - (12 SHL 3 AND 8) Mod 15‬‬

‫=<‬ ‫>‬ ‫><‬ ‫<‬ ‫ﻋﻤﻠﮕﺮﻫﺎي راﺑﻄـﻪ اﯾﯽ‪>= = :‬‬

‫ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ ﺩﺍﺭﺍﻱ ﺗﻘﺪﻡ ﻳﻜﺴﺎﻧﻲ ﻫﺴﺘﻨﺪ‪ .‬ﺣﺎﺻﻞ ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ ‪ True‬ﻳﺎ ‪) False‬ﺑﻮﻟﻴﻦ( ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪ .‬ﺍﺯ ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫـﺎ ﺑﻴـﺸﺘﺮ ﺩﺭ ﺷـﺮﻃﻬﺎ‬
‫ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬‬

‫‪12 > 14 è False‬‬ ‫‪25 <> 25 è False‬‬ ‫‪FALSE > TRUE è False‬‬
‫‪18 >= 18 è True‬‬ ‫‪TRUE > FALSE è TRUE‬‬

‫‪XOR‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎي ﺑﻮﻟﯽ‪OR AND NOT :‬‬

‫ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ ﺷﺒﻴﻪ ﻋﻤﻠﮕﺮﻫﺎﻱ ﻣﻨﻄﻘﻲ ﻫﺴﺘﻨﺪ ﺍﻣﺎ ﺣﺎﺻﻞ ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ )ﺑﻮﻟﻲ( ﺑﻮﻟﻴﻦ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬
‫ﺍﻭﻟﻮﻳﺖ ﻋﻤﻠﮕﺮﻫﺎﻱ ﺑﻮﻟﻲ ﺑﻴﺸﺘﺮ ﺍﺯ ﻋﻤﻠﮕﺮﻫﺎﻱ ﺭﻳﺎﺿﻲ ﻭ ﻋﻤﻠﮕﺮﻫﺎﻱ ﺭﺍﺑﻄﻪ ﺍﻳﻲ ﺍﺳﺖ‪.‬‬
‫ﺟﺪﻭﻝ ﻣﺮﺑﻮﻁ ﺑﻪ ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ ﻣﺎﻧﻨﺪ ﺟﺪﻭﻝ ﻋﻤﻠﮕﺮﻫﺎﻱ ﻣﻨﻄﻘﻲ ﺍﺳﺖ ﺑﺎ ﺍﻳﻦ ﺗﻔﺎﻭﺕ ﻛﻪ ﺑﺠﺎﻱ ﺻﻔﺮ‪ False،‬ﻭ ﺑﺠﺎﻱ ﻳﻚ‪ True ،‬ﻗﺮﺍﺭ ﺩﻫﻴﺪ‪.‬‬
‫‪(12 > 8) XOR (9> 15) =è True‬‬ ‫‪(13 > 14) OR‬‬ ‫‪NOT( 10 > 15) ==è True‬‬
‫)‪(14 <> 19‬‬ ‫‪AND ( 12 =13) ==èFalse‬‬
‫ﻣﻌﻤﻮﻻ ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ ﺑﺮﺍﻱ ﺍﻳﺠﺎﺩ ﺷﺮﻃﻬﺎﻱ ﻣﺮﻛﺐ ﺑﺎ ﻋﻤﻠﮕﺮﻫﺎﻱ ﺭﺍﺑﻄﻪ ﺍﻳﻲ ﺑﻪ ﻛﺎﺭ ﻣﻲ ﺭﻭﻧﺪ‪.‬‬
‫‪ ) +‬ﻋﻤﻠﮕﺮ ﺗﺮﮐﯿﺐ)اﻟﺤﺎق((‬ ‫ﻋﻤﻠﮕﺮﻫﺎي رﺷﺘﻪ اﯾﯽ‪:‬‬

‫’‪’Ali’+’Reza’=’AliReza‬‬ ‫ﺍﻳﻦ ﻋﻤﻠﮕﺮ ﺟﻬﺖ ﺍﺗﺼﺎﻝ )ﺗﺮﻛﻴﺐ( ﺩﻭ ﺭﺷﺘﻪ ﺑﻪ ﻛﺎﺭ ﻣﻲ ﺭﻭﺩ‪.‬‬

‫ﺑﻪ ﻣﺜﺎﻟﻬﺎﻱ ﺯﻳﺮ ﻭ ﺗﻔﺎﻭﺕ ﻫﺎﻱ ﺁﻧﻬﺎ ﺩﻗﺖ ﻛﻨﻴﺪ ‪:‬‬
‫’‪’5’+’4’=’54‬‬ ‫‪5+4=9‬‬ ‫ﻭ‬ ‫‪4+5=9‬‬ ‫’‪’4’+’5’=’45‬‬
‫ﻧﻜﺘﻪ ( ﻋﻤﻠﮕﺮ ﺗﺮﻛﻴﺐ ﺩﺍﺭﺍﻱ ﺧﺎﺻﻴﺖ ﺟﺎﺑﺠﺎﻳﻲ ﻧﻴﺴﺖ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪18‬‬
‫ﻋﻤﻠﮕﺮﻫﺎﻱ ﺭﺍﺑﻄﻪ ﺍﻳﻲ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﺮﺍﻱ ﺭﺷﺘﻪ ﻫﺎ ﻧﻴﺰ ﺑﻪ ﻛﺎﺭ ﺑﺮﺩ‪ .‬ﺑﺮﺍﻱ ﻣﻘﺎﻳﺴﻪ ﺩﻭ ﺭﺷﺘﻪ ﺣﺮﻑ ﺍﻭﻝ ﻳﻚ ﺭﺷﺘﻪ ﺑﺎ ﺣﺮﻑ ﺍﻭﻝ ﺭﺷﺘﻪ ﺩﻳﮕﺮ‬
‫ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮﻧﺪ)ﻛﺪ ﺍﺳﻜﻲ ﺁﻧﻬﺎ ﺑﺎ ﻫﻢ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮﻧﺪ(‪.‬‬
‫’‪’ALI’ > ’REZA‬‬ ‫‪è False‬‬ ‫’‪’M’ > ’AMPLK‬‬ ‫‪è True‬‬
‫‪’ALI’ < ’APLBBN’ è True‬‬ ‫‪’ABCD’ >= ’ABCE’ è False‬‬
‫ﺧﻮاﻧﺎﯾـﯽ ﺑﺮﻧﺎﻣﻪ‪:‬‬
‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺑﺎﻳﺪ ﺳﻌﻲ ﻛﻨﺪ ﺑﺮﻧﺎﻣﻪ ﺍﻳﻲ ﺭﺍ ﻛﻪ ﻣﻲ ﻧﻮﻳﺴﺪ ﺧﻮﺍﻧﺎ ﺑﺎﺷﺪ ﺗﺎ ﺍﻓﺮﺍﺩ ﺩﻳﮕﺮ ﻫﻢ ﺑﺘﻮﺍﻧﻨﺪ ﺑﻪ ﺁﺳﺎﻧﻲ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺩﺭﻙ ﻛﻨﻨـﺪ‪ .‬ﺑـﺮﺍﻱ ﺍﻳﻨﻜـﻪ‬
‫ﺑﺮﻧﺎﻣﻪ ﺧﻮﺍﻧﺎ ﺑﺎﺷﺪ ﺍﻳﻦ ﻣﻮﺍﺭﺩ ﺭﺍ ﺭﻋﺎﻳﺖ ﻛﻨﻴﺪ‪:‬‬
‫‪ -١‬ﺍﻧﺘﺨﺎﺏ ﻧﺎﻡ ﻣﻨﺎﺳﺐ ﺑﺮﺍﻱ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻏﻴﺮ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ‬
‫‪ -٢‬ﻛﻨﮕﺮﻩ ﺩﺍﺭ ﻛﺮﺩﻥ ﺑﺮﻧﺎﻣﻪ)ﺗﻮﺭﻓﺘﮕﻲ(‬
‫‪ -٣‬ﻗﺮﺍﺭﺩﺍﺩﻥ ﺗﻮﺿﻴﺤﺎﺕ ﺩﺭ ﺑﺮﻧﺎﻣﻪ‪:‬‬
‫ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﭘﺎﺳﻜﺎﻝ‪ ،‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ ﺗﻮﺍﻧﺪ ﺑﺎ ﻗﺮﺍﺭ ﺩﺍﺩﻥ ﺗﻮﺿﻴﺤﺎﺕ ﺩﺭ ﺑﺮﻧﺎﻣﻪ )ﻫﺮ ﻛﺠﺎ ﻛﻪ ﻧﻴﺎﺯ ﺑﻪ ﺗﻮﺿﻴﺢ ﺍﺳﺖ( ﺩﺭﻙ ﺑﺮﻧﺎﻣـﻪ ﺭﺍ ﺁﺳـﺎﻥ ﻛﻨـﺪ‪.‬‬
‫ﺑﺮﺍﻱ ﺩﺭﺝ ﺗﻮﺿﻴﺤﺎﺕ ﻣﻲ ﺗﻮﺍﻧﻴﺪ ﺍﺯ ﻋﻼﻣﺖ}{ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﺪ‪ .‬ﺍﺑﺘﺪﺍ ﻋﻼﻣﺖ { ﺭﺍ ﻗﺮﺍﺭ ﺩﻫﻴﺪ ﻭ ﺳﭙﺲ ﺗﻮﺿﻴﺤﺎﺕ ﺭﺍ ﺑﻨﻮﻳﺴﻴﺪ ﻭ ﺳﭙﺲ } ﺭﺍ ﻗـﺮﺍﺭ‬
‫ﺩﻫﻴﺪ‪ .‬ﻣﻲ ﺗﻮﺍﻥ ﺍﺯ ﻋﻼﻣﺖ ﺯﻳﺮ ﻧﻴﺰ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ‪.‬‬
‫;‪Program Average‬‬ ‫*(‬ ‫ﺗﻮﺿﻴﺤﺎﺕ‬ ‫)*‬
‫‪Var‬‬
‫;‪IntA,IntB:Integer; RlC:Real‬‬
‫‪Begin‬‬
‫}‪Read(IntA,IntB); { input data‬‬
‫}‪RlC:=(IntA+IntB)/2; { calculate average‬‬
‫} ‪Writeln(RlC); { output average‬‬
‫‪End.‬‬
‫‪ -٤‬ﺭﻭﺵ ﻧﺎﻡ ﮔﺬﺍﺭﻱ ﻣﺘﻐﻴﺮﻫﺎ ﺑﻪ ﺻﻮﺭﺕ ﻣﺠﺎﺭﺳﺘﺎﻧﻲ‪ :‬ﺑﺮﺍﻱ ﺍﻳﻨﻜﻪ ﻧﻮﻉ ﻳﻚ ﻣﺘﻐﻴﺮ ﺭﺍ ﺍﺯ ﺭﻭﻱ ﺍﺳﻢ ﺁﻥ ﺑﺘﻮﺍﻧﻴﻢ ﺗﺸﺨﻴﺺ ﺩﻫـﻴﻢ ﻣـﻲ ﺗـﻮﺍﻧﻴﻢ ﺍﺯ‬
‫ﺍﻳﻦ ﺭﻭﺵ ﺑﺮﺍﻱ ﻧﺎﻡ ﮔﺬﺍﺭﻱ ﻣﺘﻐﻴﺮﻫﺎ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﺪ‪ .‬ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﻣﺨﻔﻒ ﻧﻮﻉ ﻣﺘﻐﻴﺮ ﺩﺭ ﺍﺑﺘﺪﺍﻱ ﻧﺎﻡ ﻣﺘﻐﻴﺮ ﺁﻭﺭﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﻣﺜﻼ ﺍﮔﺮ ﻳـﻚ‬
‫ﻣﺘﻐﻴﺮ ﺍﺯ ﻧﻮﻉ ‪ Real‬ﺑﺎ ﻧﺎﻡ ‪ F‬ﻣﻲ ﺧﻮﺍﻫﻴﺪ ﺗﻌﺮﻳﻒ ﻛﻨﻴﺪ ﺍﺳﻢ ﺁﻥ ﺭﺍ ‪ RlF‬ﻗﺮﺍﺭ ﺩﻫﻴﺪ‪ .‬ﻣﺜﺎﻟﻬﺎﻱ ﺩﻳﮕﺮ‪BlnZero , IntConter :‬‬
‫ﺍﻳﻦ ﺭﻭﺵ ﺑﻮﺳﻴﻠﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﺎﻥ ﺷﺮﻛﺖ ﻣﻴﻜﺮﻭﺳﺎﻓﺖ ) ﺁﻗﺎﻱ ﭼﺎﺭﻟﺰﺳﻴﻤﻮﻧﻲ( ﺑﻪ ﻛﺎﺭ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪-٥‬ﻧﺎﻡ ﻣﺘﻐﻴﺮﻫﺎ ﺭﺍ ﺳﻌﻲ ﻛﻨﻴﺪ ﻛﻮﺗﺎﻩ ﻧﻜﻨﻴﺪ‪.‬‬
‫ﺑﺮﭼﺴﺒـﻬﺎ‪:‬‬
‫ﺍﺯ ﺑﺮﭼﺴﺐ ﻫﺎ ﺑﺮﺍﻱ ﻣﺸﺨﺺ ﻛﺮﺩﻥ ﺧﻄﻮﻁ ﺧﺎﺻﻲ ﺍﺯ ﺑﺮﻧﺎﻣﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬ﻣﻌﻤﻮﻻ ﺍﺯ ﺑﺮﭼﺴﺐ ﻫﺎ ﺑﻪ ﻫﻤﺮﺍﻩ ﺩﺳـﺘﻮﺭ ‪ goto‬ﺍﺳـﺘﻔﺎﺩﻩ ﻣـﻲ‬
‫ﺷﻮﺩ‪ .‬ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ Goto‬ﻣﻲ ﺗﻮﺍﻥ ﻛﻨﺘﺮﻝ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭﺍﺕ ﺭﺍ ﺍﺯ ﺧﻄﻲ ﺑﻪ ﺧﻂ ﺩﻳﮕﺮ ﻣﻨﺘﻘﻞ ﻛﺮﺩ‪ .‬ﻫﻤﻪ ﺑﺮﭼﺴﺒﻬﺎ ﺑﺎﻳﺪ ﺩﺭ ﺑﺮﻧﺎﻣـﻪ ﺩﺭ‬
‫ﻗﺴﻤﺖ ﺗﻌﺎﺭﻳﻒ ﺗﻌﺮﻳﻒ ﺷﻮﻧﺪ‪ .‬ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﺑﺮﭼﺴﺒﻬﺎ ﺍﺯ ﻛﻠﻤﺔ ﺭﺯﺭﻭﺷﺪﺓ ‪ Label‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬ﺑﺮﺍﻱ ﻧﺎﻡ ﮔﺬﺍﺭﻱ ﺑﺮﭼﺴﺐ ﻫﺎ ﺍﺯ ﻗﻮﺍﻧﻴﻦ ﻧﺎﻡ‬
‫ﮔﺬﺍﺭﻱ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻏﻴﺮﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪ .‬ﺍﻟﺒﺘﻪ ﻳﻚ ﺍﺳﺘﺜﻨﺎﺀ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻭ ﺁﻥ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺑﺮﺍﻱ ﻧـﺎﻡ ﮔـﺬﺍﺭﻱ ﺑﺮﭼـﺴﺐ ﻫـﺎ ﻣـﻲ‬
‫ﺗﻮﺍﻥ ﺍﺯ ﺍﻋﺪﺍﺩ ﺻﺤﻴﺢ ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 9999‬ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ‪.‬‬
‫‪Label‬‬
‫;‪L1,5‬‬ ‫ﺑﺮﺍﻱ ﻣﺸﺨﺺ ﻛﺮﺩﻥ ﺑﺮﭼﺴﺐ ﻳﻚ ﺧﻂ ﺍﺑﺘﺪﺍ ﻧﺎﻡ ﺑﺮﭼﺴﺐ ﺭﺍ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻭ ﺳﭙﺲ ﻋﻼﻣﺖ‪:‬‬
‫‪Var‬‬ ‫ﺭﺍ ﻗﺮﺍﺭ ﻣﻲ ﺩﻫﻴﻢ ﻭ ﺩﺳﺘﻮﺭ ﺭﺍ ﻣﻲ ﻧﻮﻳﺴﻴﻢ‪.‬‬
‫;‪K:integer‬‬
‫‪Begin‬‬ ‫ﻧﻜﺘﻪ‪ :‬ﻧﺎﻡ ﺑﺮﭼﺴﺐ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ‪ 5A‬ﺑﺎﺷﺪ ﺯﻳﺮﺍ ﺣﺮﻑ ﺍﻭﻝ ﺁﻥ ﻋﺪﺩ ﺍﺳﺖ‪.‬‬
‫;‪K:=0‬‬ ‫ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ Goto‬ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻫﻴﭻ ﻋﻨﻮﺍﻥ ﭘﻴﺸﻨﻬﺎﺩ ﻧﻤﻲ ﺷـﻮﺩ ﺯﻳـﺮﺍ ﺩﺭﻙ ﻣﻨﻄـﻖ‬
‫‪5:‬‬ ‫;‪K:=K+2‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻭ ﺩﻧﺒﺎﻝ ﻛﺮﺩﻥ ﻣﺴﻴﺮ ﺍﺟﺮﺍﻱ ﺁﻥ ﺑﻪ ﻣﻨﻈﻮﺭ ﻋﻴﺐ ﻳﺎﺑﻲ ﺑﺮﻧﺎﻣﻪ ﻣﺸﻜﻞ ﺍﺳﺖ ﻭ ﺧﻮﺍﻧـﺎﻳﻲ‬
‫;)‪L1: Writeln(K‬‬
‫;‪K:=K+1‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻛﻢ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪If K<100 then‬‬
‫;‪Goto L1‬‬ ‫ﻧﻜﺘﻪ‪ :‬ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻏﻴﺮﺍﺳﺘﺎﻧﺪﺍﺭﺩﻱ ﻛﻪ ﻛﺎﺭﺑﺮ ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﺪ ﻧﺒﺎﻳﺪ ﻫﻢ ﻧﺎﻡ ﺑﺎﺷﻨﺪ‪ .‬ﺑـﻪ ﻋﻨـﻮﺍﻥ‬
‫‪If K<150 then‬‬ ‫ﻣﺜﺎﻝ ﻛﺎﺭﺑﺮ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﻳﻚ ﺑﺮﭼﺴﺐ ﺑﺎ ﻧﺎﻡ ‪ A‬ﺗﻌﺮﻳﻒ ﻛﻨﺪ ﻭ ﻳﻚ ﻣﺘﻐﻴﺮ ﻧﻴﺰ ﺑﺎ ﻧﺎﻡ ‪ A‬ﺗﻌﺮﻳـﻒ‬
‫;‪Goto 5‬‬
‫ﻛﻨﺪ‪ .‬ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﺻﺎﺩﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪End.‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪19‬‬
‫ﺗﺴﺖ‬

‫‪-١‬ﻛﺪﺍﻣﻴﻚ ﺍﺯ ﺍﺳﺎﻣﻲ ﺯﻳﺮ ﺑﺮﺍﻱ ﻳﻚ ﺷﻨﺎﺳﻪ ﻏﻴﺮ ﻣﺠﺎﺯ ﺍﺳﺖ؟‬

‫ﺩ( ‪if‬‬ ‫ﺝ( ‪A6B‬‬ ‫ﺏ( ‪prog‬‬ ‫ﺍﻟﻒ( ‪for_if‬‬
‫‪-٢‬ﻃﻮﻝ ﻧﺎﻡ ﻣﺘﻐﻴﺮﻫﺎ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﻣﻲ ﺗﻮﺍﻧﺪ ﺣﺪﺍﻛﺜﺮ …… ﻛﺎﺭﺍﻛﺘﺮ ﺑﺎﺷﺪ‪.‬‬
‫ﺩ( ‪٨‬‬ ‫ﺝ( ‪٦٣‬‬ ‫ﺏ( ‪٢٥٥‬‬ ‫ﺍﻟﻒ( ‪٦٤‬‬
‫‪ -٣‬ﻣﺘﻐﻴﺮ ﻧﻮﻉ ‪ shortint‬ﭼﻨﺪ ﺑﺎﻳﺖ ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨﺪ؟‬
‫ﺩ( ﺣﺪﺍﻗﻞ ‪ ٢‬ﺑﺎﻳﺖ‬ ‫ﺝ( ‪ ٤‬ﺑﺎﻳﺖ‬ ‫ﺏ( ‪ ١‬ﺑﺎﻳﺖ‬ ‫ﺍﻟﻒ( ‪ ٢‬ﺑﺎﻳﺖ‬
‫‪-٤‬ﻛﻮﭼﻜﺘﺮﻳﻦ ﻭﺍﺣﺪ ﻣﻌﻨﻲ ﺩﺍﺭ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ………… ﺍﺳﺖ‪.‬‬
‫ﺩ( ﺑﺮﭼﺴﺐ‬ ‫ﺝ( ﺗﻮﻛﻦ‬ ‫ﺏ( ﺷﻨﺎﺳﻪ‬ ‫ﺍﻟﻒ( ﻛﺎﺭﺍﻛﺘﺮ‬
‫‪-٥‬ﻣﻌﻤﻮﻻ ﺑﺮﭼﺴﺐ ﻫﺎ ﺑﻪ ﻫﻤﺮﺍﻩ ﻛﺪﺍﻡ ﺩﺳﺘﻮﺭ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﻧﺪ؟‬
‫ﺩ(‪Goto‬‬ ‫ﺝ(‪Readln‬‬ ‫ﺏ( ‪For‬‬ ‫ﺍﻟﻒ( ‪Writeln‬‬
‫‪-٦‬ﺍﻧﻮﺍﻉ ﺍﻋﺪﺍﺩ ﺻﺤﻴﺢ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﻛﺪﺍﻣﻨﺪ؟‬
‫ﺏ( ‪Longint,Integer,Single,Byte‬‬ ‫ﺍﻟﻒ( ‪Longint ,Word, Shortint,Integr,Byte‬‬
‫ﺩ( ‪Integer,Byte,Extended,Word‬‬ ‫ﺝ(‪Integer,Single,Comp,Byte‬‬
‫‪-٧‬ﻋﺒﺎﺭﺍﺗﻲ ﻛﻪ ﺩﺭﻭﻥ ……… ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﻧﺪ ﺩﺍﺭﺍﻱ ﺣﻖ ﺗﻘﺪﻡ ﺑﺎﻻﺗﺮﻱ ﻧﺴﺒﺖ ﺑﻪ ﺩﻳﮕﺮ ﻋﻤﻠﮕﺮﻫﺎ ﺩﺍﺭﻧﺪ‪.‬‬
‫ﺩ( ﻋﻼﻣﺖ ] [‬ ‫ﺝ( ﻛﺮﻭﺷﻪ }{‬ ‫ﺏ( ﭘﺮﺍﻧﺘﺰ‬ ‫ﺍﻟﻒ(ﺁﭘﺴﺘﺮﻭﻑ‬
‫‪-٨‬ﻛﺪﺍﻡ ﻳﻚ ﺍﺯ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﺯﻳﺮ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﻣﺠﺎﺯ ﻧﻴﺴﺖ؟‬
‫ﺩ( ‪INT‬‬ ‫ﺝ(‪Pascal‬‬ ‫ﺏ(‪Case‬‬ ‫ﺍﻟﻒ( ‪ASCII‬‬
‫‪-٩‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ‪ 12 + 6 / 3 + 20 MOD 6‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ( ‪13.2‬‬ ‫ﺝ( ‪16‬‬ ‫ﺏ( ‪3.6‬‬ ‫ﺍﻟﻒ( ‪8‬‬
‫‪-١٠‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ‪ 12 XOR 25 SHL 2 AND 14‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪١٢‬‬ ‫ﺝ( ‪٤‬‬ ‫ﺏ(‪٨‬‬ ‫ﺍﻟﻒ( ‪١٠‬‬
‫‪-١١‬ﺛﺎﺑﺖ ﻧﻮﻉ ﺩﺍﺭ ﺛﺎﺑﺘﻲ ﺍﺳﺖ ﻛﻪ‪:‬‬
‫ﺏ( ﻗﺎﺑﻞ ﭼﺎﭖ ﻧﻤﻲ ﺑﺎﺷﺪ‬ ‫ﺍﻟﻒ(ﺩﺭ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﻣﻘﺪﺍﺭ ﺁﻥ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺗﻐﻴﻴﺮ ﺩﺍﺩ‪.‬‬
‫ﺩ( ﺩﺭ ﻫﻨﮕﺎﻡ ﺗﻌﺮﻳﻒ ﻣﻘﺪﺍﺭ ﺁﻥ ﻣﺸﺨﺺ ﻧﻴﺴﺖ‪.‬‬ ‫ﺝ(ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﺁﻥ ﺭﺍ ﻧﻤﻲ ﺗﻮﺍﻥ ﺗﻐﻴﻴﺮ ﺩﺍﺩ‪.‬‬
‫‪ -١٢‬ﻋﻤﻠﻮﻧﺪﻫﺎﻱ ﻋﻤﻠﮕﺮ ‪ DIV‬ﺍﺯ ﭼﻪ ﻧﻮﻋﻲ ﻫﺴﺘﻨﺪ؟‬
‫ﺩ( ﺭﺷﺘﻪ ﺍﻱ‬ ‫ﺝ( ﺻﺤﻴﺢ‬ ‫ﺏ( ﺍﻋﺸﺎﺭﻱ‬ ‫ﺍﻟﻒ(ﺻﺤﻴﺢ ﻭ ﺍﻋﺸﺎﺭﻱ‬
‫‪-١٣‬ﻋﺒﺎﺭﺕ ‪ ( b OR a) XOR 0‬ﻣﻌﺎﺩﻝ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺯﻳﺮ ﺍﺳﺖ؟)‪ a‬ﻭ‪ b‬ﻋﺪﺩ ﺻﺤﻴﺢ ﻫﺴﺘﻨﺪ(‬
‫ﺩ( )‪b AND NOT(a‬‬ ‫‪b AND a‬‬ ‫ﺝ(‬ ‫ﺏ( ‪b OR a‬‬ ‫ﺍﻟﻒ( ‪a XOR b‬‬
‫‪ -١٤‬ﻛﺪﺍﻡ ﺷﻨﺎﺳﻪ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﻣﺠﺎﺯ ﺍﺳﺖ؟‬
‫ﺩ( ‪5Array‬‬ ‫ﺝ( ‪MEHRDAD7‬‬ ‫ﺏ( ‪then‬‬ ‫ﺍﻟﻒ( ‪Ali R‬‬
‫‪-١٥‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺯﻳﺮ ﺩﺭﺳﺖ ﺍﺳﺖ؟‬
‫ﺏ(ﻋﺒﺎﺭﺗﻬﺎﻱ ﺑﻮﻟﻲ ﻳﻚ ﻋﺪﺩ ﺍﻋﺸﺎﺭﻱ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﻨﺪ‪.‬‬ ‫ﺍﻟﻒ( ﻋﺒﺎﺭﺗﻬﺎﻱ ﺑﻮﻟﻲ ﻳﻚ ﻧﺘﻴﺠﺔ ﺭﺷﺘﻪ ﺍﻱ ﺩﺍﺭﻧﺪ‪.‬‬
‫ﺩ( ﻋﺒﺎﺭﺗﻬﺎﻱ ﺑﻮﻟﻲ ﺍﺭﺯﺵ ﺩﺭﺳﺖ ﻳﺎ ﻧﺎﺩﺭﺳﺖ ﺩﺍﺭﻧﺪ‪.‬‬ ‫ﺝ(ﻋﺒﺎﺭﺗﻬﺎﻱ ﺑﻮﻟﻲ ﻳﻚ ﻋﺪﺩ ﺻﺤﻴﺢ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﻨﺪ‪.‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪20‬‬
‫‪ -١٦‬ﺍﮔﺮ ﻣﺘﻐﻴﺮﻫﺎﻱ ‪ y, x‬ﺍﺯ ﻧﻮﻉ ﺻﺤﻴﺢ ﺑﺎﺷﻨﺪ ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﺣﺎﺻﻞ ﻋﺒﺎﺭﺗﻬﺎﻱ ‪ X*Y‬ﻭ ‪ X/Y‬ﺑﻪ ﺗﺮﺗﻴﺐ ﭼﻪ ﻧﻮﻋﻲ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪).‬ﺍﺯ ﺭﺍﺳﺖ ﺑﻪ ﭼﭗ(‬
‫ﺩ( ﺻﺤﻴﺢ – ﺍﻋﺸﺎﺭﻱ‬ ‫ﺝ( ﺻﺤﻴﺢ – ﺻﺤﻴﺢ‬ ‫ﺏ(ﺍﻋﺸﺎﺭﻱ – ﺍﻋﺸﺎﺭﻱ‬ ‫ﺍﻟﻒ(ﺍﻋﺸﺎﺭﻱ – ﺻﺤﻴﺢ‬
‫‪-١٧‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫ﺩ( ‪Const name := 5‬‬ ‫ﺝ( ‪Const name = 5‬‬ ‫ﺏ( ;‪Const name = 5‬‬ ‫ﺍﻟﻒ( ;‪Const name := 5‬‬
‫‪-١٨‬ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭ )‪ 13 XOR $18 AND NOT (170+60‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ( ‪25‬‬ ‫ﺝ( ‪21‬‬ ‫ﺏ( ‪17‬‬ ‫ﺍﻟﻒ( ‪29‬‬
‫‪-١٩‬ﻛﺪﺍﻡ ﻳﻚ ﺍﺯ ﺍﺳﺎﻣﻲ ﺯﻳﺮ ﺑﺮﺍﻱ ﻳﻚ ﺷﻨﺎﺳﻪ ﻏﻴﺮ ﻣﺠﺎﺯ ﺍﺳﺖ؟‬
‫ﺩ( ﻫﺮ ﺳﻪ ﻣﻮﺭﺩ‬ ‫ﺝ( ‪const‬‬ ‫ﺏ( ‪Write‬‬ ‫ﺍﻟﻒ( ‪INC‬‬
‫‪-٢٠‬ﺩﺭ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﭘﺎﺳﻜﺎﻝ ﻫﺮ ﺳﻄﺮ ﺣﺪﺍﻛﺜﺮ ﭼﻨﺪ ﻛﺎﺭﺍﻛﺘﺮ ﻣﻲ ﺗﻮﺍﻧﺪ ﺑﺎﺷﺪ؟‬
‫ﺩ(ﻣﺤﺪﻭﺩﻳﺘﻲ ﻧﺪﺍﺭﺩ‬ ‫ﺝ( ‪٢٥٥‬‬ ‫ﺏ( ‪١٢٧‬‬ ‫ﺍﻟﻒ(‪٦٣‬‬
‫‪-٢١‬ﻛﺪﺍﻣﻴﻚ ﺍﺯ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﺯﻳﺮ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﻣﺠﺎﺯ ﻧﻴﺴﺖ؟‬
‫ﺩ(‪INT‬‬ ‫ﺝ(‪A3B‬‬ ‫ﺏ( ‪DOWNTO‬‬ ‫ﺍﻟﻒ(‪ABS‬‬
‫‪-٢٢‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ )‪ (12*5 DIV 3+8 MOD 6‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪١٢‬‬ ‫ﺝ(‪٠‬‬ ‫ﺏ(‪٢٢‬‬ ‫ﺍﻟﻒ(‪١٤‬‬
‫‪a DIV –3 +16/b*3‬‬ ‫‪-٢٣‬ﺑﺎ ﻓﺮﺽ ﺍﻳﻨﻜﻪ ‪ a=10‬ﻭ ‪ b=8‬ﺑﺎﺷﺪ ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﺯﻳﺮ ﭼﻴﺴﺖ؟‬
‫ﺩ(ﻋﺒﺎﺭﺕ ﻓﻮﻕ ﻧﺎﺩﺭﺳﺖ ﺍﺳﺖ‪.‬‬ ‫ﺝ( ‪-٣‬‬ ‫ﺏ( ‪٠‬‬ ‫ﺍﻟﻒ(‪٣‬‬
‫‪-٢٤‬ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭ))‪ WRITE(10 XOR (NOT 255‬ﭼﻴﺴﺖ؟‬
‫ﺩ( ‪١١‬‬ ‫ﺝ( ‪٥‬‬ ‫ﺏ( ﻣﻜﻤﻞ ﺩﻭ ﻋﺪﺩ‪١٠‬‬ ‫ﺍﻟﻒ( ‪١٠‬‬
‫‪-٢٥‬ﺣﺎﺻﻞ ‪ 167 shr 3‬ﻛﺪﺍﻣﺴﺖ؟‬
‫ﺩ(‪7‬‬ ‫ﺝ(‪1336‬‬ ‫ﺏ(‪2‬‬ ‫ﺍﻟﻒ( ‪20‬‬
‫‪-٢٦‬ﺍﮔﺮ ‪ a‬ﻭ ‪ b‬ﺍﺯ ﻧﻮﻉ ﻣﻨﻄﻘﻲ ﺑﺎﺷﻨﺪ ﻣﻌﺎﺩﻝ ‪ a=b‬ﻛﺪﺍﻣﺴﺖ؟‬
‫‪a‬‬ ‫‪AND‬‬ ‫ﺩ(‪b‬‬ ‫ﺝ( ‪a OR b‬‬ ‫‪NOT ( a XOR‬‬ ‫ﺏ( )‪b‬‬ ‫ﺍﻟﻒ( ‪a XOR b‬‬
‫‪-٢٧‬ﺩﺭ ﺭﺍﺑﻄﻪ ﺑﺎ ﺗﺮﺗﻴﺐ ﻋﻤﻠﮕﺮﻫﺎ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺩﺭﺳﺖ ﺍﺳﺖ)ﺍﺯﺭﺍﺳﺖ ﺑﻪ ﭼﭗ(‬
‫ﺩ( ‪or, div, Not‬‬ ‫ﺝ( *‪and, + ,‬‬ ‫ﺏ( ‪mod, > ,Not‬‬ ‫ﺍﻟﻒ( * ‪mod, Not,‬‬
‫‪ Real-٢٨‬ﺩﺍﺭﺍﻱ ﺩﻗﺖ ﭼﻨﺪ ﺭﻗﻢ ﺍﻋﺸﺎﺭ ﺍﺳﺖ؟‬
‫ﺩ( ‪٩‬‬ ‫ﺝ( ‪١١‬‬ ‫ﺏ( ‪١٠‬‬ ‫ﺍﻟﻒ( ‪١٧‬‬
‫‪-٢٩‬ﻛﺪﺍﻡ ﻳﻚ ﺍﺯ ﺍﻧﻮﺍﻉ ﺩﺍﺩﻩ ﻫﺎﻱ ﺯﻳﺮ ﺷﺎﻣﻞ ﻣﻘﺎﺩﻳﺮ ﻣﻨﻔﻲ ﻧﻴﺰ ﻣﻲ ﺑﺎﺷﺪ؟‬
‫ﺩ(‪Word‬‬ ‫ﺝ(‪Char‬‬ ‫ﺏ(‪Shortint‬‬ ‫ﺍﻟﻒ(‪Byte‬‬
‫‪-٣٠‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ‪ 2 or 3*2+120 mod 4‬ﭼﻴﺴﺖ؟‬
‫ﺩ(‪٤‬‬ ‫ﺝ( ‪٣٦‬‬ ‫ﺏ( ‪٦‬‬ ‫ﺍﻟﻒ( ‪٢‬‬
‫‪-٣١‬ﻛﺪﺍﻡ ﺷﻨﺎﺳﻪ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫ﺩ(‪SQR‬‬ ‫ﺝ( ‪TO‬‬ ‫ﺏ( ‪X-Y‬‬ ‫ﺍﻟﻒ( ‪2a‬‬
‫‪-٣٢‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ‪ 24 OR 22 AND 13 > = 22 Xor 13 +1‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(ﻋﺒﺎﺭﺕ ﺍﺷﺘﺒﺎﻩ ﺍﺳﺖ‪.‬‬ ‫ﺝ(‪False‬‬ ‫ﺏ( ‪23‬‬ ‫ﺍﻟﻒ( ‪True‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪21‬‬
‫‪-٣٣‬ﺩﺭ ﭘﺎﺳﻜﺎﻝ‪ ،‬ﺑﻼﻙ ﺍﺻﻠﻲ ﺑﺮﻧﺎﻣﻪ ﺑﻼﻛﻲ ﺍﺳﺖ ﻛﻪ ‪:‬‬
‫ﺏ( ﺩﺭ ﺍﻧﺘﻬﺎ ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ‪.‬‬ ‫ﺍﻟﻒ( ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻟﺰﻭﻡ ﺩﺭ ﺍﺑﺘﺪﺍ ﻳﺎ ﺍﻧﺘﻬﺎ ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﺩ( ﺩﺭ ﺍﻧﺘﻬﺎﻱ ﺑﺮﻧﺎﻣﻪ ﻗﺮﺍﺭ ﺩﺍﺭﺩ‪.‬‬ ‫ﺝ( ﺩﺭ ﺍﺑﺘﺪﺍﻱ ﺑﺮﻧﺎﻣﻪ ﻗﺮﺍﺭ ﺩﺍﺭﺩ‪.‬‬
‫‪-٣٤‬ﺩﺍﺩﻩ ﻧﻮﻉ ‪ Comp‬ﺍﺯ ﭼﻪ ﻧﻮﻋﻴﺴﺖ؟‬
‫ﺩ( ﺻﺤﻴﺢ‬ ‫ﺝ( ﺻﺤﻴﺢ ﺑﻠﻨﺪ‬ ‫ﺏ( ﺍﻋﺸﺎﺭﻱ ‪Single‬‬ ‫ﺍﻟﻒ( ﺍﻋﺸﺎﺭﻱ ‪Double‬‬
‫‪-٣٥‬ﭼﻨﺎﻧﭽﻪ ﻣﺘﻐﻴﺮﻫﺎﻱ ﺯﻳﺮ ﺑﺎ ﺭﻭﺵ ﻣﺠﺎﺭﺳﺘﺎﻧﻲ ﻧﺎﻣﮕﺬﺍﺭﻱ ﺷﺪﻩ ﺑﺎﺷﻨﺪ ﻣﺠﻤﻮﻉ ﻓﻀﺎﻱ ﺍﺷﻐﺎﻟﻲ ﺁﻧﻬﺎ ﻛﺪﺍﻣﺴﺖ؟‬
‫‪CmpNumber , LngCount ,XtdNo‬‬
‫ﺩ(‪24‬‬ ‫ﺝ( ‪20‬‬ ‫ﺏ(‪22‬‬ ‫ﺍﻟﻒ(‪18‬‬
‫‪17 + 6 shl 2 xor 4 * 7‬‬ ‫‪ -٣٦‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪315‬‬ ‫ﺝ(‪21‬‬ ‫ﺏ( ‪53‬‬ ‫ﺍﻟﻒ(‪64‬‬
‫‪-٣٧‬ﻋﻼﻣﺖ ………… ﻧﺸﺎﻧﻪ ﭘﺎﻳﺎﻥ ﺳﻄﺮ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺍﺳﺖ‪.‬‬
‫ﺩ( ;‬ ‫ﺝ( ‪,‬‬ ‫ﺏ( ‪:‬‬ ‫ﺍﻟﻒ( ‪.‬‬

‫‪-٣٨‬ﺍﮔﺮ ‪ a‬ﻭ ‪ b‬ﺍﺯ ﻧﻮﻉ ﺑﻮﻟﻲ ﺑﺎﺷﻨﺪ‪ ،‬ﻣﻌﺎﺩﻝ ﻋﺒﺎﺭﺕ ‪ (a≤b)>b‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ( )‪Not(a or b‬‬ ‫ﺝ(‪not(a) and b‬‬ ‫ﺏ(‪a or b‬‬ ‫ﺍﻟﻒ()‪a and not (b‬‬
‫‪X mod Y‬‬ ‫‪-٣٩‬ﺩﺭ ﭼﻪ ﺻﻮﺭﺕ ﺩﺭ ﻋﺒﺎﺭﺕ ﺭﻭﺑﺮﻭ ﻧﺘﻴﺠﻪ ﻋﻤﻞ ﻧﺎﻣﻌﻠﻮﻡ ﺧﻮﺍﻫﺪ ﺑﻮﺩ؟‬
‫ﺩ(‪X<Y‬‬ ‫ﺝ(‪X>Y‬‬ ‫ﺏ(‪X=0‬‬ ‫ﺍﻟﻒ( ‪Y=0‬‬

‫‪-٤٠‬ﻋﺒﺎﺭﺕ ﻣﻌﺎﺩﻝ ﺑﺎ ‪ (a≥b)≤a‬ﺍﮔﺮ ‪ a‬ﻭ ‪ b‬ﺍﺯ ﻧﻮﻉ ﻣﻨﻄﻘﻲ ﺑﺎﺷﻨﺪ ﻛﺪﺍﻣﺴﺖ؟‬

‫ﺩ(‪True‬‬ ‫‪A‬‬ ‫ﺝ(‪OR B‬‬ ‫‪A and‬‬ ‫ﺏ(‪B‬‬ ‫ﺍﻟﻒ(‪A XOR B‬‬
‫‪-٤١‬ﺧﻼﺻﻪ ﻋﺒﺎﺭﺕ )‪ B and ( B Or False‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪B‬‬ ‫ﺝ(‪B OR False‬‬ ‫ﺏ(‪False‬‬ ‫ﺍﻟﻒ( ‪True‬‬
‫‪-٤٢‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺩﺭﺳﺖ ﻭ ﺍﺯ ﻧﻮﻉ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫ﺏ( )‪A (Div B Mod C‬‬ ‫ﺍﻟﻒ( ‪A mod B * Div C‬‬
‫ﺩ( ‪A Div B Mod C‬‬ ‫ﺝ(‪A/B +C Div D‬‬
‫‪-٤٣‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﻳﻚ ﺛﺎﺑﺖ ﺩﺭﺳﺖ ﺍﺳﺖ؟‬
‫‪Const‬‬ ‫ﺏ( ;‪a=12.5-9.5‬‬ ‫‪Const‬‬ ‫ﺍﻟﻒ( ;‪a=12.5:real‬‬
‫ﺩ(;‪Const a:Real‬‬ ‫ﺝ( ;‪Const a,b=12‬‬
‫‪-٤٤‬ﻭﺟﻮﺩ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺩﺭ ﺳﺎﺧﺘﺎﺭ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺯﺑﺎﻥ ﺗﻮﺭﺑﻮﭘﺎﺳﻜﺎﻝ ﺑﺮﺍﻱ ﺍﺟﺮﺍ ﺿﺮﻭﺭﻱ ﺍﺳﺖ؟‬
‫ﺩ( ﻣﺘﻐﻴﺮﻫﺎ‬ ‫ﺝ( ﺛﺎﺑﺘﻬﺎ‬ ‫ﺏ(ﻋﻨﻮﺍﻥ )‪(Header‬‬ ‫ﺍﻟﻒ( ﺩﺳﺘﻮﺭﺍﺕ )‪(Statement‬‬
‫‪-٤٥‬ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺗﺮﺗﻴﺐ ﺗﻌﺮﻳﻒ ﻭ ﻳﺎ ﺍﻋﻼﻥ ﺷﻨﺎﺳﻪ ﻫﺎ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺏ( ﻣﺘﻐﻴﺮﻫﺎ – ﻧﻮﻉ ﺩﺍﺩﻩ ﻫﺎ – ﺛﺎﺑﺘﻬﺎ‬ ‫ﺍﻟﻒ( ﻧﻮﻉ ﺩﺍﺩﻩ ﻫﺎ – ﻣﺘﻐﻴﺮﻫﺎ – ﺛﺎﺑﺘﻬﺎ‬
‫ﺩ( ﺛﺎﺑﺘﻬﺎ – ﻣﺘﻐﻴﺮﻫﺎ – ﻧﻮﻉ ﺩﺍﺩﻩ ﻫﺎ‬ ‫ﺝ( ﺛﺎﺑﺘﻬﺎ – ﻧﻮﻉ ﺩﺍﺩﻩ ﻫﺎ – ﻣﺘﻐﻴﺮﻫﺎ‬
‫‪-٤٦‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺍﺯ ﺑﺨﺸﻬﺎﻱ ﺍﺻﻠﻲ ﻭ ﺍﺟﺒﺎﺭﻱ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﭘﺎﺳﻜﺎﻝ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺍﺳﺖ؟‬
‫ﺩ( ﻋﻨﻮﺍﻥ‬ ‫ﺝ( ﺷﻨﺎﺳﻪ ﻫﺎ‬ ‫ﺏ( ﺗﻌﺎﺭﻳﻒ ﻭ ﺍﻋﻼﻧﺎﺕ‬ ‫ﺍﻟﻒ(ﻋﻼﺋﻢ ﻭ ﺛﺎﺑﺘﻬﺎ‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪22‬‬
‫‪-٤٧‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺩﺭ ﻣﻮﺭﺩ ﻋﻼﻣﺖ ; )‪ (semicolon‬ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫ﺏ( ﺑﺮﺍﻱ ﺟﺪﺍﺳﺎﺯﻱ ﺩﺳﺘﻮﺭﻫﺎ ﺍﺳﺖ‬ ‫ﺍﻟﻒ(ﺑﻪ ﻋﻨﻮﺍﻥ ﭘﺎﻳﺎﻥ ﺩﺳﺘﻮﺭﻫﺎ ﻣﻮﺭﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ‬
‫ﺩ( ﺁﺧﺮﻳﻦ ﺩﺳﺘﻮﺭ ﻧﻴﺎﺯ ﺑﻪ ; ﺩﺍﺭﺩ‪.‬‬ ‫ﺝ( ﺍﻭﻟﻴﻦ ﻭ ﺁﺧﺮﻳﻦ ﺩﺳﺘﻮﺭ ﻧﻴﺎﺯ ﺑﻪ ; ﺩﺍﺭﻧﺪ‪.‬‬
‫‪-٤٨‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫ﺏ( ‪IntC:= BytF Mod ShtA‬‬ ‫ﺍﻟﻒ( ‪IntA:=IntB Mod RlD‬‬
‫ﺩ(‪IntA:= RlC Div ShtD‬‬ ‫ﺝ( ‪RlC=IntA Div BlD‬‬
‫)’‪Write( ’BABY’<’BABAK‬‬ ‫‪-٤٩‬ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭ ﻣﻘﺎﺑﻞ ﭼﻴﺴﺖ؟‬
‫ﺩ(ﺧﻄﺎ ﺗﻮﻟﻴﺪ ﻣﻲ ﺷﻮﺩ‪.‬‬ ‫ﺝ(‪False‬‬ ‫ﺏ(‪True‬‬ ‫ﺍﻟﻒ(‪1‬‬
‫‪(A≤B) AND A‬‬ ‫‪-٥٠‬ﺗﺎﺑﻊ ﺭﻭﺑﺮﻭ ﻣﻌﺎﺩﻝ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺍﺳﺖ؟‬
‫ﺩ( ‪Not A AND B‬‬ ‫ﺝ(‪A XOR B‬‬ ‫‪A OR‬‬ ‫ﺏ(‪B‬‬ ‫ﺍﻟﻒ(‪A AND B‬‬
‫‪-٥١‬ﻛﺪﺍﻡ ﻛﻠﻤﻪ ﺭﺯﺭﻭ ﺷﺪﻩ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺍﺳﺖ؟‬
‫ﺩ(‪Read‬‬ ‫ﺝ(‪true‬‬ ‫ﺏ(‪Var‬‬ ‫ﺍﻟﻒ(‪Integer‬‬
‫‪-٥٢‬ﺍﮔﺮ ﺗﻌﺮﻳﻒ ﺭﻭﺑﺮﻭ ﻣﻮﺭﺩ ﻧﻈﺮ ﺑﺎﺷﺪ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺑﺎﻋﺚ ﺧﻄﺎ ﻣﻲ ﺷﻮﺩ؟‬

‫;‪Var a:integer‬‬ ‫ﺩ(‪B:=a/B‬‬ ‫ﺝ(‪B:=a-B‬‬ ‫ﺏ(‪B:=a Mod B‬‬ ‫ﺍﻟﻒ(‪B:=a*B‬‬

‫;‪B :Real‬‬

‫‪(A SHR 1) SHL 1 = A‬‬ ‫ﺗﺤﻘﻴﻖ‪ :‬ﺁﻳﺎ ﺭﺍﺑﻄﻪ ﺭﻭﺑﺮﻭ ﻫﻤﻴﺸﻪ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪23‬‬
‫دﺳﺘﻮرات ورودي‪ /‬ﺧﺮوﺟـﯽ ‪:‬‬
‫ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺩﺳﺘﻮﺭﺍﺕ ‪ Read‬ﻭ ‪ Readln‬ﺑﺮﺍﻱ ﺩﺭﻳﺎﻓﺖ ﺩﺍﺩﻩ ﻫﺎ ﺍﺯ ﻭﺭﻭﺩﻱ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻛﺎﺭ ﻣﻲ ﺭﻭﻧﺪ‪.‬ﺍﻳـﻦ ﺩﻭ ﺩﺳـﺘﻮﺭ ﺑـﺎ ﻫـﻢ ﺩﺭ ﻳـﻚ‬
‫ﻣﻮﺭﺩ ﺍﺧﺘﻼﻑ ﺩﺍﺭﻧﺪ ﻛﻪ ﺑﺤﺚ ﺧﻮﺍﻫﺪ ﺷﺪ ﻭ ﺑﻘﻴﻪ ﻣﻮﺍﺭﺩ ﻭ ﻧﻜﺎﺕ ﺁﻧﻬﺎ ﺷﺒﻴﻪ ﻫﻢ ﺍﺳﺖ‪.‬‬
‫;)ﻣﺘﻐﻴﺮ(‪READ‬‬ ‫;)ﻣﺘﻐﻴﺮ(‪ READLN‬ﻳﺎ‬
‫ﻧﻜﺘﻪ( ﺩﺍﺩﻩ ﻫﺎﻳﻲ ﻛﻪ ﺍﺯ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﻭﺍﺭﺩ ﻣﻲ ﺷﻮﺩ ﺑﺎﻳﺪ ﺑﺎ ﻧﻮﻉ ﻣﺘﻐﻴﺮﺫﻛﺮ ﺷﺪﻩ ﺩﺭ ﺩﺳﺘﻮﺭ ﻭﺭﻭﺩﻱ ﻣﻄﺎﺑﻘﺖ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﺑﻪ ﻋﻨـﻮﺍﻥ ﻣﺜـﺎﻝ ﺍﮔـﺮ‬
‫ﻋﺪﺩ ‪ 12.9‬ﺍﺯ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﻭﺍﺭﺩ ﻣﻲ ﺷﻮﺩ ﻣﺘﻐﻴﺮ ﻣﻮﺟﻮﺩ ﺩﺭ ﺩﺳﺘﻮﺭ ﻭﺭﻭﺩﻱ ﻫﻢ ﺑﺎﻳﺪ ﺍﻋﺸﺎﺭﻱ ﺑﺎﺷﺪ‪ .‬ﺩﺭ ﻏﻴﺮ ﺍﻳﻦ ﺻﻮﺭﺕ ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﺻﺎﺩﺭ ﻣـﻲ‬
‫ﺷﻮﺩ ﻭ ﺑﺮﻧﺎﻣﻪ ﻗﻄﻊ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺑﻪ ﺧﻄﺎﻫﺎﻳﻲ ﻛﻪ ﺩﺭ ﺣﻴﻦ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺭﺥ ﻣﻲ ﺩﻫﺪ ﺧﻄﺎﻱ ﺯﻣﺎﻥ ﺍﺟﺮﺍ ﻣﻲ ﮔﻮﻳﻨﺪ‪Run Time Error .‬‬
‫ﻣﺜﺎﻝ‪ :‬ﺍﮔﺮ ﺩﺭ ﺍﺯﺍﻱ ﺩﺳﺘﻮﺭ ;)‪ ) Read(A,B,C‬ﻣﺘﻐﻴﺮ ‪ A‬ﺍﺯ ﻧﻮﻉ ﺻﺤﻴﺢ ﻭ ﻣﺘﻐﻴﺮ ‪ B‬ﺍﺯ ﻧﻮﻉ ﻛﺎﺭﺍﻛﺘﺮﻱ ﻭ ﻣﺘﻐﻴﺮ ‪ C‬ﺍﺯ ﻧﻮﻉ ﺭﺷـﺘﻪ ﺍﻳـﻲ ﺍﺳـﺖ(‬
‫ﺩﺍﺩﻩ ﻫﺎﻱ ‪ 12 5 231‬ﻭﺍﺭﺩ ﺷﻮﺩ ﺁﻧﮕﺎﻩ ﻋﺪﺩ ‪ ١٢‬ﻭﺍﺭﺩ ﻣﺘﻐﻴﺮ ‪ A‬ﻭ ﻛﺎﺭﺍﻛﺘﺮ ‪ 5‬ﻭﺍﺭﺩ ﻣﺘﻐﻴﺮ ‪ B‬ﻭ ﺭﺷﺘﻪ ’‪ ’231‬ﺩﺭ ﻣﺘﻐﻴﺮ ‪ C‬ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﻫﻨﮕﺎﻡ ﻭﺍﺭﺩ ﻛﺮﺩﻥ ﺩﺍﺩﻩ ﻫﺎ ﻧﻤﻲ ﺗﻮﺍﻧﻴﺪ ﻳﻚ ﻋﺒﺎﺭﺕ ﺑﻨﻮﻳﺴﻴﺪ‪ .‬ﻣﺜﺎﻝ ﺩﺭ ﺍﺯﺍﻱ ﺩﺳﺘﻮﺭ )‪ Readln(A‬ﺍﮔﺮ ‪ A‬ﺍﺯ ﻧﻮﻉ ﺍﻋـﺸﺎﺭﻱ ﺑﺎﺷـﺪ ﻧﻤـﻲ‬
‫ﺗﻮﺍﻧﻴﺪ ‪ 12+3‬ﺑﻨﻮﻳﺴﻴﺪ ﺍﻣﺎ ﻣﻲ ﺗﻮﺍﻥ ‪ 12.3E-1‬ﺭﺍ ﻭﺍﺭﺩ ﻛﺮﺩ‪) .‬ﻧﻤﺎﻳﺶ ﺍﻋﺪﺍﺩ ﺑﻪ ﺻﻮﺭﺕ ﻋﻠﻤﻲ(‬
‫;‪Const H=12‬‬
‫ﻧﻜﺘﻪ( ﺩﺭ ﺩﺳﺘﻮﺭﺍﺕ ﻭﺭﻭﺩﻱ ﻧﻤﻲ ﺗﻮﺍﻧﻴﺪ ﻋﺒﺎﺭﺕ ﺑﻨﻮﻳﺴﻴﺪ‪ Read(A+1) .‬ﺧﻄﺎ ﺩﺍﺭﺩ‪.‬‬
‫;‪Z:Real=18.2‬‬
‫‪.‬‬ ‫ﻧﻜﺘﻪ(ﺍﺯ ﺛﺎﺑﺖ ﺑﺪﻭﻥ ﻧﻮﻉ ﻧﻴﺰ ﻧﻤﻲ ﺗﻮﺍﻧﻴﺪ ﺩﺭ ﺩﺳﺘﻮﺭﺍﺕ ﻭﺭﻭﺩﻱ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﺪ‪ .‬ﺍﻣﺎ ﺛﺎﺑﺖ ﺑﺎﻧﻮﻉ ﺧﻄﺎﻳﻲ ﻧﺪﺍﺭﺩ‪.‬‬
‫‪.‬‬ ‫ﻧﻜﺘﻪ(ﺍﮔﺮ ﺩﺳﺘﻮﺭ ‪ Readln‬ﺭﺍ ﺑﺪﻭﻥ ﺫﻛﺮ ﻣﺘﻐﻴﺮ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺑﻨﻮﻳﺴﻴﻢ ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﺑﺮﻧﺎﻣﻪ‬
‫‪.‬‬
‫ﻣﻮﻗﺘﺎ ﻣﺘﻮﻗﻒ ﻣﻲ ﺷﻮﺩ ﺗﺎ ﻛﺎﺭﺑﺮ ﻛﻠﻴﺪ‪ Enter‬ﺭﺍ ﺑﺰﻧﺪ ﺗﺎ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺍﺩﺍﻣﻪ ﭘﻴﺪﺍ ﻛﻨﺪ‪.‬‬
‫ﺧﻄﺎ ;)‪Read(H‬‬
‫;‪Readln‬‬
‫;)‪Read(Z‬‬ ‫ﺗﺤﻘﻴﻖ‪ :‬ﺍﮔﺮ ﻣﺘﻐﻴﺮ ‪ S‬ﺍﺯ ﻧﻮﻉ ﺭﺷﺘﻪ ﺍﻳﻲ ﺑﺎﺷﺪ ﻭ ﺩﺭ ﺍﺯﺍﻱ ﺩﺳﺘﻮﺭ ;)‪ Read(S‬ﻋﺒﺎﺭﺕ ‪ 25*2‬ﺭﺍ ﻭﺍﺭﺩ ﻛﻨﻴﻢ‬
‫ﭼﻪ ﺍﺗﻔﺎﻗﻲ ﻣﻲ ﺍﻓﺘﺪ؟‬
‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﺩﺍﺩﻩ ﻫﺎﻱ ﻭﺭﻭﺩﻱ ﻛﻤﺘﺮ ﺍﺯ ﻣﺘﻐﻴﺮﻫﺎﻱ ﺫﻛﺮ ﺷﺪﻩ ﺩﺭ ﺩﺳﺘﻮﺭ ‪ read‬ﻳﺎ ‪ readln‬ﺑﺎﺷﺪ ﺭﺍﻳﺎﻧﻪ ﺑﺮﺍﻱ ﺩﺭﻳﺎﻓﺖ ﺑﻘﻴﻪ ﺩﺍﺩﻩ ﻫـﺎ ﻣﻨﺘﻈـﺮ ﻣـﻲ‬
‫‪Read(a,b,c,d); ==è 12 13.5‬‬ ‫ﻣﺎﻧﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﺩﺍﺩﻩ ﻫﺎﻱ ﻭﺍﺭﺩ ﺷﺪﻩ ﺑﻴﺸﺘﺮ ﺍﺯ ﺗﻌﺪﺍﺩ ﻣﺘﻐﻴﺮﻫﺎﻱ ﺫﻛﺮﺷﺪﻩ ﺩﺭ ﺩﺳﺘﻮﺭ ﻭﺭﻭﺩﻱ ‪ Readln‬ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ ﺩﺍﺩﻩ ﻫﺎﻱ ﺍﺿـﺎﻓﻲ ﺣـﺬﻑ ﻣـﻲ‬
‫ﺷﻮﻧﺪ‪.‬‬
‫‪ Readln(a,b); ===è 17 13 25 19‬ﺩﺍﺩﻩ ﻫﺎﻱ ‪ ١٧‬ﻭ ‪ ١٣‬ﺩﺭ ‪ a‬ﻭ ‪ b‬ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩﻭ ﺑﻘﻴﻪ ﺣﺬﻑ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﻧﻜﺘﻪ(ﺍﮔﺮ ﺩﺍﺩﻩ ﻫﺎﻱ ﻭﺍﺭﺩ ﺷﺪﻩ ﺍﺯ ﺗﻌﺪﺍﺩ ﻣﺘﻐﻴﺮﻫﺎﻱ ﺫﻛﺮﺷﺪﻩ ﺩﺭ ﺩﺳﺘﻮﺭ ﻭﺭﻭﺩﻱ ‪ Read‬ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ ﺩﺍﺩﻩ ﻫﺎﻱ ﺍﺿﺎﻓﻲ ﺣﺬﻑ ﻧﻤﻲ ﺷﻮﻧﺪ ﺑﻠﻜـﻪ‬
‫ﺩﺭ ﺣﺎﻓﻈﻪ ﻣﻲ ﻣﺎﻧﻨﺪ ﺗﺎ ﺩﺭ ﺩﺳﺘﻮﺭﺍﺕ ‪ Read‬ﻳﺎ ‪ Readln‬ﺑﻌﺪﻱ ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﻧﺪ‪.‬‬
‫‪Read(a,b); =è12 15 17 18‬‬ ‫‪Read(a); ==è 45 32 21 70 30‬‬ ‫ﻣﺜﺎﻝ‪:‬‬
‫……‬ ‫‪…..‬‬
‫;)‪Read(C‬‬ ‫;)‪Readln(K,M‬‬
‫……‬ ‫‪…..‬‬
‫;)‪Readln(H,F‬‬ ‫;)‪Read(Z‬‬

‫ﻧﻜﺘﻪ( ﺍﺯ ﻣﺘﻐﻴﺮ ﻧﻮﻉ ‪ Boolean‬ﻧﻤﻲ ﺗﻮﺍﻥ ﺩﺭ ﺩﺳﺘﻮﺭﺍﺕ ﻭﺭﻭﺩﻱ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ‪ .‬ﻣﺜﻼ ﺍﮔﺮ ﻣﺘﻐﻴﺮ ‪ B‬ﺍﺯ ﻧﻮﻉ ‪ Boolean‬ﺑﺎﺷﺪ ﺩﺳﺘﻮﺭ‬
‫;)‪ Read(B‬ﺧﻄﺎ ﺍﺳﺖ‪.‬‬
‫ﺑﺮﺍﻱ ﭼﺎﭖ ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮﻫﺎ ﻳﺎ ﻋﺒﺎﺭﺕ ﻳﺎ ﺛﺎﺑﺘﻬﺎ ﻣﻲ ﺗﻮﺍﻥ ﺍﺯ ﺩﺳﺘﻮﺭﺍﺕ ‪ Write‬ﻳﺎ ‪ Writeln‬ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ‪.‬‬
‫ﺗﻔﺎﻭﺕ ﺩﺳﺘﻮﺭ ‪ Write‬ﻭ ‪ Writeln‬ﺩﺭ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺩﺭ ﺩﺳﺘﻮﺭ ‪ Writeln‬ﭘﺲ ﺍﺯ ﭼﺎﭖ ﻣﻘﺎﺩﻳﺮ ﺩﺭ ﻣﺎﻧﻴﺘﻮﺭ ﻣﻜﺎﻥ ﻧﻤﺎ ﺑﻪ ﺍﺑﺘﺪﺍﻱ ﺳﻄﺮ ﺑﻌـﺪﻱ‬
‫ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮﺩ‪ .‬ﺍﻣﺎ ﺩﺭ ﺩﺳﺘﻮﺭ ‪ Write‬ﻣﻜﺎﻥ ﻧﻤﺎ ﺩﺭ ﻫﻤﺎﻥ ﺳﻄﺮ ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ‪.‬ﺩﺭﻭﺍﻗﻊ ﻣﻲ ﺗـﻮﺍﻥ ﮔﻔـﺖ ﻛـﻪ ﺩﺭ ﺩﺳـﺘﻮﺭ ‪ Writeln‬ﭘـﺲ ﺍﺯ‬
‫ﭼﺎﭖ ﻣﻘﺎﺩﻳﺮ ﺑﺮ ﺭﻭﻱ ﻣﺎﻧﻴﺘﻮﺭ ﺩﻭ ﻛﺎﺭﺍﻛﺘﺮ ‪ CR‬ﻭ ‪ LF‬ﺭﺍ ﺑﻪ ﻣﺎﻧﻴﺘﻮﺭ ﻣﻲ ﻓﺮﺳﺘﺪ‪Writeln; == Write(#10#13);.‬‬
‫‪ CR‬ﺑﺎ ﻛﺪ ﺍﺳﻜﻲ ‪ ١٣‬ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﻣﻜﺎﻥ ﻧﻤﺎ ) ﭼﺮﺍﻍ ﭼﺸﻤﻚ ﺯﻥ( ﺑﻪ ﺍﺑﺘﺪﺍﻱ ﺳﻄﺮ ﻓﻌﻠﻲ ﺑﻴﺎﻳﺪ ﻭ ‪ LF‬ﺑﺎ ﻛﺪ ﺍﺳـﻜﻲ ‪ ١٠‬ﺑﺎﻋـﺚ ﻣـﻲ ﺷـﻮﺩ‬
‫ﻣﻜﺎﻥ ﻧﻤﺎ ﻳﻚ ﺳﻄﺮ ﭘﺎﺋﻴﻦ ﺑﻴﺎﻳﺪ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪24‬‬
‫ﻣﺜﺎﻝ( ﺩﺳﺘﻮﺭ;)‪ Writeln(A,’ABC’,5*2+3‬ﻣﻘﺪﺍﺭ ﻣﻮﺟﻮﺩ ﺩﺭ ﻣﺘﻐﻴﺮ ‪ A‬ﺭﺍ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ ﻭ ﺑﻪ ﺩﻧﺒﺎﻝ ﺁﻥ ﺭﺷـﺘﻪ ‪ ABC‬ﻭ ﻋـﺪﺩ ‪ ١٣‬ﺭﺍ‬
‫ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ ﻭ ﻳﻚ ﺳﻄﺮ ﭘﺎﺋﻴﻦ ﻣﻲ ﺭﻭﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺩﺳﺘﻮﺭ ;‪ Writeln‬ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﻣﻜﺎﻥ ﻧﻤﺎ ﻳﻚ ﺳﻄﺮ ﭘﺎﻳﻴﻦ ﺑﺮﻭﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺩﺳﺘﻮﺭ ;)‪ Write(False<True‬ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﻋﺒﺎﺭﺕ ‪ TRUE‬ﺑﺮ ﺭﻭﻱ ﻣﺎﻧﻴﺘﻮﺭ ﻇﺎﻫﺮ ﺷﻮﺩ‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﻣﺘﻐﻴﺮﻫﺎﻱ ﺍﺯ ﻧـﻮﻉ ﺑـﻮﻟﻴﻦ‬
‫ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺩﺭ ﺩﺳﺘﻮﺭﺧﺮﻭﺟﻲ ﻗﺮﺍﺭ ﺩﺍﺩ‪.‬‬
‫ﻧﻜﺘﻪ(ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﻱ ﺭﺍ ﺑﻮﺳﻴﻠﻪ ﺩﺳﺘﻮﺭ ‪ Write‬ﻳﺎ ‪ Writeln‬ﺩﺭ ﺧﺮﻭﺟﻲ ﭼﺎﭖ ﻣﻲ ﻛﻨﻴﻢ ﺍﻋـﺪﺍﺩ ﺑـﻪ ﺻـﻮﺭﺕ ﻋﻠﻤـﻲ ﭼـﺎﭖ ﻣـﻲ‬
‫ﺷﻮﻧﺪ‪ .‬ﺩﺭ ﺍﺩﺍﻣﻪ ﺟﻬﺖ ﭼﺎﭖ ﺁﻧﻬﺎ ﺑﻪ ﺻﻮﺭﺕ ﻣﻤﻴﺰ ﺛﺎﺑﺖ ﺑﺤﺚ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﺗﺤﻘﻴﻖ( ﺩﺳﺘﻮﺭ ;)‪ Writeln(#7‬ﻭ ;)‪ Write(#13#10‬ﭼﻪ ﭼﻴﺰ ﺭﺍ ﺩﺭ ﺧﺮﻭﺟﻲ ﭼﺎﭖ ﻣﻲ ﻛﻨﻨﺪ؟‬
‫ﻧﻜﺘﻪ( ﺩﺳﺘﻮﺭ ;)’’’’(‪ Write‬ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﻋﺒﺎﺭﺕ ’ ﺑﺮﺭﻭﻱ ﻣﺎﻧﻴﺘﻮﺭ ﭼﺎﭖ ﺷﻮﺩ‪ .‬ﺩﺳﺘﻮﺭ ;)’’’‪ Writeln(’’’,,‬ﭼـﻪ ﭼﻴـﺰﻱ ﺭﺍ ﭼـﺎﭖ‬
‫ﻣﻲ ﻛﻨﺪ؟ ﺩﺳﺘﻮﺭ;)’’’(‪ Write‬ﭼﻪ ﭼﻴﺰﻱ ﺭﺍ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ؟‬
‫ﻓﺮﻣﺖ ﺑﻨﺪي ﺧﺮوﺟﯽ‪:‬‬
‫ﺷﻤﺎ ﻣﻲ ﺗﻮﺍﻧﻴﺪ ﺩﺍﺩﻩ ﻫﺎﻱ ﺭﺍ ﻛﻪ ﻗﺮﺍﺭ ﺍﺳﺖ ﺩﺭ ﻣﺎﻧﻴﺘﻮﺭ ﭼﺎﭖ ﻛﻨﻴﺪ ﺑﺎ ﻳﻚ ﻓﺮﻣﺖ ﺧﺎﺻﻲ ﭼﺎﭖ ﻛﻨﻴﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪ :‬ﺩﺳﺘﻮﺭ ;)’‪ Writeln(’MAHDI‬ﻋﺒﺎﺭﺕ ‪ MAHDI‬ﺭﺍ ﺩﺭ ﺍﺑﺘﺪﺍﻱ ﺳﻄﺮ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‪ .‬ﺍﻣﺎ ﺩﺳﺘﻮﺭ ;)‪Writeln(’MAHDI’:8‬‬
‫ﻋﺒﺎﺭﺕ ‪MAHDI‬ٱٱٱ ﺭﺍ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‪) .‬ٱ ﻧﺸﺎﻧﻪ ﺟﺎ ﺧﺎﻟﻲ ﺍﺳﺖ(‪.‬ﻋﺪﺩ ‪ ٨‬ﻧﺸﺎﻧﻪ ﻳﻚ ﺑﺎﻧﺪ)ﻣﻴﺪﺍﻥ( ﻫﺸﺘﺎﻳﻲ ﺍﺳـﺖ ﻛـﻪ ﻋﺒـﺎﺭﺕ ‪ MAHDI‬ﺍﺯ‬
‫ﺳﻤﺖ ﺭﺍﺳﺖ ﺁﻥ ﭘﺮ ﻣﻲ ﺷﻮﺩ ﻭ ﺟﺎ ﻫﺎﻱ ﺧﺎﻟﻲ ﺁﻥ ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ‪.‬‬
‫‪M A H D I‬‬
‫ﻣﺜﺎﻝ( ;)‪ Write(124:7‬ﻋﺪﺩ ‪ ١٢٤‬ﺭﺍ ﺩﺭﻳﻚ ﺑﺎﻧﺪ ‪ ٧‬ﺗﺎﻳﻲ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﺩﺭ ﻧﻬﺎﻳﺖ ‪ ٤‬ﺟﺎ ﺧﺎﻟﻲ ﺩﺭ ﺳﻤﺖ ﭼﭗ ﻋﺪﺩ ﻣﻲ ﻣﺎﻧﺪ‪.‬‬
‫ﺍﻋﺪﺍﺩ ﺻﺤﻴﺢ ﻭ ﺭﺷﺘﻪ ﻫﺎ ﺩﺍﺭﺍﻱ ﻳﻚ ﺑﺎﻧﺪ ﺑﺮﺍﻱ ﻓﺮﻣﺖ ﺑﻨﺪﻱ ﻫﺴﺘﻨﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﺑﺎﻧﺪ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺍﺯ ﺗﻌﺪﺍﺩ ﻛﺎﺭﺍﻛﺘﺮﻱ ﻛﻪ ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ ﻛﻤﺘﺮ ﺑﺎﺷﺪ ﺑﺎﻧﺪ ﺻﺮﻑ ﻧﻈﺮ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻣﺜﺎﻝ(ﺩﺳﺘﻮﺭ ;)‪ Write(1258:3‬ﻋﺪﺩ ‪ ١٢٥٨‬ﺭﺍ ﺑﺪﻭﻥ ﺑﺎﻧﺪ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‪ ).‬ﺧﻄﺎﻳﻲ ﺭﺥ ﻧﻤﻲ ﺩﻫﺪ(‪.‬‬
‫ﺑﺮﺍﻱ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﻱ ﻧﻴﺰ ﻣﻲ ﺗﻮﺍﻥ ﭘﻬﻨﺎﻱ ﺑﺎﻧﺪ ﺗﻌﺮﻳﻒ ﻛﺮﺩ‪ .‬ﻛﻪ ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﻱ ﺩﺭ ﺧﺮﻭﺟﻲ ﺑﻪ ﺻﻮﺭﺕ ﻣﻤﻴﺰ ﺛﺎﺑـﺖ ﻧﻤـﺎﻳﺶ ﺩﺍﺩﻩ‬
‫ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﻱ ﺩﺍﺭﺍﻱ ﺩﻭ ﭘﻬﻨﺎﻱ ﺑﺎﻧﺪ ﻫﺴﺘﻨﺪ ‪.‬‬
‫ﻣﺜﺎﻝ( ;)‪ Writeln(126.2314:10:2‬ﻛﻪ ﺑﺎﻧﺪ ﺍﻭﻟﻲ ) ﻋﺪﺩ ‪ (١٠‬ﻣﺮﺑﻮﻁ ﺑﻪ ﻛﻞ ﻋﺪﺩ ﺍﺳﺖ ﻭ ﺑﺎﻧﺪ ﺩﻭﻣﻲ ﻣﺮﺑﻮﻁ ﺑﻪ ﺗﻌﺪﺍﺩ ﺍﻋـﺸﺎﺭ ﺁﻥ ﺍﺳـﺖ‪.‬‬
‫ﺩﺳﺘﻮﺭ ﺫﻛﺮ ﺷﺪﻩ ﻋﺪﺩ ‪ 126.23‬ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫‪1 2 6 . 2 3‬‬
‫ﻧﻜﺘﻪ( ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺍﻋﺸﺎﺭ ﺍﺿﺎﻓﻪ ﺩﻭﺭ ﺭﻳﺨﺘﻪ ﻣﻲ ﺷﻮﺩ ﻋﺪﺩ ﺩﺭ ﺍﻋﺸﺎﺭ ﺑﺎﻗﻲ ﻣﺎﻧﺪﻩ ﮔﺮﺩ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻣﺜﺎﻝ( ;)‪ Writeln(125.4751:7:2‬ﺩﺭ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﻋﺒﺎﺭﺕ ‪ 125.48‬ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ ﺩﺭ ﺑﺎﻧﺪ ﺍﻭﻟﻲ ﺗﻌﺪﺍﺩ ﺭﻗﻢ ﻫﺎ ﺍﺯ ﺗﻌﺪﺍﺩ ﺑﺎﻧﺪ ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ ﺑﺎﻧﺪ ﻣﺮﺑﻮﻁ ﺑﻪ ﻛﻞ ﻋﺪﺩ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﻤﻲ ﺷﻮﺩ‪.‬‬
‫‪Writeln(54.456:3:5); ==è 54.45600‬‬ ‫‪Write(19.96:2:1); ==è 20.0‬‬
‫‪Writeln(19.152:0:1); ==è 19.2‬‬ ‫‪Write(17.184:5:0); ==è 17‬‬
‫‪Write(19.512:1:0); ==è 20‬‬ ‫‪Writeln(3.451:6:1); ==è 3.5‬‬

‫ﺗﺤﻘﻴﻖ‪ :‬ﺩﺳﺘﻮﺭ ;)‪ Write(True‬ﭼﻪ ﭼﻴﺰ ﺭﺍ ﺩﺭ ﺧﺮﻭﺟﻲ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ؟‬

‫;‪Y:=2.36‬‬ ‫ﺗﺴﺖ‪ :‬ﺧﺮﻭﺟﻲ ﻗﻄﻌﻪ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ‪:‬‬
‫;)‪Writeln(Y:4:1‬‬
‫ﺩ(‪2.4‬‬ ‫ﺝ(‪2.36‬‬ ‫ﺏ(‪2.30‬‬ ‫ﺍﻟﻒ( ‪2.3‬‬
‫ﺗﺴﺖ‪ :‬ﺍﮔﺮ ﻣﺘﻐﻴﺮ ‪ Pi‬ﺍﺯ ﻧﻮﻉ ‪ Real‬ﺑﺎﺷﺪ ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭ ‪ Write‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫;‪Pi:=3.1416‬‬
‫;)‪Write(Pi:0:3‬‬ ‫ﺩ(‪0‬‬ ‫ﺝ(‪3‬‬ ‫ﺏ(‪3.141‬‬ ‫ﺍﻟﻒ(‪3.142‬‬

‫ﻧﻜﺘﻪ( ;)‪ Write(#13#10‬ﻣﻌﺎﺩﻝ ﺩﺳﺘﻮﺭ ;‪ Writeln‬ﺍﺳﺖ‪.‬‬

 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪25‬‬
‫دﺳﺘﻮرات در زﺑﺎن ﭘﺎﺳﮑﺎل‪:‬‬
‫ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺑﻴﻦ ﻫﺮ ﺩﺳﺘﻮﺭ ﺑﺮﺍﻱ ﺟﺪﺍ ﻛﺮﺩﻥ ﺩﺳﺘﻮﺭﺍﺕ ﺍﺯ ﻳﻜﺪﻳﮕﺮ ﻋﻼﻣﺖ ; ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﺍﻳﻦ ﻓﻜﺮ ﻛﻪ ﺩﺭ ﺍﻧﺘﻬﺎﻱ ﻫﺮ ﺧﻂ ﺑﺎﻳـﺪ‬
‫ﻳﻚ ﻋﻼﻣﺖ ; ﻗﺮﺍﺭ ﺩﺍﺩ ﺍﺷﺘﺒﺎﻩ ﺍﺳﺖ‪ .‬ﺁﺧﺮﻳﻦ ﺩﺳﺘﻮﺭﺍﻟﻌﻤﻞ ﻣﻲ ﺗﻮﺍﻧﺪ ; ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷـﺪ‪ .‬ﻛﻠﻤـﺎﺕ ‪ Begin‬ﻭ ‪ End‬ﺩﺳـﺘﻮﺍﻟﻌﻤﻞ ﻧﻴـﺴﺘﻨﺪ ﻭ ﺗﻨﻬـﺎ‬
‫ﺑﺮﺍﻱ ﻣﺸﺨﺺ ﻛﺮﺩﻥ ﺷﺮﻭﻉ ﻭ ﭘﺎﻳﺎﻥ ﺑﻼﻙ ﺑﻪ ﻛﺎﺭ ﻣﻲ ﺭﻭﻧﺪ‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﺑﻌﺪ ﺍﺯ ‪ Begin‬ﻭ ﻗﺒﻞ ﺍﺯ ‪ End‬ﺍﺯ ﻋﻼﻣﺖ ; ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻲ ﺷﻮﺩ‪.‬‬
‫ﺩﺳﺘﻮﺭﺍﺕ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺑﻪ ﺩﻭ ﺩﺳﺘﻪ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ‪:‬‬
‫‪ v‬ﺩﺳﺘﻮﺭﺍﺕ ﺳﺎﺩﻩ‪ -١ :‬ﺩﺳﺘﻮﺭ ﺍﻧﺘﺴﺎﺏ ‪ -٢‬ﺩﺳﺘﻮﺭ ﭘﺮﺵ‪ -٣ Goto‬ﺩﺳﺘﻮﺭ ﻓﺮﺍﺧﻮﺍﻧﻲ ﭘﺮﺩﺍﺯﻩ)ﺯﻳﺮﺭﻭﺍﻝ(‬
‫‪ v‬ﺩﺳﺘﻮﺭ ﺳﺎﺧﺘﺎﺭﻱ‪:‬‬
‫‪ ü‬ﺩﺳﺘﻮﺭ ﻣﺮﻛﺐ‪ :‬ﺩﺳﺘﻮﺭ ﻣﺮﻛﺐ‪ ،‬ﺍﺯ ﺗﻌﺪﺍﺩﻱ ﺩﺳﺘﻮﺭ ﺩﻳﮕﺮ ﻛﻪ ﺑﻴﻦ ﻛﻠﻤﺎﺕ ﺫﺧﻴﺮﻩ ﺷﺪﺓ ‪ Begin‬ﻭ ‪ End‬ﻗﺮﺍﺭ ﮔﺮﻓﺘﻪ ﺍﻧﺪ ﺗـﺸﻜﻴﻞ‬
‫ﺷﺪﻩ ﺍﺳﺖ‪.‬‬
‫‪Begin‬‬ ‫ﺑﻪ ﺗﻮﺭﻓﺘﮕﻲ ﺩﺳﺘﻮﺭﺍﺕ ﺩﻗﺖ ﻛﻨﻴﺪ‪).‬ﻛﻨﮕﺮﻩ ﺩﺍﺭ ﻛﺮﺩﻥ(‬
‫;‪A:=A+1‬‬
‫ﺩﺳﺘﻮﺭ ﻗﺒﻞ ﺍﺯ ‪ End‬ﻣﻲ ﺗﻮﺍﻧﺪ ; ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫;)‪Writeln(A‬‬
‫‪A:=B*2‬‬ ‫ﭼﻮﻥ ﺩﺳﺘﻮﺭ ﻣﺮﻛﺐ ﺑﻪ ﻋﻨﻮﺍﻥ ﻳﻚ ﺩﺳﺘﻮﺭ ﺩﺭﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮﺩ ﺑﺎﻳﺪ ﺍﺯ ﺩﺳﺘﻮﺭﺍﺕ‬
‫;‪End‬‬ ‫ﺩﻳﮕﺮ ﺟﺪﺍ ﺷﻮﺩ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺑﻌﺪ ﺍﺯ ‪ End‬ﻋﻼﻣﺖ ; ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ‪.‬‬

‫ﺩﺳﺘﻮﺭﺍﺕ ﺷﺮﻃﻲ‪ :‬ﺩﺭ ﺍﺩﺍﻣﻪ ﺑﺤﺚ ﻣﻲ ﺷﻮﺩ‪.‬‬ ‫‪ü‬‬

‫ﺩﺳﺘﻮﺭﺍﺕ ﺗﻜﺮﺍﺭ‪ :‬ﺩﺭ ﺍﺩﺍﻣﻪ ﺑﺤﺚ ﻣﻲ ﺷﻮﺩ‪.‬‬ ‫‪ü‬‬
‫ﺩﺳﺘﻮﺭ‪ :With‬ﻛﻪ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﭘﻴﺸﺮﻓﺘﻪ ﺑﺤﺚ ﻣﻲ ﺷﻮﺩ‪.‬‬ ‫‪ü‬‬

‫دﺳﺘﻮرات ﺷـﺮﻃﯽ‪:‬‬

‫ﺩﺳﺘﻮﺭﺍﺕ ﺷﺮﻃﻲ ﺩﺳﺘﻮﺭﺍﺗﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺑﺮﺍﻱ ﺍﺟﺮﺍﻱ ﻳﻚ ﻳﺎ ﭼﻨﺪ ﺩﺳﺘﻮﺭ ﺩﻳﮕﺮ ﺷﺮﻁ ﻗﺮﺍﺭ ﻣﻲ ﺩﻫﺪ‪ .‬ﺩﺳـﺘﻮﺭﺍﺕ ﺷـﺮﻃﻲ ﺑـﻪ ﺩﻭ‬
‫ﺩﺳﺘﻪ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ ‪ - ١‬ﺩﺳﺘﻮﺭ ‪ - ٢ If-Then‬ﺩﺳﺘﻮﺭ ‪Case‬‬
‫‪ -1‬دﺳﺘﻮر ‪: If-Then‬‬
‫‪If‬‬ ‫‪ then‬ﺷﺮط)ﻫﺎ(‬ ‫ﺩﺳﺘﻮﺭ ‪ If‬ﺧﻮﺩ ﺑﻪ ﺩﻭ ﺷﻜﻞ ﺍﺳﺖ ‪ If –then -١‬ﻭ ‪If then Else -٢‬‬
‫ﺷﻜﻞ ﻛﻠﻲ ﺩﺳﺘﻮﺭ ‪:If then‬‬
‫; ﯾﮏ دﺳﺘﻮر ﺳﺎده ﯾﺎ ﯾﮏ دﺳﺘﻮر ﺳﺎﺧﺘﺎري‬
‫ﺩﺭ ﺷﻜﻞ ﻛﻠﻲ ﺩﺳﺘﻮﺭ ﺭﻭﺑﺮﻭ ﺩﺳﺘﻮﺭ ﺳﺎﺩﻩ ﻳﺎ ﺩﺳﺘﻮﺭ ﺳﺎﺧﺘﺎﺭﻱ ﺩﺭﺻﻮﺭﺗﻲ ﺍﻧﺠﺎﻡ‬
‫ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺷﺮﻁ)ﻫﺎ( ‪ True‬ﺑﺎﺷﺪ‪.‬‬
‫‪If‬‬ ‫‪A>10 then‬‬
‫;)’‪Write(’Ali‬‬ ‫ﻣﺜﺎﻝ‪ :‬ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺩﺭﺻﻮﺭﺗﻲ ﺭﺷﺘﺔ ‪ Ali‬ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ ﻛﻪ ‪ A>10‬ﺑﺎﺷﺪ‪.‬‬

‫‪IF (Z<>0) Xor (H<=5) then‬‬ ‫ﻧﻜﺘﻪ( ﻓﻘﻂ ﻳﻚ ﺩﺳﺘﻮﺭ ﺑﻌﺪ ﺍﺯ ‪ then‬ﻣﺮﺑﻮﻁ ﺑﻪ ‪ IF‬ﺍﺳﺖ ﻭ ﺍﻳﻦ ﺩﺳﺘﻮﺭﻣﻴﺘﻮﺍﻧﺪ‬
‫‪Begin‬‬ ‫ﺩﺳﺘﻮﺭ ﻣﺮﻛﺐ‬
‫ﺳﺎﺩﻩ ﻳﺎ ﻣﺮﻛﺐ ﻳﺎ ﺳﺎﺧﺘﺎﺭﻱ ﺑﺎﺷﺪ‪.‬‬
‫;)’*’(‪Writeln‬‬ ‫‪IF S<>’ALI’ then‬‬
‫;‪A:=A+4‬‬ ‫ﻧﻜﺘﻪ( ﺩﺳﺘﻮﺭ ‪ If‬ﺑﺎ ﺑﻼﻙ ﻣﺮﺑﻮﻁ ﺑﻪ ﺁﻥ‬
‫;)’*’(‪Write‬‬
‫;)‪Read(F‬‬ ‫;)’‪Write(’M‬‬ ‫ﻛﻼ ﻳﻚ ﺩﺳﺘﻮﺭ ﻣﺤﺴﻮﺏ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫;‪End‬‬

‫ﻧﻜﺘﻪ( ﺩﻗﺖ ﻛﻨﻴﺪ ﻛﻪ ﺑﻌﺪ ﺍﺯ ‪ Then‬ﻋﻼﻣﺖ ; ﻧﺒﺎﻳﺪ ﺑﺎﺷﺪ‪ .‬ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ ﻋﻼﻣﺖ ; ﻗﺮﺍﺭ ﮔﻴﺮﺩ ﻫﻴﭻ ﺧﻄﺎﻳﻲ ﺭﺥ ﻧﻤﻲ ﺩﻫﺪ ﺑﻠﻜﻪ ﻋﻼﻣﺖ ; ﺑﻪ‬
‫ﻋﻨﻮﺍﻥ ﺗﻚ ﺩﺳﺘﻮﺭ ‪ If‬ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﺧﻮﺍﻫﺪ ﺷﺪ‪).‬ﺧﻄﺎﻱ ﻣﻨﻄﻘﻲ(‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪26‬‬
‫; ‪IF B>3 then‬‬ ‫ﻣﺜﺎﻝ( ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺩﺳﺘﻮﺭ ;)’*’(‪ Write‬ﻣﺮﺑﻮﻁ ﺑﻪ ‪ IF‬ﻧﻴﺴﺖ‪.‬‬
‫;)’*’(‪Write‬‬ ‫ﺯﻳﺮﺍ ﻋﻼﻣﺖ ; ﺑﻼﻙ ‪ IF‬ﻣﺤﺴﻮﺏ ﻣﻲ ﺷﻮﺩ‪ .‬ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺩﺳﺘﻮﺭ‬
‫;)’‪Write(’Z‬‬ ‫;)’*’(‪ Write‬ﺣﺘﻤﺎ ﻳﻚ ﺑﺎﺭ ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ‪ .‬ﺩﺳﺘﻮﺭ ;)’‪ Write(’Z‬ﻧﻴﺰ ﻳﻚ ﺑﺎﺭ ﺍﺟﺮﺍ‬
‫;)’‪IF NOT D<4 then Writeln(’S‬‬ ‫ﻣﻲ ﺷﻮﺩ ﻭ ﻣﺮﺑﻮﻁ ﺑﻪ ‪ IF‬ﻧﻴﺴﺖ‪ .‬ﺍﻣﺎ ﺩﺳﺘﻮﺭ ;)’‪ Writeln(’S‬ﻣﺮﺑﻮﻁ ﺑﻪ ‪ IF‬ﺩﻭﻡ ﺍﺳﺖ‬
‫ﻭ ﺩﺭﺻﻮﺭﺗﻲ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﻛﻪ ‪ NOT D<4‬ﺩﺭﺳﺖ ﺑﺎﺷﺪ‪ D<4).‬ﻧﺒﺎﺷﺪ(‬
‫;‪Label AB‬‬
‫‪Var‬‬ ‫ﺗﺤﻘﻴﻖ( ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻪ ﺧﺮﻭﺟﻲ ﺩﺍﺭﺩ؟‬
‫;‪H:Shortint‬‬
‫ﺏ( ﺍﻋﺪﺍﺩ ﺯﻭﺝ ﺩﻭ ﺭﻗﻤﻲ‬ ‫ﺍﻟﻒ( ﺍﻋﺪﺍﺩ ﺯﻭﺝ ﺍﺯ ‪ 0‬ﺗﺎ ‪101‬‬
‫‪Begin‬‬
‫;‪H:=0‬‬ ‫ﺝ( ﺍﻋﺪﺍﺩ ﺯﻭﺝ ﻛﻮﭼﻜﺘﺮ ﺍﺯ ‪ 100‬ﻭ ﺑﺰﺭﮔﺘﺮ ﻣﺴﺎﻭﻱ ‪0‬‬
‫;)‪AB: Writeln(H‬‬ ‫ﺩ( ﺍﻋﺪﺍﺩ ﻓﺮﺩ ﻛﻮﭼﻜﺘﺮ ﺍﺯ ‪100‬‬
‫;‪H:=H+2‬‬
‫‪IF H<100 then‬‬
‫;‪Goto AB‬‬ ‫ﻧﻜﺘﻪ( ﺩﺭ ﺷﺮﻁ ﺩﺳﺘﻮﺭ ‪ IF‬ﻣﻲ ﺗﻮﺍﻥ ﻳﻚ ﻋﺒﺎﺭﺕ ﺑﻮﻟﻲ ﻗﺮﺍﺭ ﺩﺍﺩ ﺗﺎ ﺷﺮﻃﻬﺎ ﺑﺎﻫﻢ ﺗﺮﻛﻴﺐ ﺷﻮﻧﺪ‪.‬‬
‫‪End.‬‬ ‫ﻧﻜﺘﻪ( ﻛﻠﻤﺎﺕ ‪ IF‬ﻭ ‪ THEN‬ﻭ ‪ ELSE‬ﻛﻠﻤﺎﺕ ﺭﺯﺭﻭ ﺷﺪﻩ )ﺫﺧﻴﺮﻩ ﺷﺪﻩ(ﻫﺴﺘﻨﺪ‪.‬‬

‫‪ -2‬دﺳﺘﻮر ‪:IF-THEN ELSE‬‬

‫ﺷﻜﻞ ﻛﻠﻲ ﺩﺳﺘﻮﺭ ‪: IF Then ELSE‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪ THEN‬ﺷﺮط)ﻫﺎ( ‪IF‬‬ ‫‪IF A>8 then‬‬
‫)’‪Writeln(’ALI‬‬
‫ﯾﮏ دﺳﺘﻮر ﺳﺎده ﯾﺎ ﺳﺎﺧﺘﺎري‬ ‫‪Else‬‬
‫‪ELSE‬‬ ‫;)’‪Writeln(’REZA‬‬
‫; ﯾﮏ دﺳﺘﻮر ﺳﺎده ﯾﺎ ﺳﺎﺧﺘﺎري‬ ‫;‪F:=F+1‬‬

‫ﺩﺭ ﻣﺜــﺎﻝ ﺑــﺎﻻ ﺩﺭ ﺻــﻮﺭﺗﻲ ﻛــﻪ ‪ A>8‬ﺩﺭﺳــﺖ ﺑﺎﺷــﺪ ﺩﺳــﺘﻮﺭ )’‪ Writeln(’ALI‬ﺍﻧﺠــﺎﻡ ﻣــﻲ ﺷــﻮﺩ ﻭ ﺩﺭ ﻏﻴــﺮ ﺍﻳﻨــﺼﻮﺭﺕ ﺩﺳــﺘﻮﺭ‬
‫;)’‪ Writeln(’REZA‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪ .‬ﺗﻮﺟﻪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﺍﺯ ﺍﻳـﻦ ﺩﻭ ﺩﺳـﺘﻮﺭ ﻓﻘـﻂ ﺍﺯ ﺁﻧﻬـﺎ ﺍﻧﺠـﺎﻡ ﺧﻮﺍﻫـﺪ ﺷـﺪ‪ .‬ﺩﺳـﺘﻮﺭ ;‪F:=F+1‬‬
‫ﻣﺮﺑﺮﻭﻁ ﺑﻪ ﺩﺳﺘﻮﺭ ‪ IF‬ﻧﻴﺴﺖ ﻭ ﺑﻌﺪ ﺍﺯ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭ ‪ IF then Else‬ﺍﻧﺠﺎﻡ ﺧﻮﺍﻫﺪ ﺷﺪ‪.‬‬

‫‪IF (M=10) OR (H<=20) then‬‬ ‫ﻣﺜﺎﻝ‪ :‬ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺩﺳﺘﻮﺭ ﻣﺮﻛﺐ ﺑﻼﻙ ‪ IF‬ﺍﺳﺖ ﻭ ﺩﺳﺘﻮﺭ;)’‪Writeln(’AMIN‬‬
‫‪Begin‬‬
‫;)’*’(‪Writeln‬‬ ‫ﻣﺮﺑﻮﻁ ﺑﻪ ﺑﻼﻙ ‪ Else‬ﺍﺳﺖ‪.‬‬
‫;‪Z:=12‬‬ ‫ﻧﻜﺘﻪ( ﺩﺳﺘﻮﺭ ﻗﺒﻞ ﺍﺯ ‪ Else‬ﻋﻼﻣﺖ ; ﻧﻤﻲ ﺧﻮﺍﻫﺪ ﺩﺭ ﺻﻮﺭﺕ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻋﻼﻣﺖ ; ﻗﺒﻞ ﺍﺯ‬
‫‪End‬‬ ‫‪ Else‬ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﺩﺭ ﺯﻣﺎﻥ ﺗﺮﺟﻤﻪ ﺭﺥ ﻣﻲ ﺩﻫﺪ‪ .‬ﭼﺮﺍ؟‬
‫‪Else‬‬
‫;)’‪Writeln(’AMIN‬‬
‫ﺗﺤﻘﻴﻖ( ﻓﻠﻮﭼﺎﺭﺕ ﻣﺮﺑﻮﻁ ﺑﻪ ﺩﺳﺘﻮﺭﻫﺎﻱ ‪ IF –Then‬ﻭ ‪ IF then Else‬ﺭﺍ ﺭﺳﻢ ﻛﻨﻴﺪ‪.‬‬
‫;‪Program ODD_EVEN‬‬ ‫ﻣﺜﺎﻝ(ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛـﻪ ﻳـﻚ ﻋـﺪﺩ ﺍﺯ ﻭﺭﻭﺩﻱ ﺩﺭﻳﺎﻓـﺖ ﻛﻨـﺪ ﻭ ﺯﻭﺝ ﻭ ﻓﺮﺩﺑـﻮﺩﻥ ﺁﻥ ﺭﺍ‬
‫‪Var‬‬
‫;‪K:integer‬‬ ‫ﻣﺸﺨﺺ ﻛﻨﺪ؟‬
‫‪Begin‬‬
‫;)‪READLN(K‬‬ ‫ﻧﻜﺘﻪ( ﻛﻠﻤﺔ ‪ Else‬ﺑﺨﺸﻲ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ IF‬ﺍﺳﺖ ﻭ ﺑﻪ ﺗﻨﻬﺎﻳﻲ ﺑﻪ ﻛﺎﺭ ﻧﻤﻲ ﺭﻭﺩ‪.‬‬
‫‪If (K MOD 2) =0 then‬‬
‫)’‪Wrietln(’EVEN‬‬
‫‪Else‬‬
‫;)’‪Writeln(’ODD‬‬
‫‪End.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪27‬‬
‫‪ IF‬ﻫﺎي ﺗﻮ در ﺗﻮ)ﻣﺘﺪاﺧﻞ( ‪:‬‬
‫ﻫﻤﺎﻧﻄﻮﺭ ﺩﺭ ﺷﻜﻞ ﻛﻠﻲ ﺩﺳﺘﻮﺭ ‪ IF‬ﻣﺸﺨﺺ ﺍﺳﺖ ﺗﻚ ﺩﺳﺘﻮﺭ ﻣﺮﺑﻮﻁ ﺑﻪ ‪ IF‬ﻣﻲ ﺗﻮﺍﻧﺪ ﻳﻚ ﺩﺳﺘﻮﺭ ﺳﺎﺧﺘﺎﺭﻱ ﺩﻳﮕﺮ ﺍﺯ ﺟﻤﻠـﻪ ﻳـﻚ ‪ IF‬ﺩﻳﮕـﺮ‬
‫ﺑﺎﺷﺪ‪.‬‬
‫‪IF B then‬‬ ‫}‪{ B:Boolean‬‬
‫‪IF C>15 then‬‬ ‫ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ‪ IF‬ﺩﻭﻣﻲ ﺑﻼﻙ ‪ IF‬ﺍﻭﻟﻲ ﺍﺳﺖ‪ .‬ﺩﺭﺻﻮﺭﺗﻲ ﻛﻪ ﻣﺘﻐﻴﺮ ﺑﻮﻟﻴﻦ‪B‬‬
‫;)’‪Writeln(’ALI‬‬ ‫‪ TRUE‬ﺑﺎﺷﺪ ‪ IF‬ﺩﻭﻡ ﺑﺮﺭﺳﻲ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺩﺭ ﺻﻮﺭﺕ ﺩﺭﺳﺖ ﺑﻮﺩﻥ ‪C>15‬‬
‫ﺭﺷﺘﺔ ‪ ALI‬ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ‪.‬‬

‫‪IF (B) AND ( C > 15) then‬‬ ‫ﺩﺭ ﻣﺜﺎﻝ ﺑﺎﻻ ﻣﻲ ﺗﻮﺍﻥ ﻫﺮ ﺩﻭ ‪ IF‬ﺭﺍ ﺩﺭﻳﻚ ‪ IF‬ﺍﺩﻏﺎﻡ ﻛﺮﺩ‪.‬‬
‫;)’‪WRITELN(’ALI‬‬ ‫ﺑﻪ ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ ﺩﺳﺘﻮﺭ ﺭﻭﺑﺮﻭ ﻭ ﻣﺜﺎﻝ ﺑﺎﻻ ﻳﻚ ﻛﺎﺭ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﻨﺪ ﻭ ﻣﻌﺎﺩﻟﻨﺪ‪.‬‬

‫ﻣﺜﺎﻝ ‪:‬‬
‫‪IF K>10 then‬‬
‫‪IF H=5 then‬‬ ‫ﺑﺎﻳﺪ ﻣﺸﺨﺺ ﻛﻨﻴﺪ ﻛﻪ ﻫﺮ ‪ Else‬ﻣﺮﺑﻮﻁ ﺑﻪ ﻛﺪﺍﻡ ‪ IF‬ﺍﺳﺖ‪.‬‬
‫)’‪Writeln(’$‬‬ ‫’*’‪(K>10) = False è‬‬
‫‪Else‬‬ ‫’‪ (H=5)=True è ’$‬ﻭ ‪(K>10) = True‬‬
‫)’‪Writeln(’%‬‬ ‫’‪ (H=5)=False è ’%‬ﻭ ‪(K>10)=True‬‬
‫‪Else‬‬
‫;)’*’(‪Writeln‬‬

‫ﻣﺜﺎﻝ( ﻣﺸﺨﺺ ﻛﻨﻴﺪ ﻛﻪ ﺩﺭ ﭼﻪ ﺻﻮﺭﺕ ﭼﻪ ﭼﻴﺰﻱ ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ؟‬

‫‪IF W<>12 then‬‬
‫‪IF P<4 then‬‬
‫‪Begin‬‬
‫‪IF A then‬‬
‫;)’‪Write(’#‬‬
‫‪End‬‬
‫‪Else‬‬
‫)’‪Write(’+‬‬
‫‪Else‬‬
‫;)’~’(‪Write‬‬
‫‪ IF‬ﻫﺎﻱ ﺗﻮ ﺩﺭ ﺗﻮ ﻣﻮﻗﻌﻲ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺍﺯ ﺑﻴﻦ ﭼﻨﺪ ﺣﺎﻟﺖ ﻳﻚ ﺣﺎﻟﺖ ﺭﺍ ﺑﺨﻮﺍﻫﻴﻢ ﻃﺒﻖ ﺷﺮﻁ ﻫﺎ ﺍﻧﺘﺨﺎﺏ ﻛﻨﻴﻢ‪ IF.‬ﻫـﺎﻱ ﺗـﻮ ﺩﺭ ﺗـﻮ‬
‫ﺧﻮﺍﻧﺎﻳﻲ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﻛﺎﻫﺶ ﻣﻲ ﺩﻫﺪ‪ .‬ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺗﻮﺻﻴﻪ ﻣﻲ ﺷﻮﺩ ﺑﺠﺎﻱ ‪ IF‬ﻫﺎﻱ ﺗﻮ ﺩﺭ ﺗﻮ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ Case‬ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ‪.‬‬
‫دﺳﺘـﻮر ‪: Case‬‬
‫ﺩﺳﺘﻮﺭ ‪ Case‬ﺯﻣﺎﻧﻲ ﺑﻪ ﻛﺎﺭ ﻣﻲ ﺭﻭﺩ ﻛﻪ ﺑﺨﻮﺍﻫﻴﻢ ﺍﺯ ﺑﻴﻦ ﭼﻨﺪﻳﻦ ﺣﺎﻟﺖ‪ ،‬ﻳﻚ ﺣﺎﻟﺖ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﻛﻨﻴﻢ ﻭ ﻣﻌﺎﺩﻝ‪ IF‬ﻫﺎﻱ ﺗﻮ ﺩﺭ ﺗﻮ ﺍﺳﺖ‪.‬‬
‫‪ OF‬ﻋﺒﺎﺭﺕ ﻳﺎ ﻣﺘﻐﻴﺮ ‪Case‬‬ ‫ﺷﻜﻞ ﻛﻠﻲ ﺩﺳﺘﻮﺭ ‪: Case‬‬
‫; ﺩﺳﺘﻮﺭ ﺳﺎﺩﻩ ﻳﺎ ﺳﺎﺧﺘﺎﺭﻱ‪: ١‬ﻣﻘﺪﺍﺭ ﻳﺎ ﻣﻘﺎﺩﻳﺮ‪١‬‬
‫;‪A:=12‬‬ ‫ﻣﺜﺎﻝ‪:‬‬
‫; ﺩﺳﺘﻮﺭ ﺳﺎﺩﻩ ﻳﺎ ﺳﺎﺧﺘﺎﺭﻱ‪: ٢‬ﻣﻘﺪﺍﺭ ﻳﺎ ﻣﻘﺎﺩﻳﺮ‪٢‬‬
‫‪Case A+3 OF‬‬
‫; ﺩﺳﺘﻮﺭ ﺳﺎﺩﻩ ﻳﺎ ﺳﺎﺧﺘﺎﺭﻱ‪: ٣‬ﻣﻘﺪﺍﺭ ﻳﺎ ﻣﻘﺎﺩﻳﺮ‪٣‬‬ ‫;)’‪1,12: Writeln(’OK‬‬
‫‪…..‬‬ ‫;)’‪15,14:Writeln(’ALI‬‬
‫‪Else‬‬ ‫;)’‪16:Writeln(’AMIN‬‬
‫; ﺩﺳﺘﻮﺭ ﺳﺎﺩﻩ ﻳﺎ ﺳﺎﺧﺘﺎﺭﻱ‬ ‫;‪End‬‬
‫; ‪End‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪28‬‬
‫ﺭﻭﻧﺪ ﺍﺟﺮﺍﻳﻲ ﺩﺳﺘﻮﺭ ‪ Case‬ﺑﻪ ﺍﻳﻦ ﺷﻜﻞ ﺍﺳﺖ ﻛﻪ ﻋﺒﺎﺭﺕ ﻳﺎ ﻣﺘﻐﻴﺮ ﺟﻠﻮﻱ ‪ Case‬ﻣﻘﺪﺍﺭﺵ ﻣﺸﺨﺺ ﻣﻲ ﺷﻮﺩ ﻭ ﺳﭙﺲ ﺍﻳﻦ ﻣﻘﺪﺍﺭ ﺑﺎ ﻫﺮﻛـﺪﺍﻡ‬
‫ﺍﺯ ﻣﻘﺎﺩﻳﺮ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮﺩ ﺑﺎ ﻫﺮ ﻛﺪﺍﻡ ﻛﻪ ﺑﺮﺍﺑﺮ ﺑﻮﺩ ﺩﺳﺘﻮﺭ ﻣﺮﺑﻮﻁ ﺑﻪ ﺁﻥ ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ‪ .‬ﺍﮔﺮ ﻣﻘﺪﺍﺭ ﺑﺎ ﻫﻴﭻ ﻛﺪﺍﻡ ﻳﻚ ﺍﺯ ﻣﻘـﺎﺩﻳﺮ ﺑﺮﺍﺑـﺮ ﻧـﺸﻮﺩ‬
‫;)‪Readln(F‬‬ ‫ﺩﺳﺘﻮﺭ ﻣﺮﺑﻮﻁ ﺑﻪ ‪ ) Else‬ﺩﺭ ﺻﻮﺭﺕ ﻭﺟﻮﺩ( ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪Case F OF‬‬ ‫ﻧﻜﺘﻪ( ﻗﺴﻤﺖ ‪ Else‬ﺩﺭ ﺩﺳﺘﻮﺭ ‪ Case‬ﺍﺧﺘﻴﺎﺭﻱ ﺍﺳﺖ‪.‬‬
‫;)’‪0..9: Writeln(’ONE‬‬ ‫ﻧﻜﺘﻪ( ﺩﺳﺘﻮﺭ ‪ Case‬ﻋﺒﺎﺭﺕ ‪ Begin‬ﻧﺪﺍﺭﺩ ﺍﻣﺎ ;‪ End‬ﺩﺍﺭﺩ‪.‬‬
‫;)’‪10 .. 99: Writeln(’TWO‬‬
‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﺑﺠﺎﻱ ﺩﺳﺘﻮﺭ ;)’‪ Writeln(’ONE‬ﺑﺨﻮﺍﻫﻴﻢ ﭼﻨﺪﻳﻦ ﺩﺳﺘﻮﺭ ﺑﻨﻮﻳﺴﻴﻢ‬
‫‪ELSE‬‬
‫;)’‪Writeln(’Other‬‬ ‫ﺑﺎﻳﺪ ﺍﺯ ﺩﺳﺘﻮﺭ ﻣﺮﻛﺐ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﻢ‪.‬‬
‫;‪END‬‬ ‫ﻧﻜﺘﻪ( ﺩﺭ ﻗﺴﻤﺖ ﻣﻘﺎﺩﻳﺮ ﻧﺒﺎﻳﺪ ﺍﺯ ﻣﺘﻐﻴﺮ ﻳﺎ ﺛﺎﺑﺖ ﺑﺎ ﻧﻮﻉ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﻋﺒﺎﺭﺕ ﺭﻭﺑﺮﻭﻱ ‪ Case‬ﺑﺎﻳﺪ ﺍﺯ ﻧﻮﻉ ﺍﺳﻜﺎﻟﺮ ﺑﺎﺷﺪ‪ .‬ﺩﺭ ﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ ﺩﺭ ﺯﻣﺎﻥ ﺗﺮﺟﻤﻪ ﺧﻄﺎ ﺻﺎﺩﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬

‫ﻧﻮع داده اﺳﮑﺎﻟـﺮ‪:‬‬

‫ﻧﻮﻉ ﺩﺍﺩﻩ ﺍﻳﻲ ﻛﻪ ﻗﺎﺑﻞ ﺷﻤﺎﺭﺵ ﺑﺎﺷﺪ ﺭﺍ ﺍﺳﻜﺎﻟﺮ ﻣﻲ ﮔﻮﻳﻨﺪ‪ .‬ﺩﺍﺩﻩ ﻫﺎﻱ ﺍﺳﻜﺎﻟﺮ ﻣﺎﻧﻨـﺪ ‪ :‬ﺍﻋـﺪﺍﺩ ﺻـﺤﻴﺢ ) ﺑـﻪ ﻏﻴـﺮ ﺍﺯ ‪ – (Comp‬ﻛـﺎﺭﺍﻛﺘﺮﻱ–‬
‫ﺑﻮﻟﻴﻦ‬
‫ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﻗﺎﺑﻞ ﺷﻤﺎﺭﺵ ﻫﺴﺘﻨﺪ ﻳﻌﻨﻲ ﺑﻌﺪ ﺍﺯ ﺣﺮﻑ ’‪ ’A‬ﺣﺮﻑ ’‪ ’B‬ﺍﺳﺖ ﻭ ﻗﺒﻞ ﺍﺯ ﺣﺮﻑ’‪ ’A‬ﻧﻴﺰﻛﺎﺭﺍﻛﺘﺮ ’@’ ﺍﺳﺖ‪ ) .‬ﺟﺪﻭﻝ ﻛﺪ ﺍﺳﻜﻲ(‬
‫ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﻱ ﻭ ﺭﺷﺘﻪ ﻫﺎ ﺍﺳﻜﺎﻟﺮ ﻧﻴﺴﺘﻨﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﺩﺭ ﺩﺳﺘﻮﺭ ‪ Case‬ﻋﺒﺎﺭﺕ ‪ Else‬ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﻣﻤﻜﻦ ﺍﺳﺖ ﻫﻴﭽﻜﺪﺍﻡ ﺍﺯ ﺣﺎﻟﺖ ﻫﺎ ﺍﻧﺘﺨﺎﺏ ﻧﺸﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﻣﻘﺎﺩﻳﺮ ﺩﺭ ﺩﺳﺘﻮﺭ ‪ Case‬ﻣﻲ ﺗﻮﺍﻧﻨﺪ ﺗﻜﺮﺍﺭﻱ ﺑﺎﺷﻨﺪ ﺍﻣﺎ ﺩﺭ ﻫﻨﮕﺎﻡ ﺑﺮﺭﺳﻲ ﻣﻘﺎﺩﻳﺮ ﺍﻭﻟﻴﻦ ﺣﺎﻟﺖ ﻛﻪ ﺍﻧﺘﺨﺎﺏ ﺷﻮﺩ ﺍﺟﺮﺍ ﻣـﻲ ﺷـﻮﺩ ﻭ ﺑﻘﻴـﻪ‬
‫ﺣﺎﻟﺖ ﻫﺎ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﻤﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﺗﺤﻘﻴﻖ( ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻨﺪ ﺧﻄﺎ ﺩﺍﺩ؟)ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺍﺳﺖ(‬
‫;‪Program H‬‬
‫‪Var‬‬
‫;‪H:Integer‬‬
‫‪Const‬‬
‫;‪X:20‬‬
‫‪Begin‬‬
‫;‪Readln(H); X:=X+1‬‬
‫‪Case H/10 OF‬‬
‫‪1,3:‬‬
‫;)‪Writeln(X‬‬
‫;)’‪2,1:Writeln(’F‬‬
‫;‪H:=12‬‬
‫;)’‪9..5:Writeln(’X‬‬
‫;‪End‬‬
‫;‪End‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪29‬‬
‫ﺗﺴﺖ ‪:‬‬
‫‪-٥٣‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺩﺭ ﻣﻮﺭﺩ ﻣﺘﻐﻴﺮ ‪ A‬ﻛﻪ ﺍﺯ ﻧﻮﻉ ‪ Boolean‬ﻣﻲ ﺑﺎﺷﺪ ﻧﺎﺩﺭﺳﺖ ﺍﺳﺖ؟‬
‫ﺩ( )‪READ(A‬‬ ‫ﺝ( ;‪A:=False‬‬ ‫ﺏ( ;‪A:=TRUE‬‬ ‫ﺍﻟﻒ( )‪WRITE(A‬‬
‫‪ -٥٤‬ﺍﮔﺮ ‪ A=68.951‬ﺑﺎﺷﺪ ﺣﺎﺻﻞ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭ )‪ WRITE(A:5:1‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪69. 1‬‬ ‫ﺝ( ‪69. 0‬‬ ‫ﺏ( ‪68. 96‬‬ ‫ﺍﻟﻒ( ‪68. 9‬‬
‫‪ -٥٥‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫;‪Var D:real‬‬ ‫ﺝ(‪OK‬‬ ‫ﺏ(‪Not BAD‬‬ ‫ﺍﻟﻒ(‪BAD‬‬
‫‪Begin‬‬ ‫ﺩ( ﺩﺭ ﺯﻣﺎﻥ ﺗﺮﺟﻤﻪ ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﻣﻲ ﺩﻫﺪ‪.‬‬
‫;‪D:=6 XOR 0‬‬
‫‪Case D of‬‬
‫;)’‪1. . 7: writeln(‘BAD‬‬
‫;)’‪8. . 12 : Writeln(‘NOT BAD‬‬
‫;)’‪13. . 20 : writeln(‘OK‬‬
‫;‪end‬‬
‫‪end.‬‬

‫‪-٥٦‬ﻛﺪﺍﻡ ﻳﻚ ﺍﺯ ﺍﻧﻮﺍﻉ ﺩﺍﺩﻩ ﻫﺎﻱ ﺯﻳﺮ ﻓﻀﺎﻱ ﺑﻴﺸﺘﺮﻱ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨﺪ؟‬

‫ﺏ(‪Word‬‬ ‫ﺍﻟﻒ(‪Longint‬‬
‫ﺩ(‪Single‬‬ ‫ﺝ(‪Real‬‬
‫‪ -٥٧‬ﭼﻨﺎﻧﭽﻪ ﺑﺨﻮﺍﻫﻴﻢ ﺍﺯ ﭼﻨﺪﻳﻦ ﺣﺎﻟﺖ) ﺑﻴﺶ ﺍﺯ ﺩﻭ ﺣﺎﻟﺖ( ﻳﻚ ﺣﺎﻟﺖ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﻛﻨﻴﻢ ﻛﺪﺍﻡ ﺳﺎﺧﺘﺎﺭ ﻣﻨﺎﺳﺒﺘﺮ ﺍﺳﺖ؟‬
‫‪For‬‬ ‫ﺩ(‬ ‫ﺝ( ‪Goto‬‬ ‫‪Case‬‬ ‫ﺏ(‬ ‫ﺍﻟﻒ( ‪IF‬‬
‫‪ -٥٨‬ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ ﺍﺯ ﺩﺳﺘﻮﺭ ﻭﺭﻭﺩﻱ ‪ Readln‬ﺑﺪﻭﻥ ﺫﻛﺮﻣﺘﻐﻴﺮﻫﺎﻱ ﻭﺭﻭﺩﻱ ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﺎﻳﻴﺪ ﺑﺎﻋﺚ ﺧﻮﺍﻫﺪ ﺷﺪﻛﻪ ﻛﺎﻣﭙﻴﻮﺗﺮﻣﻨﺘﻈﺮ ﻓﺸﺮﺩﻥ‬
‫ﻛﻠﻴﺪ ‪ .…..‬ﺷﻮﺩ؟‬
‫ﺩ(‪Enter‬‬ ‫ﺝ(‪Esc‬‬ ‫ﺏ(‪Ctrl‬‬ ‫ﺍﻟﻒ(‪ALT‬‬
‫‪ -٥٩‬ﺣﺎﺻﻞ ﻋﻤﻠﮕﺮﻫﺎﻱ ﺭﺍﺑﻄﻪ ﺍﻳﻲ ﺍﺯ ﻧﻮﻉ …………‪ .‬ﻭ ﺣﺎﺻﻞ ﻋﻤﻠﮕﺮ ‪) /‬ﺗﻘﺴﻴﻢ( ﺍﺯ ﻧﻮﻉ ………‪ .‬ﺍﺳﺖ‪.‬‬
‫ﺩ( ﺭﻳﺎﺿﻲ – ﺑﺴﺘﮕﻲ ﺑﻪ ﻋﻤﻠﻮﻧﺪ ﻫﺎ ﺩﺍﺭﺩ‬ ‫ﺝ( ﺑﻮﻟﻲ‪ -‬ﺍﻋﺸﺎﺭﻱ‬ ‫ﺏ( ﺑﻮﻟﻲ – ﺻﺤﻴﺢ‬ ‫ﺍﻟﻒ( ﺭﻳﺎﺿﻲ ‪ -‬ﺍﻋﺸﺎﺭﻱ‬
‫‪ -٦٠‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺩﺭﺳﺖ ﻣﻲ ﺑﺎﺷﺪ؟‬
‫ﺝ( ‪X mod Y = X*(X div Y)-Y‬‬ ‫ﺍﻟﻒ( ‪X mod Y=X-(X div Y)*Y‬‬
‫ﺩ( ‪X mod Y=X*(X div Y)+Y‬‬ ‫ﺏ( ‪X mod Y=X-(X div Y)-Y‬‬
‫‪ -٦١‬ﺣﺎﺻﻞ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭ ﻣﻘﺎﺑﻞ ﭼﻴﺴﺖ؟‬
‫ﺝ( ﺧﻄﺎ‬ ‫ﺍﻟﻒ( ﭼﺎﭖ ﺍﻋﺪﺍﺩ ‪ ١‬ﻳﺎ ‪٢‬‬
‫;‪Var Z: string‬‬
‫‪Begin‬‬ ‫ﺩ( ﭼﺎﭖ ﺍﻋﺪﺍﺩ ‪ ١‬ﻭ ‪٢‬‬ ‫ﺏ( ﭼﺎﭖ ﻋﺪﺩ ﺩﺭﻳﺎﻓﺘﻲ ‪Z‬‬
‫;)‪Readln(Z‬‬ ‫‪ - ٦٢‬ﺍﮔﺮ ‪ A:=329‬ﺑﺎﺷﺪ ﺣﺎﺻﻞ ‪ A SHR 4‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫‪Case Z of‬‬
‫;)‪1: Write(1‬‬ ‫ﺩ(‪٢٩‬‬ ‫ﺝ(‪٢١‬‬ ‫ﺏ(‪٢‬‬ ‫ﺍﻟﻒ( ‪٢٠‬‬
‫;)‪2: Write(2‬‬
‫;‪end‬‬
‫‪end.‬‬

‫‪ -٦٣‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺩﺭ ﻣﻮﺭﺩ ﻧﺘﻴﺠﻪ ﺣﺎﺻﻞ ﺍﺯ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭ ;)‪Write(#13‬ﺻﺤﻴﺢ ﺍﺳﺖ؟‬

‫ﺏ( ﺻﺪﺍﻱ ﺑﻮﻕ ﺍﺯ ﺑﻠﻨﺪﮔﻮﻱ ﺳﻴﺴﺘﻢ ﺷﻨﻴﺪﻩ ﻣﻲ ﺷﻮﺩ‬ ‫ﺍﻟﻒ( ﻣﻜﺎﻥ ﻧﻤﺎ ﻳﻚ ﺳﻄﺮ ﭘﺎﻳﻴﻦ ﻣﻲ ﺭﻭﺩ‬
‫ﺩ( ﻣﻜﺎﻥ ﻧﻤﺎ ﺑﻪ ﺍﺑﺘﺪﺍﻱ ﺳﻄﺮ ﺑﻌﺪﻱ ﻣﻲ ﺭﻭﺩ‪.‬‬ ‫ﺝ( ﻣﻜﺎﻥ ﻧﻤﺎ ﺑﻪ ﺍﺑﺘﺪﺍﻱ ﺳﻄﺮ ﻓﻌﻠﻲ ﻣﻲ ﺭﻭﺩ‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪30‬‬
‫‪ -٦٤‬ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﺪﺍﻡ ﻧﻮﻉ ﺩﺍﺩﻩ ﺩﺭ ﻋﺒﺎﺭﺕ ﺩﺳﺘﻮﺭ ‪ Case‬ﻣﺠﺎﺯ ﻧﻤﻲ ﺑﺎﺷﺪ؟‬
‫ﺩ(‪Shortint‬‬ ‫ﺝ(‪Real‬‬ ‫ﺏ( ‪Byte‬‬ ‫ﺍﻟﻒ( ‪Longint‬‬
‫‪((43‬‬ ‫‪shr 1) shl 2) xor 84‬‬ ‫‪ -٦٥‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﺭﻭﺑﺮﻭ ﭼﻨﺪ ﺍﺳﺖ؟‬
‫ﺩ(‪٠‬‬ ‫ﺝ(‪٢٣‬‬ ‫ﺏ(‪٦٣‬‬ ‫ﺍﻟﻒ(‪٢٤٣‬‬
‫‪ -٦٦‬ﻧﺘﻴﺠﻪ ﻛﺪﺍﻡ ﻋﺒﺎﺭﺕ ﺑﻮﻟﻲ ﺑﺮﺍﺑﺮ ‪ True‬ﺍﺳﺖ؟‬
‫ﺩ( ’‪’TEST’=’test‬‬ ‫ﺝ(’‪’TEST’>=’test‬‬ ‫ﺏ(’‪’TEST’<’test‬‬ ‫ﺍﻟﻒ( ’‪’TEST’>’test‬‬
‫‪ -٦٧‬ﻋﺒﺎﺭﺕ ﺟﺒﺮﻱ ‪ 5≥X>3‬ﻣﻌﺎﺩﻝ ﻛﺪﺍﻡ ﻋﺒﺎﺭﺕ ﺑﻮﻟﻲ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺍﺳﺖ؟‬
‫ﺏ( )‪(X<=5) OR (X>3‬‬ ‫ﺍﻟﻒ( )‪(X<=5) AND (X>3‬‬
‫ﺩ( )‪(X>3) OR (X>=5‬‬ ‫ﺝ( )‪(X>3) AND (X>=5‬‬
‫‪ -٦٨‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺯﻳﺮ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫;‪Var x,y:byte‬‬ ‫ﺏ( ﺧﻄﺎﻱ ‪ Type Mismatch‬ﻇﺎﻫﺮ ﻣﻲ ﺷﻮﺩ‬ ‫ﺍﻟﻒ( ‪False‬‬
‫;‪A,b,f:boolean‬‬ ‫ﺝ( ‪) True‬ﺑﻪ ﻣﻘﺪﺍﺭ ‪ x‬ﻭ‪ y‬ﺑﺴﺘﮕﻲ ﻧﺪﺍﺭﺩ(‬ ‫ﺏ( ‪) True‬ﺑﻪ ﻣﻘﺪﺍﺭ ‪ x‬ﻭ ‪ y‬ﺑﺴﺘﮕﻲ ﺩﺍﺭﺩ‪(.‬‬
‫‪Begin‬‬
‫;‪X:=5; y:=6‬‬
‫;‪A:=X<=y‬‬
‫;‪B:=Y<X‬‬
‫‪If a<b then f:=a<b‬‬
‫;‪Else f:=b<a‬‬
‫;)‪Write(F‬‬
‫‪End.‬‬ ‫‪ -٦٩‬ﻋﻼﻣﺖ ‪ :‬ﻫﻤﻮﺍﺭﻩ ﺩﺭ ………‪ .‬ﺑﻜﺎﺭ ﻣﻲ ﺭﻭﺩ؟‬
‫ﺏ( ﺗﻌﻴﻴﻦ ﻧﻮﻉ ﻣﺘﻐﻴﺮﻫﺎ‬ ‫ﺍﻟﻒ(ﻣﻘﺪﺍﺭ ﺩﻫﻲ ﻣﺘﻐﻴﺮﻫﺎ‬
‫ﺩ( ﭘﺎﻳﺎﻥ ﺳﻄﺮﻫﺎ‬ ‫ﺝ(ﻣﻌﺮﻓﻲ ﺛﺎﺑﺘﻬﺎ‬
‫‪ -٧٠‬ﺍﮔﺮ ﻣﺘﻐﻴﺮ ﺭﺷﺘﻪ ﺍﻳﻲ ﺑﻪ ﻃﻮﻝ ‪ ١٠‬ﺗﻌﺮﻳﻒ ﻛﺮﺩﻩ ﺑﺎﺷﻴﺪ ﺣﺎﻓﻈﻪ ﺍﺧﺘﺼﺎﺹ ﺩﺍﺩﻩ ﺷﺪﻩ ﺑﻪ ﺁﻥ ﭼﻨﺪ ﺑﺎﻳﺖ ﺍﺳﺖ؟‬
‫ﺩ( ﺑﺴﺘﮕﻲ ﺑﻪ ﺭﺷﺘﻪ ﺩﺍﺧﻞ ﺁﻥ ﺩﺍﺭﺩ‬ ‫ﺝ(‪١٠‬‬ ‫ﺏ(‪٩‬‬ ‫ﺍﻟﻒ( ‪١١‬‬
‫‪ -٧١‬ﻛﺪﺍﻡ ﻧﻮﻉ ﻋﺒﺎﺭﺕ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺩﺭ ﺟﻠﻮﻱ ﺩﺳﺘﻮﺭ ‪ Case‬ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﻧﻮﺷﺖ؟‬
‫ﺩ(‪Real‬‬ ‫ﺝ( ‪String‬‬ ‫ﺏ( ‪Double‬‬ ‫ﺍﻟﻒ(‪Byte‬‬
‫‪ -٧٢‬ﺍﮔﺮ ‪ X:=3456.981‬ﺑﺎﺷﺪ ﺣﺎﺻﻞ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭ )‪ Write(X:0:1‬ﭼﻴﺴﺖ؟‬
‫ﺩ(‪3457‬‬ ‫ﺝ(‪3457.0‬‬ ‫ﺏ(‪3456.9‬‬ ‫ﺍﻟﻒ(‪3456.0‬‬
‫‪ -٧٣‬ﺍﮔﺮ ﺩﺳﺘﻮﺭﺍﺕ ﺩﺍﺩﻩ ﺷﺪﻩ ﺑﻪ ﺗﺮﺗﻴﺐ ﺍﺟﺮﺍ ﺷﻮﻧﺪ ﻭ ﺩﺍﺩﻩ ﻫﺎﻱ ﻭﺭﻭﺩﻱ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺑﺎﺷﻨﺪ ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮﻫﺎﻱ ‪ P1,P2,P3‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫‪Readln(P1,P2); 1 2 3‬‬ ‫ﺏ( ‪1 , 2 , 4‬‬ ‫ﺍﻟﻒ( ‪1 , 2 , 3‬‬
‫‪Read(P3); 4 5 6‬‬ ‫ﺩ( ‪1 , 4 , 5‬‬ ‫ﺝ( ‪1 , 2 , 5‬‬
‫‪ -٧٤‬ﺍﮔﺮ ﻣﻘﺪﺍﺭ ‪ J‬ﺑﺮﺍﺑﺮ ‪ ٣‬ﺑﺎﺷﺪ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺩﺳﺘﻮﺭﺍﺕ ﺭﻭﺑﺮﻭ ﺧﺮﻭﺟﻲ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪9‬‬ ‫ﺝ( ‪18‬‬ ‫ﺏ( ‪6‬‬ ‫ﺍﻟﻒ( ‪3‬‬
‫; ‪IF J>4 then‬‬
‫;‪J:=2*J‬‬
‫‪IF J<=3 then‬‬
‫;‪J:=3*J‬‬
‫;)‪Writeln(J‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪31‬‬
‫دﺳﺘﻮرات ﺗﮑﺮار) ﺣﻠﻘﻪ(‪:‬‬
‫ﺩﺳﺘﻮﺭﺍﺕ ﺗﻜﺮﺍﺭ ﺑﺮﺍﻱ ﺗﻜﺮﺍﺭ ﺍﺟﺮﺍﻱ ﺗﻌﺪﺍﺩﻱ ﺩﺳﺘﻮﺭ ﺑﻪ ﻛﺎﺭ ﻣﻲ ﺭﻭﻧﺪ‪ .‬ﺑﺮﺍﻱ ﺍﻳﺠﺎﺩ ﺣﻠﻘﻪ ﻫﺎ ﺍﺯ ﺩﺳﺘﻮﺭﺍﺕ ﺗﻜـﺮﺍﺭ ﺍﺳـﺘﻔﺎﺩﻩ ﻣـﻲ ﺷـﻮﺩ‪ .‬ﺳـﻪ ﻧـﻮﻉ‬
‫ﺩﺳﺘﻮﺭ ﺗﻜﺮﺍﺭ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪:‬‬
‫‪ -2 While‬دﺳﺘﻮر ‪ -3 Repeat Until‬دﺳﺘﻮر ‪For‬‬ ‫‪ -1‬دﺳﺘﻮر ‪Do‬‬
‫ﻫﺮ ﻛﺪﺍﻡ ﺍﺯ ﺍﻳﻦ ﺩﺳﺘﻮﺭﺍﺕ ﺩﺍﺭﺍﻱ ﻭﻳﮋﮔﻲ ﻫﺎﻱ ﺧﺎﺻﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻧﻴﺎﺯ ﺧﻮﺩ ﻳﻜﻲ ﺍﺯ ﺁﻧﻬﺎ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﺧﻮﺍﻫﺪ ﻛﺮﺩ‪.‬‬

‫‪ - 1‬دﺳﺘﻮر ‪: While Do‬‬

‫ﺷﻜﻞ ﻛﻠﻲ ﺩﺳﺘﻮﺭ‪:‬‬

‫‪ Do‬ﻋﺒﺎرت ﺑﻮﻟﯽ ‪WHILE‬‬

‫; ﯾﮏ دﺳﺘﻮر ﺳﺎده ﯾﺎ دﺳﺘﻮر ﺳﺎﺧﺘﺎري‬
‫ﺩﺭ ﻫﻨﮕﺎﻡ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭ ‪ While‬ﺍﺑﺘﺪﺍ ﻋﺒﺎﺭﺕ ﺑﻮﻟﻲ)ﺷﺮﻁ( ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﺷﻮﺩ ﺩﺭ ﺻـﻮﺭﺗﻲ ﻛـﻪ ﻧﺘﻴﺠـﻪ ﺑﺮﺍﺑـﺮ ‪ True‬ﺑﺎﺷـﺪ ﺩﺳـﺘﻮﺭ ﻣﺮﺑـﻮﻁ‬
‫ﺑﻪ‪ While‬ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ ﻭ ﺩﻭﺑﺎﺭﻩ ﻋﺒﺎﺭﺕ ﺑﻮﻟﻲ ﺑﺮﺭﺳﻲ ﻣﻲ ﺷﻮﺩ ﻭ ﺍﻳﻦ ﻛﺎﺭ ﺩﻭﺑﺎﺭﻩ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‪ .‬ﺗﺎ ﺯﻣـﺎﻧﻲ ﻛـﻪ ﻣﻘـﺪﺍﺭ ﻋﺒـﺎﺭﺕ ﺑـﻮﻟﻲ ﺑﺮﺍﺑـﺮ‬
‫‪ True‬ﺑﺎﺷﺪ ﺣﻠﻘﺔ ‪ While‬ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﺩﺭ ﺍﻭﻟﻴﻦ ﺑﺎﺭ ﻛﻪ ﺷﺮﻁ ﺑﺮﺭﺳﻲ ﻣﻲ ﺷﻮﺩ ﺷﺮﻁ ﻧﺎﺩﺭﺳﺖ ﺑﺎﺷﺪ ﺁﻧﮕﺎﻩ ﺣﻠﻘﻪ ﺍﺻﻼ ﺗﻜﺮﺍﺭ ﻧﻤﻲ ﺷﻮﺩ‬
‫ﭘﺲ ﺍﺣﺘﻤﺎﻝ ﺩﺍﺭﺩ ﻛﻪ ﺣﻠﻘﻪ ﺗﻜﺮﺍﺭ ﻧﺸﻮﺩ‪.‬‬
‫ﻣﺜﺎﻝ(ﺑﺮﻧﺎﻣﻪ ﺍﯼ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻚ ﻋﺪﺩﻣﺜﺒﺖ ﺍﺯ ﻭﺭﻭﺩﻱ ﺑﺨﻮﺍﻧﺪ ﻭ ﺭﻗﻤﻬﺎﻱ ﺁﻥ ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ‪.‬‬

‫‪Var‬‬
‫;‪R, N:Integer‬‬
‫‪Begin‬‬
‫;)‪Readln(N‬‬
‫‪While N> 0 DO‬‬
‫‪Begin‬‬
‫;‪R:=N Mod 10‬‬
‫;)‪Writeln(R‬‬
‫;‪N:=N DIV 10‬‬
‫;‪End‬‬
‫‪End.‬‬
‫ﺩ(‪5‬‬ ‫ﺝ(‪4‬‬ ‫ﺏ( ‪1‬‬ ‫ﻣﺜﺎﻝ( ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﺩﺳﺘﻮﺭ ;)‪ Writeln(X‬ﭼﻨﺪ ﺑﺎﺭ ﺍﺟﺮﺍ ﺧﻮﺍﻫﺪ ﺷﺪ؟ ﺍﻟﻒ( ‪0‬‬
‫;‪X:=1‬‬
‫‪While X<5 Do‬‬
‫‪Begin‬‬
‫;)‪Writeln(X‬‬
‫;‪X:=X+1‬‬
‫;‪End‬‬
‫ﺍﮔﺮ ﺷﺮﻁ)ﻋﺒﺎﺭﺕ ﺑﻮﻟﻲ( ﻣﺮﺑﻮﻁ ﺑﻪ ‪ While‬ﻫﻤﻴﺸﻪ ‪ True‬ﺑﺎﺷﺪ ﻭ ﺍﺻﻼ ‪ False‬ﻧﺸﻮﺩ ﺁﻧﮕـﺎﻩ ﺣﻠﻘـﻪ ‪ While‬ﻫﺮﮔـﺰ ﭘﺎﻳـﺎﻥ ﻧﻤـﻲ ﻳﺎﺑـﺪ ﻭ ﺩﺭ‬
‫ﻧﺘﻴﺠﻪ ﻳﻚ ﺣﻠﻘﻪ ﺑﻲ ﻧﻬﺎﻳﺖ ﺑﺎﺭ ﺍﺳﺖ‪ ).‬ﺑﻲ ﻧﻬﺎﻳﺖ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ( ﺩﺭ ﺍﻳﻦ ﺣﺎﻟﺖ ﻛﺎﻣﭙﻴﻮﺗﺮ ﺩﺭ ﻳﻚ ﻭﺿﻌﻴﺖ ﺛﺎﺑﺖ ﻣﻲ ﻣﺎﻧﺪ‪.‬‬
‫ﻋﺒﺎﺭﺕ ﺑﻮﻟﻲ)ﺷﺮﻁ( ﻣﺮﺑﻮﻁ ﺑﻪ ﺣﻠﻘﺔ ‪ While‬ﺑﺎﻳﺪ ﻃﻮﺭﻱ ﺗﻨﻈﻴﻢ ﺷﻮﺩ ﻛﻪ ﺯﻣﺎﻧﻲ ‪ False‬ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﺑﻌﺪ ﺍﺯ ﻛﻠﻤﺔ ﺭﺯﺭﻭ ﺷﺪﺓ ‪ Do‬ﻋﻼﻣﺖ ; ﻗﺮﺍﺭ ﮔﻴﺮﺩ ﺁﻧﮕﺎﻩ ﻋﻼﻣﺖ ; ﺑﻪ ﻋﻨﻮﺍﻥ ﺩﺳﺘﻮﺭ)ﺑﻼﻙ( ‪ while‬ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣـﻲ ﺷـﻮﺩ‪ .‬ﺩﺭ‬
‫ﺍﻳﻦ ﺻﻮﺭﺕ ﺩﻭ ﺣﺎﻟﺖ ﺭﺥ ﻣﻲ ﺩﻫﺪ‪:‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪32‬‬
‫‪ - ١‬ﺷﺮﻁ ‪ While‬ﺩﺭﺳﺖ ﺑﺎﺷﺪ ﻛﻪ ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﻳﻚ ﺣﻠﻘﻪ ﺑﻲ ﻧﻬﺎﻳﺖ ﺍﻳﺠﺎﺩ ﺷـﺪﻩ ﺍﺳـﺖ‪ - ٢ .‬ﺷـﺮﻁ ‪ While‬ﻧﺎﺩﺭﺳـﺖ ﺑﺎﺷـﺪ ﻛـﻪ ﺣﻠﻘـﻪ‬
‫‪ while‬ﺍﺻﻼ ﺗﻜﺮﺍﺭ ﻧﻤﻲ ﺷﻮﺩ‪).‬ﺧﻄﺎﻱ ﻣﻨﻄﻘﻲ(‬
‫ﻣﺜﺎﻝ( ﻣﺜﺎﻝ ﻗﺒﻞ ﺭﺍ ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ ﺑﻌﺪ ﺍﺯ ‪ Do‬ﻋﻼﻣﺖ ; ﻗﺮﺍﺭ ﮔﺮﻓﺘﻪ ﺷﺪﻩ ﺍﺳﺖ ﺣﻞ ﻛﻨﻴﺪ‪.‬‬
‫;‪K:=10; S:=7‬‬ ‫ﻣﺜﺎﻝ(ﺩﺳﺘﻮﺭﺍﺕ ;‪ K:=K-1‬ﻭ ;‪ S:=S-1‬ﻫﺮ ﻛﺪﺍﻡ ﭼﻨﺪ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﻧﺪ؟‬
‫‪While K<>10 Do‬‬
‫;‪K:=K-1‬‬
‫;‪While S>0 Do‬‬
‫;‪S:=S-1‬‬ ‫ﻧﻜﺘﻪ( ﺯﻣﺎﻧﻲ ﺍﺯ ﺣﻠﻘﻪ ‪ while‬ﺑﺮﺍﻱ ﺳﺎﺧﺖ ﺣﻠﻘﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺣﻠﻘﻪ‬
‫ﻣﺸﺨﺺ ﻧﺒﺎﺷﺪ‪.‬‬
‫ﻣﺜﺎﻝ ( ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ ﺟﻤﻠﻪ را از ورودي درﯾﺎﻓﺖ ﮐﺮده ﺗﻌﺪاد ﮐﺎراﮐﺘﺮ ‪ t‬و ‪ T‬را ﺑﺸﻤﺎرد ‪).‬ﺟﻤﻠﻪ ﺑﻪ ﺻﻔﺮ ﺧﺘﻢ ﻣﯽ ﺷﻮد(‬
‫‪var‬‬
‫;‪count:integer‬‬
‫;‪ch:char‬‬
‫‪begin‬‬
‫;)'‪writeln('Please Enter Statement‬‬
‫;)‪read(ch‬‬
‫‪while ch<>'0' do‬‬
‫‪begin‬‬
‫‪if (ch='t') or (ch='T') then‬‬
‫;‪count:=count+1‬‬
‫;)‪readln(ch‬‬
‫;‪end‬‬
‫;)‪writeln('Number of characters= ',count‬‬
‫;‪readln‬‬
‫‪end.‬‬

‫ﻣﺜﺎل( ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ‪ N‬ﻋﺪد از ﮐﺎرﺑﺮ درﯾﺎﻓﺖ ﮐﻨﺪ و ﻣﺎﮐﺰﯾﻤﻢ و ﻣﯿﻨﯿﻤﻢ اﯾﻦ اﻋﺪاد را ﭼﺎپ ﮐﻨـﺪ‪).‬آﺧـﺮﯾﻦ ﻋـﺪد ورودي‬
‫ﺻﻔﺮ اﺳﺖ(‪.‬‬
‫‪var‬‬
‫;‪n,max,min:integer‬‬
‫‪begin‬‬
‫;)‪readln(n‬‬
‫;‪max:=n‬‬
‫;‪min:=n‬‬
‫‪while n<>0 do‬‬
‫‪begin‬‬
‫;)‪readln(n‬‬
‫‪if (n<>0) and (n>max) then‬‬
‫;‪max:=n‬‬
‫‪if (n<>0) and (n<min) then‬‬
‫;‪min:=n‬‬
‫;‪end‬‬
‫;)‪writeln('max=',max, ' min=',min‬‬
‫‪end.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪33‬‬
‫‪ - 2‬دﺳﺘﻮر ‪: Repeat- Until‬‬
‫ﺷﻜﻞ ﻛﻠﻲ ﺩﺳﺘﻮﺭ‪:‬‬
‫‪Repeat‬‬
‫; دﺳﺘﻮر ﯾﺎ دﺳﺘﻮرﻫﺎ‬
‫‪Until‬‬ ‫; ﻋﺒﺎرت ﺑﻮﻟﯽ‬
‫ﺩﺭ ﺍﻳﻦ ﺣﻠﻘﻪ ﺍﺑﺘﺪﺍ ﺩﺳﺘﻮﺭ ﻳﺎ ﺩﺳﺘﻮﺭﻫﺎ ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﻧﺪ ﺳﭙﺲ ﻋﺒﺎﺭﺕ ﺑﻮﻟﻲ )ﺷﺮﻁ( ﺑﺮﺭﺳﻲ ﻣﻲ ﺷـﻮﺩ ﺍﮔـﺮ ﻣﻘـﺪﺍﺭ ﺁﻥ ‪ FALSE‬ﺑﺎﺷـﺪ ﺁﻧﮕـﺎﻩ‬
‫ﺩﻭﺑﺎﺭﻩ ﺩﺳﺘﻮﺭ ﻳﺎ ﺩﺳﺘﻮﺭﻫﺎ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﺍﻳﻦ ﻋﻤﻞ ﺗﺎ ﺯﻣﺎﻧﻲ ﻛﻪ ﺷﺮﻁ ﺑﺮﺍﺑﺮ ‪ False‬ﺑﺎﺷﺪ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‪ .‬ﺷﺮﻁ ﺧﺮﻭﺟﻲ ﺍﺯ ﺍﻳﻦ ﺣﻠﻘـﻪ ﺍﻳـﻦ‬
‫ﺍﺳﺖ ﻛﻪ ﺷﺮﻁ ‪ True‬ﺷﻮﺩ‪.‬‬
‫ﻣﺜﺎﻝ ‪:‬‬
‫;‪A:=2‬‬
‫ﻓﻠﻮﭼﺎﺭﺕ ﻣﺮﺑﻮﻁ ﺑﻪ ﺣﻠﻘﺔ ‪:Repeat‬‬
‫‪Repeat‬‬
‫;)‪Writeln(A‬‬ ‫ﻧﻜﺘﻪ( ﺑﺮﺭﺳﻲ ﺷﺮﻁ ﺣﻠﻘﻪ ‪ Repeat‬ﺩﺭ ﺍﻧﺘﻬﺎﻱ ﺣﻠﻘﻪ‬
‫;‪A:=A+2‬‬ ‫ﺻﻮﺭﺕ ﻣﻲ ﮔﻴﺮﺩ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺣﺘﻤﺎ ﻳﻚ ﺑﺎﺭ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‬
‫;‪Until A>10‬‬
‫;)’*’(‪Writeln‬‬ ‫ﺍﻣﺎ ﺷﺮﻁ ﺣﻠﻘﺔ ‪ While‬ﺩﺭ ﺍﺑﺘﺪﺍﻱ ﺣﻠﻘﻪ ﺑﺮﺭﺳﻲ ﻣﻲ ﺷﻮﺩ‬
‫ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﻣﻤﻜﻦ ﺍﺳﺖ ﻳﻚ ﺑﺎﺭ ﻫﻢ ﺍﻧﺠﺎﻡ ﻧﺸﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺣﻠﻘﻪ ‪ While‬ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ ﺷﺮﻁ ‪ False‬ﺷﻮﺩ‬
‫ﺣﻠﻘﻪ ﺑﻪ ﺍﺗﻤﺎﻡ ﻣﻲ ﺭﺳﺪ ﺍﻣﺎ ﺩﺭ ﺣﻠﻘﺔ ‪ Repeat‬ﺍﮔﺮ ﺷﺮﻁ‬
‫‪ True‬ﺷﻮﺩ ﺣﻠﻘﻪ ﺑﻪ ﺍﺗﻤﺎﻡ ﻣﻲ ﺭﺳﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﻛﻠﻤﺔ ﺭﺯﺭﻭ ﺷﺪﺓ ‪ Until‬ﭘﺎﻳﺎﻥ ﺣﻠﻘﻪ ﺭﺍ ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﻧﻴـﺎﺯﻱ ﺑـﻪ ‪ Begin‬ﻭ ‪ End‬ﻧـﺪﺍﺭﺩ‪ .‬ﻳﻌﻨـﻲ ﺍﮔـﺮ‬
‫ﺗﻌﺪﺍﺩ ﺩﺳﺘﻮﺭﺍﺕ ﺩﺭ ﺑﺪﻧﺔ ﺣﻠﻘﻪ ﻫﻢ ﺑﻴﺶ ﺍﺯ ﻳﻜﻲ ﺑﺎﺷﺪ ﻧﻴﺎﺯﻱ ﺑﻪ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﺳﺘﻮﺭ ﻣﺮﻛـﺐ ﻧﻴـﺴﺖ‪ .‬ﺑﺪﻧـﻪ ﺣﻠﻘـﻪ ﺍﺯ ﺧـﻂ ‪ Repeat‬ﺗـﺎ ﺧـﻂ‬
‫‪ Until‬ﺍﺳﺖ‪.‬‬
‫ﻧﻜﺘﻪ( ﻛﻠﻤﺎﺕ‪ DO‬ﻭ ‪ While‬ﻭ‪ repeat‬ﻭ ‪ Until‬ﺫﺧﻴﺮﻩ )ﺭﺯﺭﻭ(ﺷﺪﻩ ﻫﺴﺘﻨﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺷﺮﻁ ﺣﻠﻘﺔ ‪ Repeat‬ﺭﺍ ﻃﻮﺭﻱ ﺗﻨﻈﻴﻢ ﻛﻨﺪ ﻛﻪ ﻫﺮﮔﺰ ‪ True‬ﻧﺸﻮﺩ ﻳﻚ ﺣﻠﻘﻪ ﺑﻲ ﻧﻬﺎﻳﺖ ﺍﻳﺠﺎﺩ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻣﺜﺎﻝ( ﺩﺭ ﻣﺜﺎﻝ ﺯﻳﺮ ﺷﺮﻁ ﺣﻠﻘﻪ ﻫﻤﻴﺸﻪ ‪ Flase‬ﺍﺳﺖ ﻭ ﻫﺮﮔﺰ ﺍﺯ ﺣﻠﻘﻪ ﺧﺎﺭﺝ ﻧﻤﻲ ﺷﻮﻳﻢ‪.‬ﺣﻠﻘﻪ ﺑﻲ ﻧﻬﺎﻳﺖ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪Repeat‬‬
‫;)’*’(‪Writeln‬‬
‫;)’‪Writeln(’ALI‬‬
‫;‪Until False‬‬
‫ﻧﻜﺘﻪ( ﺣﻠﻘﻪ ‪ Reapet‬ﺯﻣﺎﻧﻲ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺑﺨﻮﺍﻫﻴﻢ ﺑﺪﻧﻪ ﺣﻠﻘﻪ ﺣﺪﺍﻗﻞ ﻳﻚ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﺷﻮﺩ ﻭ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﻣﺸﺨﺺ ﻧﺒﺎﺷﺪ ‪.‬‬
‫ﺗﺴﺖ(ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫;‪Var X:Integer ; Y:Boolean‬‬
‫ﺏ( ﺍﻋﺪﺍﺩﻓﺮﺩ ‪ ١‬ﺗﺎ ‪٩‬‬ ‫ﺍﻟﻒ( ﺍﻋﺪﺍﺩ ﺯﻭﺝ ﻛﻮﭼﻜﺘﺮ ﺍﺯ ‪10‬‬
‫‪Begin‬‬
‫;‪X:=1‬‬ ‫ﺩ( ‪Run Time Error‬‬ ‫ﺝ( ﻋﺪﺩ ‪١‬‬
‫‪Repeat‬‬
‫;)‪Write(X:3‬‬
‫;‪X:=X+2‬‬
‫;‪Y:=X=11‬‬
‫;‪Until Y‬‬
‫‪End.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪34‬‬
‫;‪Readln(X); S:=0‬‬ ‫ﻣﺜﺎﻝ( ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬
‫‪Repeat‬‬ ‫ﺏ(ﻋﺪﺩﻱ ﻭﺭﻭﺩﻱ‬ ‫ﺍﻟﻒ( ﻣﻌﻜﻮﺱ ﻋﺪﺩ ﻭﺭﻭﺩﻱ‬
‫;‪R:=X MOD 10‬‬ ‫ﺩ( ﺭﻗﻢ ﻳﻜﺎﻥ ﻋﺪﺩ ﻭﺭﻭﺩﻱ‬ ‫ﺝ( ﻣﺠﻤﻮﻉ ﺍﺭﻗﺎﻡ ﻋﺪﺩ ﻭﺭﻭﺩﻱ‬
‫;‪X:=X Div 10‬‬
‫;‪S:=S+R‬‬
‫‪Until X<>0‬‬
‫;)‪Writeln(S‬‬

‫ﻣﺜﺎل ( ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﻣﺠﻤﻮع اﻋﺪاد ﯾﮏ ﺗﺎ ﺻﺪ را ﻣﺤﺎﺳﺒﻪ و ﭼﺎپ ﻧﻤﺎﯾﺪ‪.‬‬

‫‪Var‬‬
‫;‪i,sum:integer‬‬
‫‪begin‬‬
‫;‪i:=1‬‬
‫;‪sum:=0‬‬
‫‪repeat‬‬
‫;‪sum:=sum+i‬‬
‫;‪i:=i+1‬‬
‫;‪until i>100‬‬
‫;)‪writeln(sum‬‬
‫;‪readln‬‬
‫‪end.‬‬

‫ﻣﺜﺎل ( ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ ﻋﺪد درﯾﺎﻓﺖ ﮐﻨﺪ و ﭼﺎپ ﮐﻨﺪ ﮐﻪ اﯾﻦ ﻋﺪد اول اﺳﺖ ﯾﺎ ﻣﺮﮐﺐ‪.‬‬

‫‪Var‬‬
‫;‪c,n,t,r:integer‬‬
‫‪begin‬‬
‫;)‪readln(n‬‬
‫;‪t:=0; c:=1‬‬
‫‪repeat‬‬
‫;‪r:=n mod c‬‬
‫‪if r=0 then‬‬
‫;‪t:=t+1‬‬
‫;‪c:=c+1‬‬
‫;‪until c>n‬‬
‫‪if t=2 then‬‬
‫)'‪writeln('avval‬‬
‫‪else‬‬
‫;)'‪writeln('morakab‬‬
‫‪end.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪35‬‬
‫‪ - 3‬دﺳﺘﻮر ‪: FOR‬‬
‫ﺷﻜﻞ ﻛﻠﻲ ﺩﺳﺘﻮﺭ ‪: For‬‬
‫ﻣﻘﺪار اوﻟﯿﻪ =‪:‬ﻣﺘﻐﯿﺮاﺳﮑﺎﻟﺮ ‪FOR‬‬ ‫‪ DownTo‬ﯾﺎ ‪TO‬‬ ‫‪ DO‬ﻣﻘﺪار ﻧﻬﺎﯾﯽ‬
‫; ﯾﮏ دﺳﺘﻮر ﺳﺎده ﯾﺎ ﺳﺎﺧﺘﺎري‬
‫ﻣﺜﺎﻝ( ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺩﺳﺘﻮﺭ ;)’*’(‪ Write‬ﻫﺸﺖ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪For A:=2 TO 9 Do‬‬ ‫ﺍﺑﺘﺪﺍ ‪ A=2‬ﻣﻲ ﺷﻮﺩ ﻭ ﺩﺳﺘﻮﺭ )’*’(‪ Write‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﺳﭙﺲ ‪A=3‬‬
‫;)’*’(‪Write‬‬
‫;)’‪Write(’AMIN‬‬ ‫ﻣﻴﺸﻮﺩ ﻭ ﺍﻳﻦ ﻛﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ ﺗﺎ ﺯﻣﺎﻧﻲ ﻛﻪ ‪ A=9‬ﺷﻮﺩ‪ .‬ﺍﻟﺒﺘﻪ ﺑﺮﺍﻱ ‪ A=9‬ﻧﻴﺰ‬
‫ﺩﺳﺘﻮﺭ )’*’(‪ Write‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﺩﺳﺘﻮﺭ ;)’‪ Write(’AMIN‬ﻣﺮﺑﻮﻁ ﺑﻪ ‪ for‬ﻧﻤﻲ ﺷﻮﺩ ﻭ ﺑﻌﺪ ﺍﺯ ﺍﻳﻨﻜﻪ ﻫﺸﺖ ﺗﺎ * ﭼﺎﭖ ﺷﺪ ﺭﺷﺘﺔ‪ AMIN‬ﻳﻚ ﺑﺎﺭ ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﻣﺘﻐﻴﺮ ﻣﺮﺑﻮﻁ ﺑﻪ ﺷﻤﺎﺭﺵ ﺣﻠﻘﺔ ‪ for‬ﺭﺍ ﺷﻤﺎﺭﻧﺪﺓ ﺣﻠﻘﻪ ﻣﻲ ﻧﺎﻣﻨﺪ‪).‬ﻣﺘﻐﻴﺮ ﺍﺳﻜﺎﻟﺮ(‬
‫ﻧﻜﺘﻪ( ﺷﻤﺎﺭﻧﺪﻩ ﺣﻠﻘﻪ ﺩﺭ ﻫﺮ ﺑﺎﺭ ﺍﺟﺮﺍﻱ ﺣﻠﻘﻪ ﺑﻪ ﻃﻮﺭ ﺧﻮﺩﻛﺎﺭ ﻳﻚ ﻭﺍﺣﺪ ﺍﺿﺎﻓﻪ ﻳﺎ ﻛﺎﻫﺶ ﭘﻴﺪﺍ ﻣﻲ ﻛﻨﺪ‪ .‬ﺍﮔﺮ ﺍﺯ ﻛﻠﻤـﺔ ‪ TO‬ﺍﺳـﺘﻔﺎﺩﻩ ﻛـﺮﺩﻩ‬
‫ﺑﺎﺷﻴﺪ ﺷﻤﺎﺭﻧﺪﺓ ﺣﻠﻘﻪ ﻳﻚ ﻭﺍﺣﺪ ﺍﻓﺰﺍﻳﺶ ﻣﻲ ﻳﺎﺑﺪ ﻛﻪ ﺍﺻﻄﻼﺣﺎ ﻣﻲ ﮔﻮﻳﻨﺪ ‪ For‬ﺍﻓﺰﺍﻳﺸﻲ ﺍﻳﺠﺎﺩ ﺷﺪﻩ ﺍﺳـﺖ‪ .‬ﺍﻣـﺎ ﺍﮔـﺮ ﺍﺯ ﻛﻠﻤـﺔ ‪DownTo‬‬
‫ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﺪ ﺷﻤﺎﺭﻧﺪﺓ ﺣﻠﻘﻪ ﻳﻚ ﻭﺍﺣﺪ ﻛﺎﻫﺶ ﻣﻲ ﻳﺎﺑﺪ ﻛﻪ ﺍﺻﻄﻼﺣﺎ ﻣﻲ ﮔﻮﻳﻨﺪ ‪ For‬ﻛﺎﻫﺸﻲ ﺍﻳﺠﺎﺩ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬

‫ﻣﺜﺎﻝ( ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﻳﻚ ‪ for‬ﻛﺎﻫﺸﻲ ﺍﺳﺖ ﻛﻪ ﺷﻤﺎﺭﻧﺪﺓ ﺁﻥ ‪ K‬ﺍﺳﺖ ﻛﻪ ﺍﺯ ‪ ١٠٠‬ﺷﺮﻭﻉ ﻣﻲ ﺷﻮﺩ ﻭ ﻳﻚ ﻭﺍﺣﺪ‪ ،‬ﻳﻚ ﻭﺍﺣﺪ ﻛﺎﻫﺶ ﻣﻲ ﻳﺎﺑﺪ‪.‬‬
‫‪For K:=100 DownTo 1 Do‬‬ ‫ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺩﺳﺘﻮﺭ ‪ IF‬ﻛﻪ ﻳﻚ ﺩﺳﺘﻮﺭ ﺳﺎﺧﺘﺎﺭﻱ ﺍﺳﺖ ﺑﻼﻙ ﻣﺮﺑﻮﻁ ﺑﻪ ‪ For‬ﺍﺳﺖ‪.‬‬
‫‪IF (K MOD 2)=0 then‬‬
‫;)‪Writeln(K‬‬ ‫ﻭ ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺍﻋﺪﺍﺩ ﺯﻭﺝ ﺑﻴﻦ ‪ 100‬ﺗﺎ ‪ 1‬ﭼﺎﭖ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﻭ ﺩﺳﺘﻮﺭ ;)‪ Writeln(K‬ﺑﻼﻙ ﻣﺮﺑﻮﻁ ﺑﻪ ‪ IF‬ﺍﺳﺖ ﻛﻪ ﻳﻚ ﺩﺳﺘﻮﺭ ﺳﺎﺩﻩ ﺍﺳﺖ‪.‬‬

‫ﻧﻜﺘﻪ( ﺩﺭ ‪ For‬ﺍﻓﺰﺍﻳﺸﻲ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﺍﺯ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ﺑﺎﻳﺪ ﻛﻮﭼﻜﺘﺮ ﻳﺎ ﻣﺴﺎﻭﻱ ﺑﺎﺷﺪ‪ .‬ﺩﺭ ﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ ﺧﻄﺎﻳﻲ ﺭﺥ ﻧﻤﻲ ﺩﻫﺪ ﺑﻠﻜﻪ ﺣﻠﻘﻪ ﺗﻜﺮﺍﺭ‬
‫ﻧﻤﻲ ﺷﻮﺩ‪ .‬ﺩﺭﺻﻮﺭﺗﻲ ﻛﻪ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﻭ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ﻣﺴﺎﻭﻱ ﺑﺎﺷﺪﺣﻠﻘﻪ ﻳﻚ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬

‫ﻣﺜﺎﻝ(ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺣﻠﻘﺔ ‪ For‬ﺍﻓﺰﺍﻳﺸﻲ ﺍﺳﺖ ﺍﻣﺎ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ)‪ (3‬ﺍﺯ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ )‪ (1‬ﺑﺰﺭﮔﺘﺮ ﺍﺳﺖ ﺑﻪ ﻫﻤﻴﻦ ‪For T:=3 To 1 Do‬‬
‫;)‪Writeln(T‬‬ ‫ﺩﻟﻴﻞ ﺩﺳﺘﻮﺭ ;)‪ Write(T‬ﺍﺻﻼ ﺗﻜﺮﺍﺭ ﻧﻤﻲ ﺷﻮﺩ ﻭ ﺩﺳﺘﻮﺭ ;)’*’(‪ Write‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫;)’*’(‪Write‬‬

‫ﻧﻜﺘﻪ( ﺩﺭ ‪ For‬ﻛﺎﻫﺸﻲ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﺍﺯ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ﺑﺎﻳﺪ ﺑﺰﺭﮔﺘﺮ ﻳﺎ ﻣﺴﺎﻭﻱ ﺑﺎﺷﺪ‪ .‬ﺩﺭﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ ﺧﻄﺎﻳﻲ ﺭﺥ ﻧﻤﻲ ﺩﻫﺪ ﺑﻠﻜﻪ ﺣﻠﻘـﻪ ﺗﻜـﺮﺍﺭ‬
‫ﻧﻤﻲ ﺷﻮﺩ‪ .‬ﺩﺭﺻﻮﺭﺗﻲ ﻛﻪ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﻭ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ﻣﺴﺎﻭﻱ ﺑﺎﺷﺪ ﺣﻠﻘﻪ ﻳﻚ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬

‫ﻣﺜﺎﻝ(ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺣﻠﻘﻪ ‪ For‬ﻛﺎﻫﺸﻲ ﺍﺳﺖ ﺍﻣﺎ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ)‪ (1‬ﺍﺯ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ)‪ (5‬ﻛﻮﭼﻜﺘﺮ ﺍﺳﺖ‪For C:=1 DownTo 5 Do .‬‬
‫;)‪Writeln(C‬‬ ‫ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺩﺳﺘﻮﺭ ;)‪ Writeln(C‬ﺍﺻﻼ ﺗﻜﺮﺍﺭ ﻧﻤﻲ ﺷﻮﺩ ﻭ ﺩﺳﺘﻮﺭ ;)’‪ Write(’#‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫;)’‪Write(’#‬‬

‫ﻧﻜﺘﻪ(ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﻭ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ﻭ ﺷﻤﺎﺭﻧﺪﺓ ﺣﻠﻘﺔ ‪ for‬ﺑﺎﻳﺪ ﺍﺯ ﻧﻮﻉ ﺍﺳﻜﺎﻟﺮ ﺑﺎﺷﻨﺪ ﺩﺭ ﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﺻﺎﺩﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﻛﻠﻤﺎﺕ ‪ DO‬ﻭ ‪ For‬ﻭ ‪ Downto‬ﻭ ‪ TO‬ﺭﺯﺭﻭ ﺷﺪﻩ ﻫﺴﺘﻨﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﻫﻨﮕﺎﻣﻲ ﺍﺯ ﺣﻠﻘﺔ ‪ For‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺣﻠﻘﻪ ﻣﺸﺨﺺ ﺑﺎﺷﺪ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪36‬‬
‫ﻓﻠﻮﭼﺎﺭﺕ ﺭﻭﺑﺮﻭ ﻣﺮﺑﻮﻁ ﺑﻪ ﻋﻤﻠﻜﺮﺩ ﺩﺳﺘﻮﺭ ‪ For‬ﺍﻓﺰﺍﻳﺸﻲ ﺍﺳﺖ‪ .‬ﺩﻗﺖ ﻛﻨﻴﺪ ﻛﻪ ﺷﺮﻁ ﻭﺭﻭﺩ ﺑﻪ‬
‫ﺣﻠﻘﻪ ﺩﺭ ﺍﺑﺘﺪﺍﻱ ﺣﻠﻘﻪ ﭼﻚ ﻣﻲ ﺷﻮﺩ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺍﺣﺘﻤﺎﻝ ﺩﺍﺭﺩ ﻛﻪ ﺣﻠﻘﻪ ﺍﺻﻼ ﺗﻜﺮﺍﺭ ﻧﺸﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺩﺳﺘﻮﺭﺍﺕ ﺩﺍﺧﻞ ﺑﻼﻙ ‪ for‬ﺑﺴﺘﮕﻲ ﺑﻪ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﻭ ﻧﻬﺎﻳﻲ ﺣﻠﻘﻪ ﺩﺍﺭﺩ‪.‬‬
‫ﺑﺎﻓﺮﺽ ﺍﻳﻨﻜﻪ ﺩﺳﺘﻮﺭﺍﺕ ﺩﺍﺧﻞ ﺣﻠﻘﻪ ﺭﻭﻱ ﻣﺘﻐﻴﺮ ﺷﻤﺎﺭﻧﺪﻩ ﺗﺎﺛﻴﺮﻱ ﻧﮕﺬﺍﺷﺘﻪ ﺑﺎﺷﺪ ﻣﻲ ﺗﻮﺍﻧﻴﻢ‬
‫ﺑﻮﺳﻴﻠﻪ ﺭﻭﺍﺑﻂ ﺯﻳﺮ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺣﻠﻘﻪ ﺭﺍ ﺑﺪﺳﺖ ﺁﻭﺭﺩ‬
‫‪ + 1‬ﻣﻘﺪار اﺑﺘﺪاﯾﯽ – ﻣﻘﺪار ﻧﻬﺎﯾﯽ= ﺗﻌﺪاد ﺗﮑﺮار‬ ‫‪ For‬ﺍﻓﺰﺍﻳﺸﻲ ‪ç‬‬

‫‪ + 1‬ﻣﻘﺪار ﻧﻬﺎﯾﯽ – ﻣﻘﺪرا اوﻟﯿﻪ = ﺗﻌﺪادﺗﮑﺮار‬ ‫‪ For‬ﻛﺎﻫﺸﻲ ‪ç‬‬

‫ﺷﺮﻁ ﺗﻜﺮﺍﺭ ﺣﻠﻘﻪ ﺩﺭﺳﺖ ﺑﻮﺩﻥ ﺷﺮﻁ ﺍﺑﺘﺪﺍﻱ ﺣﻠﻘﻪ ﺍﺳﺖ‪ .‬ﺩﻗﺖ ﻛﻨﻴﺪ ﻛﻪ‬
‫ﺷﺮﻁ ﺩﺭ ﺩﺳﺘﻮﺭ ﻧﻬﻔﺘﻪ ﺍﺳﺖ‪.‬‬
‫ﻧﻜﺘﻪ( ﺍﮔﺮﺑﻌﺪ ﺍﺯ ﻛﻠﻤﺔ ‪ Do‬ﻋﻼﻣﺖ ; ﻗﺮﺍﺭ ﺩﻫﻴﺪ ﺧﻄﺎﻳﻲ ﺭﺥ ﻧﻤﻲ ﺩﻫﺪ ﺑﻠﻜﻪ ﻋﻼﻣﺖ ; ﺑﻪ ﻋﻨﻮﺍﻥ ﺑﻼﻙ ‪ for‬ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮﺩ‪).‬ﺧﻄـﺎﻱ‬
‫ﻣﻨﻄﻘﻲ( ﻛﻪ ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﻳﻚ ﺣﻠﻘﻪ ﺗﺎﺧﻴﺮ ﺍﻳﺠﺎﺩ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬
‫ﻣﺜﺎﻝ( ﺧﺮﻭﺟﻲ ﻗﻄﻌﻪ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫;‪For H:=1 To 12 Do‬‬
‫ﺩ( ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﺩﺍﺭﺩ‬ ‫ﺝ( ﻋﺪﺩ ‪١٢‬‬ ‫ﺏ( ﻋﺪﺩ ‪١‬‬ ‫ﺍﻟﻒ( ﺍﻋﺪﺍﺩ ‪ ١‬ﺗﺎ ‪١٢‬‬
‫;)‪Write(H‬‬
‫ﭼﻮﻥ ﺑﻌﺪ ﺍﺯ ‪ Do‬ﻋﻼﻣﺖ ; ﻗﺮﺍﺭ ﮔﺮﻓﺘﻪ ﺷﺪﻩ ﺍﺳﺖ ﭘﺲ ﺩﺳﺘﻮﺭ ;)‪ Write(H‬ﻣﺮﺑﻮﻁ ﺑﻪ ‪ for‬ﻧﻴﺴﺖ‪ .‬ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﻳﻚ ﺣﻠﻘﻪ ﺗـﺎﺧﻴﺮ ﺍﻳﺠـﺎﺩ‬
‫ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﻭ ﻣﺘﻐﻴﺮ ‪ H‬ﺍﺑﺘﺪﺍ ‪ ١‬ﻭ ﺳﭙﺲ ‪ ٢‬ﻭ … ﻭ ﺩﺭ ﻧﻬﺎﻳﺖ ‪ ١٢‬ﻣﻲ ﺷﻮﺩ ﻭ ﺍﺯ ﺣﻠﻘﻪ ﺗﺎﺧﻴﺮ ﺧﺎﺭﺝ ﻣـﻲ ﺷـﻮﺩ ﻭ ﺩﺳـﺘﻮﺭ ‪ Write‬ﺍﻧﺠـﺎﻡ ﻣـﻲ‬
‫ﺷﻮﺩ ﻛﻪ ﻣﻘﺪﺍﺭ ‪ ١٢ ، H‬ﺍﺳﺖ‪) .‬ﮔﺰﻳﻨﻪ ﺝ(‬
‫ﻧﻜﺘﻪ( ﭘﺲ ﺍﺯ ﺧﺎﺗﻤﺔ ﺣﻠﻘﺔ ‪ For‬ﻣﻌﻤﻮﻻ ﻣﻘﺪﺍﺭﻱ ﻛﻪ ﺩﺭ ﻣﺘﻐﻴﺮ ﺷﻤﺎﺭﻧﺪﻩ ﻗﺮﺍﺭ ﺩﺍﺭﺩ ﻗﺎﺑﻞ ﺍﻋﺘﺒﺎﺭ ﻧﻴﺴﺖ‪ .‬ﺍﻣﺎ ﺩﺭ ﺗﻮﺭﺑﻮﭘﺎﺳـﻜﺎﻝ ﻣﻘـﺪﺍﺭ ﺁﻥ ﺑﺮﺍﺑـﺮ‬
‫ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ﺍﺳﺖ‪.‬‬
‫ﻧﻜﺘﻪ( ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﻭ ﻧﻬﺎﻳﻲ ﺣﻠﻘﻪ ﻣﻲ ﺗﻮﺍﻧﺪ ﻋﺒﺎﺭﺕ ﺑﺎﺷﺪ) ﻋﺒﺎﺭﺗﻲ ﻛﻪ ﺣﺎﺻﻞ ﺁﻥ ﺍﺳﻜﺎﻟﺮ ﺷﻮﺩ( ﺍﻣﺎ ﻣﻘﺪﺍﺭ ﻋﺒﺎﺭﺗﻬﺎ ﻳﻚ ﺑﺎﺭ ﺍﺭﺯﻳﺎﺑﻲ ﻣﻲ ﺷﻮﺩ ﻭ‬
‫ﺩﻳﮕﺮ ﺗﻐﻴﻴﺮ ﻧﻤﻲ ﻛﻨﺪ‪.‬‬
‫;‪M:=5‬‬ ‫ﻣﺜﺎﻝ( ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ﺣﻠﻘﻪ ﺩﺭ ﺍﺑﺘﺪﺍﻱ ﺣﻠﻘﻪ ﺑﺮﺍﺑﺮ ‪ 6‬ﻣﻲ ﺷﻮﺩ ﻭ‬
‫‪For A:=1 To M+1 Do‬‬ ‫ﺣﻠﻘﺔ ‪ for‬ﺍﺯ ﻳﻚ ﺗﺎ ﺷﺶ ﺗﻜﺮﺍﺭﻣﻲ ﺷﻮﺩ ﺑﺎ ﺍﻳﻨﻜﻪ ﻣﻘﺪﺍﺭ ‪ M‬ﺩﺭ ﻫﺮ ﺑﺎﺭ ﺍﺟﺮﺍﻱ ﺣﻠﻘﻪ‬
‫‪Begin‬‬
‫;)‪Writeln(A‬‬ ‫ﺗﻐﻴﻴﺮ ﻣﻲ ﻛﻨﺪ ﺍﻣﺎ ﺩﻳﮕﺮ ﺗﺎﺛﻴﺮﻱ ﺩﺭ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ﺣﻠﻘﻪ ﻧﺪﺍﺭﺩ‪.‬‬
‫;‪M:=M+2‬‬ ‫ﺍﻋﺪﺍﺩ ‪ ١‬ﺗﺎ ‪ ٦‬ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ‪ M).‬ﺍﺯ ﻧﻮﻉ ﺻﺤﻴﺢ ﺍﺳﺖ(‬
‫;‪End‬‬
‫ﻣﻌﻤﻮﻻ ﻣﻘﺪﺍﺭ ﺷﻤﺎﺭﻧﺪﺓ ﺣﻠﻘﻪ ﺭﺍ ﺩﺭ ﺑﺪﻧﺔ ﺣﻠﻘﻪ ﺗﻐﻴﻴﺮ ﻧﻤﻲ ﺩﻫﻨﺪ ﺍﻣﺎ ﺍﮔﺮ ﺍﻳﻦ ﻛﺎﺭ ﺭﺍ ﺍﻧﺠﺎﻡ ﺩﻫﻴﻢ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺣﻠﻘﻪ ﺗﻐﻴﻴﺮ ﺧﻮﺍﻫﺪ ﻛﺮﺩ‪.‬‬

‫;‪S:=2‬‬ ‫ﻣﺜﺎﻝ( ﺩﺭ ﻗﻄﻌﻪ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ‪ 2‬ﺍﺳﺖ ﻭ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ‪ 12‬ﺍﺳﺖ‪.‬ﺷﻤﺎﺭﻧﺪﺓ ﺣﻠﻘﻪ ‪ H‬ﺍﺳﺖ‬
‫‪For H:=S To 12 Do‬‬ ‫ﻛﻪ ﺩﺭ ﻫﺮ ﺑﺎﺭ ﺍﺟﺮﺍ ﺑﻄﻮﺭ ﺧﻮﺩﻛﺎﺭ ﻳﻚ ﻭﺍﺣﺪ ﺑﻪ ﺁﻥ ﺍﺿﺎﻓﻪ ﻣﻲ ﺷﻮﺩ ﻭ ﺩﺭﻫﺮ ﺑﺎﺭ ﺍﺟﺮﺍ ﺩﺭ ﺑﺪﻧﺔ ‪ For‬ﻧﻴﺰ‬
‫‪Begin‬‬ ‫ﺩﻭ ﻭﺍﺣﺪ ﺑﻪ ﺁﻥ ﺍﺿﺎﻓﻪ ﻣﻲ ﻛﻨﻴﻢ‪ .‬ﭘﺲ ﺳﻪ ﻭﺍﺣﺪ‪ ،‬ﺳﻪ ﻭﺍﺣﺪ ﺍﻓﺰﺍﻳﺶ ﻣﻲ ﻳﺎﺑﺪ‪.‬‬
‫;)‪Writeln(H‬‬
‫;‪H:=H+2‬‬ ‫ﺍﻋﺪﺍﺩ ‪ 2 5 8 11‬ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ ﻭ ﺣﻠﻘﻪ ﭼﻬﺎﺭ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ ﻭ‬
‫;‪S:=17‬‬ ‫ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ﺷﻤﺎﺭﻧﺪﺓ ﺣﻠﻘﻪ ‪ 13‬ﺍﺳﺖ‪.‬‬
‫;‪End‬‬
 37 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
‫ﺗﺴﺖ( ﺣﺎﺻﻞ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﺔ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
Const K:integer=100;
Begin ١٠٠ (‫ﺏ‬ ١ ‫ ﺗﺎ‬١٠٠ ‫ﺍﻟﻒ( ﭼﺎﭖ ﺍﻋﺪﺍﺩ‬
For K:=100 downto 1 do .‫ ﺍﺯ ﻧﻮﻉ ﺛﺎﺑﺖ ﺍﺳﺖ‬K ‫ﺩ( ﺧﻄﺎ ﺩﺍﺭﺩ ﭼﻮﻥ‬ ١ (‫ﺝ‬
Write(K);
End.

‫ ﻋﺪد از ورودي درﯾﺎﻓﺖ ﮐﻨﺪ و ﺳﭙﺲ ﺗﻌـﺪاد اﻋـﺪاد زوج و ﻓـﺮد را ﺷـﻤﺮده و در ﺧﺮوﺟـﯽ ﭼـﺎپ‬5 ‫ﻣﺜﺎل(ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ‬
.‫ﻧﻤﺎﯾﺪ‬
Var
i,even,odd,number:integer;
begin
writeln('Please Enter Five Numbers ');
even:=0;
odd:=0;
for i:=1 to 5 do
begin
read(number);
if (number mod 2)=0 then
even:=even+1
else
odd:=odd+1;
end;
writeln('Number of even= ',even);
writeln('Number of odd= ',odd);
end.

.‫ﻣﺜﺎل (ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ ﻋﺪد از ورودي درﯾﺎﻓﺖ ﮐﻨﺪ و ﭼﺎپ ﮐﻨﺪ ﮐﻪ اﯾﻦ ﻋﺪد اول اﺳﺖ ﯾﺎ ﻣﺮﮐﺐ‬
var
c,n,t:integer;
begin
readln(n);
t:=0;
for c:=1 to n do
if n mod c = 0 then
t:=t+1;
If t=2 then
writeln('avval')
else
writeln('morakab');
end.
‫ﺗﻤﺮﯾﻦ ( ﺧﺮوﺟﯽ ﺑﺮﻧﺎﻣﻪ روﺑﺮو ﭼﯿﺴﺖ؟‬
var
a:boolean;
begin
for a:=false to true do
write(a);
end.
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪38‬‬
‫‪var‬‬ ‫ﺗﻤﺮﯾﻦ (ﺧﺮوﺟﯽ ﺑﺮﻧﺎﻣﻪ روﺑﺮو ﭼﯿﺴﺖ؟‬
‫;‪c:char‬‬
‫‪begin‬‬
‫‪for c:='A' to 'F' do‬‬
‫;)‪write(c‬‬
‫‪end.‬‬

‫ﺣﻠﻘﻪ ﻫﺎي ﻣﺘﺪاﺧﻞ‪:‬‬

‫ﻫﻤﺎﻧﻄﻮﺭ ﻛﻪ ﺩﺭ ﺷﻜﻞ ﻛﻠﻲ ﺩﺳﺘﻮﺭﺍﺕ ﺣﻠﻘﻪ ﻣﺸﺨﺺ ﺷﺪﻩ ﺑﻮﺩ ﺑﻼﻙ ﻣﺮﺑﻮﻁ ﺑﻪ ﺣﻠﻘﻪ ﻣﻲ ﺗﻮﺍﻧﺪ ﻳﻚ ﺩﺳﺘﻮﺭ ﺳـﺎﺧﺘﺎﺭﻱ ﺑﺎﺷـﺪ ﺍﺯ ﺟﻤﻠـﻪ ﻳـﻚ‬
‫ﺣﻠﻘﻪ ﺩﻳﮕﺮ‪ .‬ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﺩﻭ ﺣﻠﻘﻪ ﻣﺘﺪﺍﺧﻞ ﺍﻳﺠﺎﺩ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺩﺍﺧﻠﻲ ﺗﺮﻳﻦ ﺩﺳﺘﻮﺭ ﺣﻠﻘﻪ ﻫﺎﻱ ﻣﺘﺪﺍﺧﻞ ﺑﺮﺍﺑﺮ ﺣﺎﺻﻠﻀﺮﺏ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﻫﺮ ﻛﺪﺍﻡ ﺍﺯ ﺣﻠﻘﻪ ﻫﺎ ﺍﺳﺖ‪.‬‬
‫ﻣﺜﺎﻝ( ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺩﻭ ﺣﻠﻘﻪ ﻣﺘﺪﺍﺧﻞ ﺍﻳﺠﺎﺩ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺩﺳﺘﻮﺭ ;)’*’(‪ Write‬ﻣﺮﺑﻮﻁ ﺑﻪ‬
‫‪For H:=1 To 8 Do‬‬ ‫‪ For‬ﺩﻭﻣﻲ ﺍﺳﺖ ﻭ ‪ for‬ﺩﻭﻣﻲ ﺑﻼﻙ ﻣﺮﺑﻮﻁ ﺑﻪ ‪ For‬ﺍﻭﻟﻲ ﺍﺳﺖ‪ .‬ﺑﺮﺍﻱ ‪ H=1‬ﺣﻠﻘﺔ ﺩﻭﻡ‬
‫‪For Z:=3 downto -1 Do‬‬
‫;)’*’(‪Write‬‬ ‫ﭘﻨﺞ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ ﻳﻌﻨﻲ ﭘﻨﺞ ﺑﺎﺭ * ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ ﻭ ﺑﺮﺍﻱ ‪ H=2‬ﺩﻭﺑﺎﺭﻩ ﺣﻠﻘﺔ ﺩﻭﻡ ﭘﻨﺞ‬
‫ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ ﻳﻌﻨﻲ …‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﻣﺠﻤﻮﻋﺎ ‪ ٤٠=٥×٨‬ﺑﺎﺭ * ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ‪.‬‬

‫;‪A:=1; N:=0‬‬ ‫ﻣﺜﺎﻝ( ﺧﺮﻭﺟﻲ ﻗﻄﻌﻪ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬

‫‪While A<9 Do‬‬ ‫ﺣﻠﻘﺔ ‪ While‬ﻭ ﺣﻠﻘﺔ ‪ For‬ﺑﺎ ﻫﻢ ﺍﺩﻏﺎﻡ ﺷﺪﻩ ﺍﻧﺪ‪.‬‬
‫‪Begin‬‬
‫‪For Z:=1 To 4 Do‬‬
‫;‪N:=N+Z‬‬ ‫ﻧﮑﺘﻪ(ﻫﺮ ﺳﻪ ﺩﺳﺘﻮﺭ ﻣﺮﺑﻮﻁ ﺑﻪ ﺣﻠﻘﻪ ﻫﺎ ﻣﻲ ﺗﻮﺍﻧﻨﺪ ﺑﺎ ﻫﻢ ﺗﺮﻛﻴﺐ ﺷﻮﻧﺪ ﻭ‬
‫;‪A:=A+3‬‬ ‫ﺣﻠﻘﻪ ﻫﺎﻱ ﻣﺘﺪﺍﺧﻞ ﺭﺍ ﺍﻳﺠﺎﺩ ﻛﻨﻨﺪ‪.‬‬
‫;‪End‬‬
‫;)‪Writeln(N‬‬

‫ﻣﺜﺎل(ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را داﺷﺘﻪ ﺑﺎﺷﺪ ‪:‬‬

‫‪Var‬‬
‫;‪i,j:integer‬‬ ‫‪1‬‬
‫‪begin‬‬ ‫‪1 2‬‬
‫;‪writeln‬‬ ‫‪1 2 3‬‬
‫‪for i:=1 to 4 do‬‬ ‫‪1 2 3 4‬‬
‫‪begin‬‬
‫‪for j:=1 to i do‬‬
‫;)‪write(j:3‬‬
‫;‪writeln‬‬
‫;‪end‬‬
‫;‪readln‬‬
‫‪end.‬‬
 39 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
‫ﺗﻤﺮﯾﻦ (ﺧﺮوﺟﯽ ﺑﺮﻧﺎﻣﻪ روﺑﺮو ﭼﯿﺴﺖ؟‬
var
i,j:integer;
begin
for i:=1 to 5 do
begin
for j:=i downto 1 do
write(j:3);
writeln;
end;
end.

.‫ را ﭼﺎپ ﻧﻤﺎﯾﺪ‬200 ‫ ﺗﺎ‬100 ‫ﻣﺜﺎل ( ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ اﻋﺪاد اول ﺑﯿﻦ‬

var
c,n,t:integer;
begin
for n:=100 to 200 do
begin
t:=0;
for c:=1 to n do
if n mod c = 0 then
t:=t+1;
if t=2 then
writeln(n);
end;
end.
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪40‬‬

‫;‪A:=10‬‬ ‫دﺳﺘﻮرات و‪ Break‬و ‪ Continue‬و ‪: Exit‬‬

‫‪While A>0 Do‬‬ ‫ﺩﺳﺘﻮﺭ ‪ Break‬ﺑﺎﻋﺚ ﺷﻜﺴﺘﻪ ﺷﺪﻥ ﺣﻠﻘﻪ ﺍﻳﻲ ﻛﻪ ﺩﺍﺧﻞ ﺁﻥ ﻫﺴﺘﻴﻢ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪Begin‬‬ ‫ﻣﺜﺎﻝ( ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺍﻋﺪﺍﺩ ‪ 10‬ﺗﺎ ‪ 5‬ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ ﻭ ﺑﻪ ﻫﻤﻴﻦ ﺗﻌﺪﺍﺩ ﻫﻢ * ﭼﺎﭖ‬
‫;)‪Writeln(A‬‬
‫‪IF A<=4 Then‬‬ ‫ﻣﻲ ﺷﻮﺩ ﺍﻣﺎ ﻫﻨﮕﺎﻣﻲ ﻛﻪ ‪ A=4‬ﻓﻘﻂ ﻋﺪﺩ ‪ 4‬ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ ﻭ ﺩﺳﺘﻮﺭ ‪ Break‬ﺍﻧﺠﺎﻡ‬
‫;‪Break‬‬ ‫ﻣﻲ ﺷﻮﺩ ﻭ ﺍﺯ ﺣﻠﻘﻪ ‪ While‬ﺧﺎﺭﺝ ﻣﻲ ﺷﻮﻳﻢ‪.‬‬
‫;)’*’(‪Write‬‬ ‫ﺩﻗﺖ ﻛﻨﻴﺪ ﻛﻪ ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺩﺳﺘﻮﺭ ‪ break‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﻛﻼ ﺍﺯ ﺣﻠﻘﻪ ﺧﺎﺭﺝ ﻣﻲ ﺷﻮﻳﻢ ﻭ‬
‫;‪A:=A-1‬‬
‫;‪End‬‬ ‫ﺩﻳﮕﺮ ﺑﻘﻴﻪ ﺩﺳﺘﻮﺭﺍﺕ ﺣﻠﻘﻪ ﺍﻧﺠﺎﻡ ﻧﻤﻲ ﺷﻮﺩ ﺍﻣﺎ ﺑﻘﻴﻪ ﺩﺳﺘﻮﺭﺍﺕ ﺑﺮﻧﺎﻣﻪ ﺩﻧﺒﺎﻝ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﺩﺳﺘﻮﺭ ‪ Break‬ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﺮﺍﻱ ﻫﺮ ﻛﺪﺍﻡ ﺍﺯ ﺩﺳﺘﻮﺭﺍﺕ ﺣﻠﻘﻪ ﺑﻜﺎﺭ ﺑﺮﺩ‪.‬‬
‫ﺩﺳﺘﻮﺭ ‪ continue‬ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ‪:‬‬
‫‪For S:=9 DownTo 1‬‬
‫‪Do‬‬ ‫ﻛﻨﺘﺮﻝ ﺍﺟﺮﺍﻱ ﺣﻠﻘﻪ ﺑﻪ ﺍﺑﺘﺪﺍﻱ ﺣﻠﻘﻪ ﻣﻨﺘﻘﻞ ﺷﻮﺩ‪.‬‬
‫‪Begin‬‬ ‫ﻣﺜﺎﻝ( ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﻫﻨﮕﺎﻣﻲ ﻛﻪ ‪ S=5‬ﺩﺭﺳﺖ ﻣﻴﺸﻮﺩ ﺁﻧﮕﺎﻩ ﺩﺳﺘﻮﺭ )‪ Write(S‬ﺍﻧﺠﺎﻡ‬
‫;)’*’(‪Write‬‬
‫ﻧﻤﻲ ﺷﻮﺩ‪ .‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﭼﻴﺴﺖ؟‬
‫‪IF S=5 then‬‬
‫;‪Continue‬‬ ‫ﺩﺳﺘﻮﺭ ‪ Continue‬ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﺮﺍﻱ ﻫﺮ ﻛﺪﺍﻡ ﺍﺯ ﺣﻠﻘﻪ ﻫﺎ ﺑﻜﺎﺭ ﺑﺮﺩ‪.‬‬
‫;)‪Write(S‬‬ ‫ﺍﮔﺮ ﺣﻠﻘﻪ ﻫﺎﻱ ﻣﺘﺪﺍﺧﻞ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ‪ Continue‬ﻭ ‪ Break‬ﻣﺮﺑﻮﻁ ﺑﻪ ﻫﺮ ﺣﻠﻘﻪ‬
‫;‪End‬‬ ‫ﻓﻘﻂ ﺭﻭﻱ ﻫﻤﺎﻥ ﺣﻠﻘﻪ ﺗﺎﺛﻴﺮ ﻣﻲ ﮔﺬﺍﺭﺩ‪.‬‬

‫…… ‪For‬‬ ‫ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺩﺳﺘﻮﺭ ‪ Break‬ﺑﻪ ﺩﻟﻴﻞ ﺍﻳﻨﻜﻪ ﺩﺭ ﺑﺪﻧﻪ ‪ While‬ﺍﺳﺖ ﭘﺲ ﻓﻘﻂ ﺣﻠﻘﺔ‬
‫‪Begin‬‬ ‫‪ while‬ﺭﺍ ﻣﻲ ﺷﻜﻨﺪ ‪ .‬ﺩﺳﺘﻮﺭ ‪ Continue‬ﻣﺮﺑﻮﻁ ﺑﻪ ﺣﻠﻘﻪ ‪ for‬ﺍﺳﺖ ﻭ ﭘﺲ ﺩﺭ ﺻﻮﺭﺕ‬
‫‪While …..‬‬
‫ﺍﺟﺮﺍ ﺷﺪﻥ ‪ Continue‬ﺑﻪ ﺍﺑﺘﺪﺍﻱ ﺣﻠﻘﻪ ‪ for‬ﻣﻲ ﺭﻭﻳﻢ‪.‬‬
‫‪Begin‬‬
‫;‪Break‬‬

‫;‪End‬‬
‫;‪Contine‬‬
‫;‪End‬‬

‫دﺳﺘﻮر ‪: Exit‬‬
‫ﻫﺪﻑ ‪ :‬ﺍﻧﺘﻘﺎﻝ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺧﺎﺭﺝ ﺍﺯ ﺑﻠﻮﮎ ﻓﻌﻠﯽ‬
‫ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺩﺭ ﻫﺮ ﺑﻠﻮﮎ ﺍﺯ ﺑﺮﻧﺎﻣﻪ ﺑﺎﻋﺚ ﻣﯽ ﺷﻮﺩ ﮐﻪ ﮐﻨﺘﺮﻝ ﺑﺮﻧﺎﻣﻪ ﺑﻼﻓﺎﺻﻠﻪ ﺑﻪ ﺧـﺎﺭﺝ ﺍﺯ ﺁﻥ ﺑﻠـﻮﮎ ﺍﻧﺘﻘـﺎﻝ ﻳﺎﺑـﺪ‪.‬ﺩﺳـﺘﻮﺭ ‪Exit‬‬
‫ﺍﮔﺮﺩﺭ ﺑﺪﻧﻪ ﺍﺻﻠﯽ ﺑﻠﻮﮎ ﻳﮏ ﭘﺮﻭﺳﻴﺠﺮ ﻳﺎ ﺗﺎﺑﻊ ﻗﺮﺍﺭ ﮔﺮﻓﺘﻪ ﺑﺎﺷﺪ ‪ ،‬ﺑﺎﻋﺚ ﺧﺮﻭﺝ ﺍﺯ ﭘﺮﻭﺳﻴﺠﺮ ﻳﺎ ﺗﺎﺑﻊ ﺷﺪﻩ ﻭ ﮐﻨﺘﺮﻝ ﺑﺮﻧﺎﻣﻪ ﺑـﻪ ﺍﻭﻟـﻴﻦ ﺩﺳـﺘﻮﺭﯼ‬
‫ﮐﻪ ﺑﻼﻓﺎﺻﻠﻪ ﭘﺲ ﺍﺯ ﺩﺳﺘﻮﺭﻓﺮﺍﺧﻮﺍﻧﯽ ﺁﻥ ﭘﺮﻭﺳﻴﺠﺮ ﻳﺎ ﺗﺎﺑﻊ ﻗﺮﺍﺭ ﮔﺮﻓﺘﻪ ﭘﺮﺵ ﻣﯽ ﮐﻨﺪ‪.‬‬
‫ﺍﮔﺮ ﺩﺳﺘﻮﺭ ‪ Exit‬ﺩﺭ ﺑﻠﻮﮎ ﺍﺻﻠﯽ ﺑﺮﻧﺎﻣﻪ ﺑﺎﺷﺪ ‪ ،‬ﺑﺮﻧﺎﻣﻪ ﺑﻼﻓﺎﺻﻠﻪ ﺧﺎﺗﻤﻪ ﻣﯽ ﻳﺎﺑﺪ‪.‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪41‬‬
‫ﺗﺴﺖ ‪:‬‬
‫ﺗﺴﺖ‪ (١‬ﻣﻨﻈﻮﺭ ﺍﺯ ﺩﺭﺟﻪ ﻱ ﻋﻤﻠﮕﺮ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺏ( ﺗﻌﺪﺍﺩ ﻋﻤﻠﻮﻧﺪﻫﺎﻱ ﻣﻮﺟﻮﺩ ﺩﺭ ﻳﻚ ﻋﺒﺎﺭﺕ‬ ‫ﺍﻟﻒ( ﺗﻌﺪﺍﺩ ﻋﻤﻠﮕﺮﻫﺎﻱ ﻣﻮﺟﻮﺩ ﺩﺭ ﻳﻚ ﻋﺒﺎﺭﺕ‬
‫ﺩ( ﺍﻭﻟﻮﻳﺖ ﺍﺟﺮﺍﻱ ﻋﻤﻠﮕﺮ‬ ‫ﺝ( ﺗﻌﺪﺍﺩ ﻋﻤﻠﻮﻧﺪﻫﺎﻱ ﻋﻤﻠﮕﺮ‬
‫ﺗﺴﺖ‪ (٢‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﻳﻚ ﺷﻨﺎﺳﻪ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺍﺳﺖ؟‬
‫ﺩ(‪String‬‬ ‫ﺝ(‪Program‬‬ ‫ﺏ(‪Readln‬‬ ‫ﺍﻟﻒ( ‪For‬‬
‫ﺗﺴﺖ‪ (٣‬ﺳﺮﻋﺖ ﺍﻧﺠﺎﻡ ﻣﺤﺎﺳﺒﺎﺕ ﺑﺎ ﻛﺪﺍﻡ ﻧﻮﻉ ﺩﺍﺩﻩ ﻧﺴﺒﺖ ﺑﻪ ﺑﻘﻴﻪ ﭘﺎﻳﻴﻦ ﺗﺮ ﺍﺳﺖ؟‬
‫ﺩ(‪Integer‬‬ ‫ﺝ(‪Word‬‬ ‫ﺏ(‪Real‬‬ ‫ﺍﻟﻒ(‪Longint‬‬
‫ﺗﺴﺖ ‪( ٤‬ﺩﺭ ﭘﺎﺳﺦ ﺑﻪ ﺍﺟﺮﺍﻱ ﻗﻄﻌﻪ ﺑﺮﻧﺎﻣﻪ ﻱ ﻣﻘﺎﺑﻞ ﺩﺍﺩﻩ ﻫﺎﻱ ﺯﻳﺮ ﺭﺍ ﻭﺍﺭﺩ ﻛﺮﺩﻩ ﺍﻳﻢ ﺧﺮﻭﺟﻲ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫‪Readln(X,Y,Z); 3 7 12 14‬‬
‫‪Read(A,B); 16 24 36‬‬ ‫ﺝ(‪ 16 24‬ﺩ(ﭘﻴﻐﺎﻡ ﺧﻄﺎ‬ ‫ﺏ(‪24 36‬‬ ‫ﺍﻟﻒ(‪14 16‬‬
‫;)‪Write(A,B‬‬

‫ﺗﺴﺖ ‪ (٥‬ﺍﮔﺮ ‪ I‬ﻳﻚ ﻣﺘﻐﻴﺮ ﺍﺯ ﻧﻮﻉ ﺻﺤﻴﺢ ﻭ ‪ r‬ﻳﻚ ﻣﺘﻐﻴﺮ ﺍﺯ ﻧﻮﻉ ﺍﻋﺸﺎﺭﻱ ﺑﺎﺷﺪ ﻛﺪﺍﻡ ﺩﺳﺘﻮﺭ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫ﺩ(;‪I:=I /32‬‬ ‫ﺝ(;‪I:= r Mod 10‬‬ ‫ﺏ(‪I:=I+r‬‬ ‫ﺍﻟﻒ(;‪r:=I Div 6‬‬

‫ﺗﺴﺖ ‪:‬‬

‫‪- ١‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫;‪N:=2‬‬
‫‪For I:=1 to 2 do‬‬ ‫ﺩ(‪34‬‬ ‫ﺝ(‪29‬‬ ‫ﺏ(‪32‬‬ ‫ﺍﻟﻒ( ‪36‬‬
‫‪For k:=1 to 4 do‬‬
‫;‪N:=N+I+k‬‬
‫;)‪Writeln(N‬‬
‫‪-٢‬ﺩﺭ ﻛﺪﺍﻡ ﺳﺎﺧﺘﺎﺭ ﺗﻜﺮﺍﺭ ﺑﺮﺍﻱ ﻣﺠﻤﻮﻋﻪ ﺩﺳﺘﻮﺭﺍﺕ ﺣﻠﻘﻪ)ﺑﻴﺶ ﺍﺯ ﻳﻚ ﺩﺳﺘﻮﺭ( ﻧﻴﺎﺯﻱ ﺑﻪ ‪ Begin-End‬ﻧﻴﺴﺖ؟‬
‫ﺩ( ‪Repeat-Until‬‬ ‫ﺝ(‪ For‬ﻭ ‪Repeat-Until‬‬ ‫ﺏ(‪For‬‬ ‫ﺍﻟﻒ( ‪While-Do‬‬
‫;‪A:=6‬‬
‫‪For B:=1 to A do‬‬ ‫‪- ٣‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫‪Begin‬‬
‫;‪A:=A-1‬‬ ‫ﺏ( ‪2 , 4‬‬ ‫ﺍﻟﻒ( ‪2 , 3 , 4 , 5 , 6‬‬
‫;‪B:=B+1‬‬ ‫ﺩ( ‪2 , 4 , 6‬‬ ‫ﺝ( ‪1 , 2 , 3 , 4 , 5 , 6‬‬
‫;)‪Writeln(B‬‬
‫;‪End‬‬

‫‪ -٤‬ﺍﮔﺮ ﻣﺘﻐﻴﺮﻱ ﺑﻪ ﺻﻮﺭﺕ ; ‪ N:string‬ﺗﻌﺮﻳﻒ ﺷﻮﺩ ﭼﻨﺪ ﺑﺎﻳﺖ ﻓﻀﺎ ﺑﺮﺍﻱ ﺁﻥ ﺍﺷﻐﺎﻝ ﺧﻮﺍﻫﺪ ﺷﺪ؟‬
‫ﺩ(‪254‬‬ ‫ﺝ(‪255‬‬ ‫ﺏ(‪127‬‬ ‫ﺍﻟﻒ(‪256‬‬
‫‪ - ٥‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫‪Begin‬‬
‫;‪For L:=6 downto 1 do‬‬ ‫ﺏ( ‪123456‬‬ ‫ﺍﻟﻒ( ‪1‬‬
‫;)‪Write(L‬‬ ‫ﺩ( ‪6‬‬ ‫ﺝ( ‪654321‬‬
‫‪End.‬‬

‫‪-٦‬ﻛﺪﺍﻡ ﻳﻚ ﺍﺯ ﺳﺎﺧﺘﺎﺭﻫﺎﻱ ﺣﻠﻘﻪ ﺣﺪﺍﻗﻞ ﻳﻚ ﺑﺎﺭ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ؟‬

‫ﺩ( ﺍﻟﻒ ﻭ ﺝ‬ ‫ﺝ( ‪Repeat‬‬ ‫ﺏ( ‪While‬‬ ‫ﺍﻟﻒ( ‪For‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪42‬‬
‫‪ -٧‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫‪For H:=FALSE TO TRUE DO‬‬ ‫ﺍﻟﻒ( ‪2FALSE3FALSE4FALSE2TRUE3TRUE4TRUE‬‬

‫‪For A:=1 TO 3 DO‬‬
‫ﺝ( ‪2H3H4H2H3H4H‬‬ ‫ﺏ(ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﺯﻣﺎﻥ ﺗﺮﺟﻤﻪ ﺧﻄﺎ ﺩﺍﺭﺩ‪.‬‬
‫;)’‪WRITE(A+1,’H‬‬
‫ﺩ( ‪1H2H3H1H2H3H‬‬
‫‪ -٨‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺝ(‪54321‬‬ ‫ﺏ( ‪4321‬‬ ‫ﺍﻟﻒ( ‪5432‬‬
‫‪For W:=4 downto 1.0 do‬‬
‫;)‪Write(W+1‬‬ ‫ﺩ( ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﺩﺍﺭﺩ‪.‬‬

‫‪ -٩‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺩﺭ ﻣﻮﺭﺩ ﺩﺳﺘﻮﺭ ‪ Repeat-Until‬ﺻﺤﻴﺢ ﺍﺳﺖ؟‬

‫ﺍﻟﻒ(ﺍﺯ ﺍﻳﻦ ﺣﻠﻘﻪ ﺯﻣﺎﻧﻲ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺩﻓﻌﺎﺕ ﺗﻜﺮﺍﺭ ﺁﻥ ﻣﻌﻠﻮﻡ ﺑﺎﺷﺪ‪.‬‬
‫ﺏ(ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ ﺩﺳﺘﻮﺭﺍﺕ ﺩﺍﺧﻞ ﺣﻠﻘﻪ ﺑﻴﺶ ﺍﺯ ﻳﻚ ﺩﺳﺘﻮﺭ ﺑﺎﺷﺪ ﺑﺎﻳﺪ ﺁﻥ ﺭﺍ ﺑﺼﻮﺭﺕ ﺩﺳﺘﻮﺭ ﻣﺮﻛﺐ ﻧﻮﺷﺖ‪.‬‬
‫ﺝ( ﺩﺭﺻﻮﺭﺗﻲ ﻛﻪ ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﺑﻮﻟﻲ ﺣﻠﻘﻪ ﻧﺎﺩﺭﺳﺖ ﺑﺎﺷﺪ ﺩﺳﺘﻮﺭﺍﺕ ﺣﻠﻘﻪ ﻓﻘﻂ ﻳﻚ ﺑﺎﺭ ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﺩ( ﻛﻠﻤﺎﺕ ﺫﺧﻴﺮﻩ ﺷﺪﻩ ﻱ ‪ Repeat‬ﻭ ‪ Until‬ﺍﺑﺘﺪﺍ ﻭ ﺍﻧﺘﻬﺎﻱ ﺣﻠﻘﻪ ﺭﺍ ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫‪ - ١٠‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫;‪A:=1‬‬
‫‪Repeat‬‬ ‫ﺏ(‪2, 3, 5, 6, 7, 9, 10‬‬ ‫ﺍﻟﻒ(‪2, 3, 4, 5, 6, 7, 8, 9, 10‬‬
‫;‪A:=A+1‬‬ ‫ﺩ(‪2, 3‬‬ ‫ﺝ( ‪2‬‬
‫‪If A>10 then‬‬
‫;‪Break‬‬
‫‪IF A mod 4 =0 then‬‬
‫;‪Continue‬‬
‫;)‪Writeln(A‬‬
‫;‪Until False‬‬

‫‪ -١١‬ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﺩﺳﺘﻮﺭ )‪ Writeln(X‬ﭼﻨﺪ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ؟‬

‫;‪X:=1‬‬ ‫ﺏ(ﻳﻚ ﺑﺎﺭ‬ ‫ﺍﻟﻒ( ﻫﻴﭻ ﺑﺎﺭ ﭼﻮﻥ ﺣﻠﻘﻪ ﺧﺎﺗﻤﻪ ﻧﻤﻲ ﻳﺎﺑﺪ‪.‬‬
‫; ‪While X<5 Do‬‬ ‫ﺩ( ‪ ٥‬ﻳﺎﺭ‬ ‫ﺝ( ‪ ٤‬ﺑﺎﺭ‬
‫‪Begin‬‬
‫;)‪Writeln(X‬‬
‫;‪X:=X+1‬‬
‫;‪End‬‬

‫‪ -١٢‬ﺩﺭ ﺣﻠﻘﻪ ﻫﺎﻱ ﻣﺘﺪﺍﺧﻞ ﺗﻌﺪﺍﺩ ﺩﻓﻌﺎﺕ ﺗﻜﺮﺍﺭ ﺩﺳﺘﻮﺭ ﺣﻠﻘﻪ ﺩﺍﺧﻠﻲ ﺑﺮﺍﺑﺮ ﺍﺳﺖ ﺑﺎ‪:‬‬
‫ﺏ( ﺣﺎﺻﻞ ﺟﻤﻊ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺣﻠﻘﻪ ﺩﺍﺧﻠﻲ ﻭ ﺣﻠﻘﻪ ﺧﺎﺭﺟﻲ‬ ‫ﺍﻟﻒ( ﺣﺎﺻﻞ ﺟﻤﻊ ﺗﻌﺪﺍﺩ ﺗﻤﺎﻣﻲ ﺣﻠﻘﻪ ﻫﺎ‬
‫ﺩ( ﺣﺎﺻﻠﻀﺮﺏ ﺗﻜﺮﺍﺭ ﺣﻠﻘﻪ ﺩﺍﺧﻠﻲ ﺩﺭ ﺣﻠﻘﻪ ﺧﺎﺭﺟﻲ‬ ‫ﺝ(ﺣﺎﺻﻠﻀﺮﺏ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺗﻤﺎﻣﻲ ﺣﻠﻘﻪ ﻫﺎ‬

‫‪ -١٣‬ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻨﺪﺑﺎﺭ ‪ TRUE‬ﻭ ﭼﻨﺪ ﺑﺎﺭ ‪ False‬ﭼﺎﭖ ﻣﻴﺸﻮﺩ؟‬

‫ﺝ( ﺷﺶ ﺑﺎﺭ ‪True‬‬ ‫ﺍﻟﻒ( ﭼﻬﺎﺭ ﺑﺎﺭ ‪ True‬ﻭ ﺩﻭ ﺑﺎﺭ ‪False‬‬
‫‪For A:=4 downto 1 do‬‬ ‫ﺩ( ﺷﺶ ﺑﺎﺭ ‪False‬‬ ‫ﺏ( ﺩﻭ ﺑﺎﺭ ‪ True‬ﻭ ﭼﻬﺎﺭ ﺑﺎﺭ ‪False‬‬
‫‪For F:=A to 4 do‬‬
‫‪If F Mod 2 =0 then‬‬
‫;)‪Writeln(F<=A‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪43‬‬
‫‪ -١٤‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫;‪N:=1‬‬ ‫ﺏ(‪11‬‬ ‫ﺍﻟﻒ( ‪10‬‬

‫‪For W:=4 downto 1 do‬‬ ‫ﺩ(‪21‬‬ ‫ﺝ( ‪36‬‬
‫‪Begin‬‬
‫;‪F:=4‬‬
‫‪While F>W do‬‬
‫‪Begin‬‬
‫;‪N:=N+W‬‬
‫;‪F:=F-1‬‬
‫;‪END‬‬
‫;‪END‬‬
‫;)‪Writeln(N‬‬

‫‪ -١٥‬ﺍﮔﺮ ﺩﺳﺘﻮﺭ ﺩﺍﺧﻞ ﺣﻠﻘﻪ ‪ for-to‬ﺭﻭﻱ ﻣﺘﻐﻴﺮ ﺷﻤﺎﺭﻧﺪﻩ ﺗﺎﺛﻴﺮ ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ ﻭ ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ ﻣﺘﻐﻴﺮ ﺷﻤﺎﺭﻧﺪﻩ ﺑﺮﺍﺑﺮ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﺁﻥ ﺑﺎﺷﺪ‬
‫ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺩﺳﺘﻮﺭ ﺩﺍﺧﻞ ﺣﻠﻘﻪ ﻭ ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ﺷﻤﺎﺭﻧﺪﻩ ﺑﻌﺪ ﺍﺯ ﺍﺟﺮﺍﻱ ﺣﻠﻘﻪ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺏ( ﻳﻚ ﺑﺎﺭ – )‪+١‬ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ – ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ(‬ ‫ﺍﻟﻒ(ﺻﻔﺮﺑﺎﺭ‪ -‬ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ‬
‫ﺩ( ﻳﻚ ﺑﺎﺭ – ‪٢‬‬ ‫ﺝ( ﻳﻚ ﺑﺎﺭ ‪ -‬ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﻲ‬
‫‪ -١٦‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬
‫ﺏ(‪5678910‬‬ ‫ﺍﻟﻒ( ‪12345678910‬‬
‫;‪X:=0‬‬ ‫ﺩ(‪10‬‬ ‫ﺝ(‪12345‬‬
‫‪FOR I:=1 To 10 Do‬‬
‫;‪IF I>=5 then X:=1‬‬
‫;)‪IF I<5 OR X<>0 THEN Write(I‬‬

‫‪ -١٧‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫;‪Var X:Integer; Y:Boolean‬‬
‫‪Begin‬‬ ‫ﺏ(ﺍﻋﺪﺍﺩ ﻓﺮﺩ ‪ ١‬ﺗﺎ ‪٩‬‬ ‫ﺍﻟﻒ( ﺻﻔﺮ‬
‫;‪X:=1‬‬
‫‪Repeat‬‬ ‫ﺩ( ‪Run Time Error‬‬ ‫ﺝ( ﻋﺪﺩ ‪١‬‬
‫;)‪Write(X:3‬‬
‫;‪X:=X+2‬‬
‫;‪Y:=X=11‬‬
‫;‪Until Y‬‬
‫‪End.‬‬

‫‪For K:=15 to 14 do‬‬ ‫‪ - ١٨‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎﺑﻞ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫‪For H:=1 to 2 do‬‬
‫‪For N:=4 to 5 do‬‬ ‫ﺏ( ﻳﻚ ﺑﺎﺭ ﭼﺎﭖ ‪OK‬‬ ‫ﺍﻟﻒ( ‪ ٦‬ﺑﺎﺭ ﭼﺎﭖ ‪OK‬‬
‫;)’‪Write(’OK‬‬ ‫ﺩ( ﻫﻴﭽﻜﺪﺍﻡ‬ ‫ﺝ( ﭘﻴﻐﺎﻡ ﺧﻄﺎ‬
‫‪ - ١٩‬ﭘﺲ ﺍﺯ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ‪ count‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫‪For H:=1 TO 18 DO‬‬
‫ﺩ( ‪-9‬‬ ‫ﺝ( ‪6‬‬ ‫ﺏ( ‪0‬‬ ‫ﺍﻟﻒ( ‪114‬‬
‫;‪Count:=60-H*3‬‬

‫;‪A:=1; F:=1; W:=True‬‬ ‫‪ - ٢٠‬ﺩﺳﺘﻮﺭ ‪ Write‬ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻨﺪ ﺑﺎﺭ ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ؟‬
‫‪While Not W do‬‬ ‫ﺩ( ﺩﻩ ﺑﺎﺭ‬ ‫ﺝ( ﺍﺻﻼ ﺍﺟﺮﺍ ﻧﻤﻲ ﺷﻮﺩ‪.‬‬ ‫ﺏ( ﺳﻪ ﺑﺎﺭ‬ ‫ﺍﻟﻒ( ﻳﻚ ﺑﺎﺭ‬
‫‪Begin‬‬
‫;‪F:=F*A‬‬
‫;‪A:=A+1‬‬
‫‪If A>4 then‬‬
‫;‪W:=False‬‬
‫;‪End‬‬
‫;)‪Writeln(F‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪44‬‬
‫ﺑﯿﺸﺘﺮ ﺑﺪاﻧﯿﻢ ‪:‬‬
‫ﭼﻨﺪ ﻧﮑﺘﻪ در ﻣﻮرد اﻧﻮاع داده ﻫﺎ در زﺑﺎن ﭘﺎ ﺳﮑﺎل‪:‬‬
‫ﺩﺍﺩﻩ ﻫﺎﻱ ﻋـﺪﺩﻱ ‪ Single‬ﻭ ‪ Double‬ﻭ ‪ Extended‬ﻭ ‪ Comp‬ﺭﺍ ﺍﻧـﻮﺍﻉ ﺩﺍﺩﻩ ‪ 8087‬ﻣـﻲ ﮔﻮﻳﻨـﺪ‪ .‬ﺍﻳـﻦ ﻧـﻮﻉ ﺩﺍﺩﻩ ﻫـﺎ ﺑـﺮﺍﻱ ﺍﻧﺠـﺎﻡ‬
‫ﻣﺤﺎﺳﺒﺎﺕ ﺑﺮ ﺭﻭﻱ ﺁﻧﻬﺎ ﺑﻪ ﻛﻤﻚ ﭘﺮﺩﺍﺯﺷﮕﺮ ﻧﻴﺎﺯ ﺩﺍﺭﻧﺪ‪ .‬ﻛﻤﻚ ﭘﺮﺩﺍﺯﺷﮕﺮ ﻳﻚ ﺳﺨﺖ ﺍﻓﺰﺍﺭ ﺍﺳـﺖ ﻛـﻪ ﺑـﺮﺍﻱ ﺍﻧﺠـﺎﻡ ﻣﺤﺎﺳـﺒﺎﺕ ﺑـﺮ ﺭﻭﻱ ﺍﻋـﺪﺍﺩ‬
‫ﺍﻋﺸﺎﺭﻱ ﺑﺎ ﺩﻗﺖ ﺑﺎﻻ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﺩﺭ ﻛﺎﻣﭙﻴﻮﺗﺮ ﻫﺎﻱ ﻗﺪﻳﻤﻲ )ﻣﺪﻝ ‪ (XT‬ﺍﻧﺠﺎﻡ ﻣﺤﺎﺳﺒﺎﺕ ﺍﻋﺸﺎﺭﻱ ﺑﺎ ﺩﻗﺖ ﺑﺎﻻ ﺑﻪ ﻛﻨـﺪﻱ ﺻـﻮﺭﺕ ﻣـﻲ‬
‫ﮔﺮﻓﺖ‪.‬‬
‫ﺑﺮﺍﻱ ﺍﻳﻨﻜﻪ ﺑﺘﻮﺍﻧﻴﻢ ﺍﺯ ﺩﺍﺩﻩ ﻫﺎﻱ ﻧﻮﻉ ‪ 8087‬ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﻢ ﺑﺎﻳﺪ ﻛﺎﻣﭙﺎﻳﻠﺮ ﭘﺎﺳﻜﺎﻝ ﺭﺍ ﺑﺮﺍﻱ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻤﻚ ﭘﺮﺩﺍﺯﺷـﮕﺮ ﻣﻄﻠـﻊ ﺳـﺎﺯﻳﻢ‪ .‬ﺑـﺮﺍﻱ‬
‫ﺍﻳﻦ ﻛﺎﺭ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﺍﺯ ﺩﻭ ﺭﻭﺵ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﻢ‪.‬‬
‫‪ -١‬ﺩﺭ ﻣﻨﻮﻱ ‪ Option‬ﮔﺰﻳﻨﺔ ‪ Compiler‬ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﻛﻨﻴﺪ ﻭ ﮔﺰﻳﻨﻪ ‪ 8087/80287‬ﺭﺍ √ )ﺗﯿﮏ(ﺑﺰﻧﻴﺪ‪ .‬ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ √ ﻧﺨﻮﺭﺩﻩ ﺑﺎﺷـﺪ‬
‫ﻓﻘﻂ ﻣﻲ ﺗﻮﺍﻧﻴﺪ ﺍﺯ ﻧﻮﻉ ‪ Real‬ﺑﺮﺍﻱ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﻱ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﺪ‪.‬‬
‫‪ -٢‬ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻫﻨﻤﻮﺩ }‪ {$N+‬ﺩﺭ ﺍﺑﺘﺪﺍﻱ ﺑﺮﻧﺎﻣﻪ‪:‬‬

‫رﻫﻨﻤﻮدﻫﺎ‪:‬‬

‫ﻋﻼﻣﺖ ‪ $‬ﭼﻨﺎﻧﭽﻪ ﭘﺲ ﺍﺯ ﻋﻼﻣﺖ { ﺑﻪ ﻛﺎﺭ ﺭﻭﺩ ﺑﺮﺍﻱ ﻣﺘﺮﺟﻢ ﻣﻔﻬﻮﻡ ﺧﺎﺻﻲ ﺩﺍﺭﺩ‪ .‬ﺍﻳﻦ ﻧﻮﻉ ﻋﻼﻳﻢ ﻛﻪ ﻧﺤﻮﺓ ﺗﺮﺟﻤﻪ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺗﻐﻴﻴﺮ ﻣﻲ ﺩﻫﻨـﺪ‬
‫ﻭ ﻣﻔﻬﻮﻡ ﺧﺎﺻﻲ ﺑﺮﺍﻱ ﻣﺘﺮﺟﻢ ﺩﺍﺭﻧﺪ ﻭ ﺩﺭ ﻭﺍﻗﻊ ﻫﺪﺍﻳﺖ ﻛﻨﻨﺪﺓ ﻣﺘﺮﺟﻢ ﺩﺭ ﺍﻣﺮ ﺗﺮﺟﻤﻪ ﺑﺮﻧﺎﻣﻪ ﻫﺴﺘﻨﺪ ﺭﻫﻨﻤﻮﺩ ﻧﺎﻣﻴﺪﻩ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﺍﮔﺮ ﻣﻲ ﺧﻮﺍﻫﻴﺪ ﺑﺮﻧﺎﻣﺔ ﺷﻤﺎ ﻛﻪ ﺩﺍﺭﺍﻱ ﻧﻮﻉ ﺩﺍﺩﺓ ‪ ٨٠٨٧‬ﺍﺳﺖ ﺩﺭ ﻛﺎﻣﭙﻴﻮﺗﺮ ﻫﺎﻳﻲ ﻛﻪ ﻛﻤﻚ ﭘﺮﺩﺍﺯﻧﺪﻩ ﻧﺪﺍﺭﻧﺪ ﻧﻴـﺰ ﺍﺟـﺮﺍ ﺷـﻮﺩ ﺑﺎﻳـﺪ ﻧـﻮﻉ ﺩﺍﺩﻩ‬
‫‪ ٨٠٨٧‬ﺭﺍ ﺷﺒﻴﻪ ﺳﺎﺯﻱ ﻛﻨﻴﺪ ﻛﻪ ﺑﻮﺳﻴﻠﺔ ﺩﻭ ﺭﻭﺵ ﺫﻛﺮ ﺷﺪﻩ ﺩﺭ ﻓﻮﻕ ﺍﻳﻦ ﻋﻤﻞ ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﻨﺪ‪.‬‬
‫ﻋﻼﻣﺖ ‪ N+‬ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻧﻮﻉ ﺩﺍﺩﻩ ‪ ٨٠٨٧‬ﻭ ﻋﻼﻣﺖ ‪ E+‬ﺷﺒﻴﻪ ﺳﺎﺯﻱ ﻧﺮﻡ ﺍﻓﺰﺍﺭﻱ ﺁﻥ ﺭﺍ ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ‪{$N+,E+} .‬‬
‫ﺭﻫﻨﻤﻮﺩ }‪ {$N+,E-‬ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﺑﺮﻧﺎﻣﻪ ﻓﻘﻂ ﺑﺮ ﺭﻭﻱ ﺭﺍﻳﺎﻧﻪ ﻫﺎﻳﻲ ﻛﻪ ﺩﺍﺭﺍﻱ ﻛﻤﻚ ﭘﺮﺩﺍﺯﺷﮕﺮ ﻫﺴﺘﻨﺪ ﺍﺟﺮﺍ ﺷﻮﺩ‪.‬‬

‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﻋﻼﻣﺖ ‪ $‬ﺑﻪ ﻫﻤﺮﺍﻩ ﻋﺪﺩ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺑﻴﺎﻳﺪ ﺑﻪ ﻣﻌﻨﺎﻱ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﻋﺪﺩ ﺩﺭ ﻣﺒﻨﺎﻱ ﺷﺎﻧﺰﺩﻩ)‪ (Hex‬ﺍﺳﺖ‪ .‬ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﻣﻨﻈﻮﺭ ﺍﺯ‬
‫ﻋﺪﺩ ‪ $12‬ﻋﺪﺩ ‪ 18‬ﺩﺭ ﻣﺒﻨﺎﻱ ﺩﻩ ﺍﺳﺖ‪ .‬ﺩﻗﺖ ﻛﻨﻴﺪ ﻛﻪ ﺟﻠﻮﻱ ‪ $‬ﻓﻘﻂ ﻋﺪﺩ ﺛﺎﺑﺖ ﻣـﻲ ﺁﻳـﺪ‪ $3 .‬ﻫﻤـﺎﻥ ﻋـﺪﺩ ‪ 3‬ﺩﺭ ﻣﺒﻨـﺎﻱ‪ ١٠‬ﺍﺳـﺖ ﻭ ‪$D‬‬
‫ﻫﻤﺎﻥ ﻋﺪﺩ ‪ ١٣‬ﺩﺭ ﻣﺒﻨﺎﻱ ﺩﻩ ﺍﺳﺖ‪ (A,B,C,D,E,F) .‬ﻣﻨﻈﻮﺭ ﺍﺯ ﻋﺪﺩ ‪ $23‬ﭼﻴﺴﺖ؟ ﻣﻨﻈﻮﺭ ﺍﺯ ‪ #$41‬ﻛﺎﺭﺍﻛﺘﺮ ’‪ ’A‬ﺍﺳﺖ‪.‬‬
‫ﺗﻮاﺑﻊ ﮐﺘﺎﺑﺨﺎﻧﻪ اي‪:‬‬
‫ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺗﻌﺪﺍﺩﻱ ﺗﺎﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ ﺍﻳﻲ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺑﺘﻮﺍﻧﺪ ﺑﻪ ﺭﺍﺣﺘﻲ ﺍﺯ ﺁﻧﻬﺎ ﺑﺮﺍﻱ ﺍﻧﺠﺎﻡ ﺑﻌﻀﻲ ﻛﺎﺭﻫﺎ ﺍﺳـﺘﻔﺎﺩﻩ ﻛﻨـﺪ‪ .‬ﺑـﻪ‬
‫ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﺗﺎﺑﻊ ‪ ABS‬ﻗﺪﺭ ﻣﻄﻠﻖ ﻳﻚ ﻋﺪﺩ ﺭﺍ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ‪ .‬ﺍﻳﻦ ﺗﻮﺍﺑﻊ ﺍﺯ ﻗﺒﻞ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺍﻧﺪ‪ .‬ﻫـﺮ ﺗـﺎﺑﻊ ﻣﻤﻜـﻦ ﺍﺳـﺖ ﺩﺍﺭﺍﻱ‬
‫ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺑﺎﺷﺪ ﻭ ﻳﻚ ﺧﺮﻭﺟﻲ ﻧﻴﺰ ﺩﺍﺭﺩ‪ .‬ﺩﺭ ﺍﺩﺍﻣﻪ ﻫﺮ ﺗﺎﺑﻊ ﺭﺍ ﺑﺎ ﻋﻤﻠﻜﺮﺩ ﺁﻥ ﻭ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﺑﻴﺎﻥ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﻧﻜﺘﻪ( ﺗﻮﺍﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ ﺍﻳﻲ ﻫﻴﭽﻜﺪﺍﻡ ﻛﻠﻤﺔ ﺭﺯﺭﻭ ﺷﺪﻩ ﻧﻴﺴﺘﻨﺪ‪.‬‬

‫ﺗﺎﺑﻊ ‪ :ABS‬ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺩﺍﺭﺩ ﻛﻪ ﺑﺎﻳﺪ ﻋﺪﺩﻱ ﺑﺎﺷﺪ)ﺻﺤﻴﺢ ﻳﺎ ﺍﻋﺸﺎﺭﻱ( ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﻳﻚ ﻋﺪﺩ ﻣﺜﺒﺖ ﻳﺎ ﺻﻔﺮ ﺧﻮﺍﻫﺪ ﺑﻮﺩ ﻛﻪ ﻗـﺪﺭ‬
‫‪ABS(5)=5‬‬ ‫‪ABS(-6)=6‬‬ ‫‪ABS(0)=0‬‬ ‫ﻣﻄﻠﻖ ﻋﺪﺩ ﻭﺭﻭﺩﻱ ﺍﺳﺖ‪.‬‬

‫ﺗﺎﺑﻊ ‪ :SQR‬ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺩﺍﺭﺩ ﻛﻪ ﺑﺎﻳﺪ ﻋﺪﺩﻱ ﺑﺎﺷﺪ ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﻣﺠﺬﻭﺭ)ﻣﺮﺑﻊ( ﻋﺪﺩ ﻭﺭﻭﺩﻱ ﺍﺳﺖ‪ .‬ﺑﻨـﺎﺑﺮﺍﻳﻦ ﺣﺎﺻـﻞ ﺁﻥ ﻫﻤﻴـﺸﻪ‬
‫‪SQR(5)=25‬‬ ‫‪SQR(-4)=16 SQR(0)=0‬‬ ‫ﻳﻚ ﻋﺪﺩ ﻣﺜﺒﺖ ﻳﺎ ﺻﻔﺮ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬

‫ﺗﺎﺑﻊ ‪ : SQRT‬ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺩﺍﺭﺩ ﻛﻪ ﺑﺎﻳﺪ ﺍﺯ ﻧﻮﻉ ﻋﺪﺩﻱ ﺑﺎﺷﺪ ﻭ ﺧﺮﻭﺟـﻲ ﺁﻥ ﺟـﺬﺭ)ﺭﺍﺩﻳﻜـﺎﻝ( ﻋـﺪﺩ ﻭﺭﻭﺩﻱ ﺍﺳـﺖ‪ .‬ﺑﻨـﺎﺑﺮﺍﻳﻦ ﻋـﺪﺩ‬
‫ﻭﺭﻭﺩﻱ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﻋﺪﺩ ﻣﻨﻔﻲ ﺑﺎﺷﺪ ﺯﻳﺮﺍ ﺯﻳﺮ ﺭﺍﺩﻳﻜﺎﻝ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﻣﻨﻔﻲ ﺑﺎﺷﺪ‪ .‬ﺧﺮﻭﺟﻲ ﺍﻳﻦ ﺗﺎﺑﻊ ﺍﺯ ﻧﻮﻉ ‪ Real‬ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬
‫‪Sqrt(0)=0.0‬‬ ‫ﺧﻄﺎ =)‪SQRT(-9‬‬ ‫‪SQRT(81)=9.0‬‬
‫‪SQRT(ABS(-9))=3.0‬‬ ‫‪SQR(SQRT(A))=A‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪45‬‬
‫ﺗﺎﺑﻊ ‪ : Pi‬ﺍﻳﻦ ﺗﺎﺑﻊ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﻧﺪﺍﺭﺩ ﺍﻣﺎ ﺧﺮﻭﺟﻲ ﺁﻥ ﺍﺯ ﻧﻮﻉ‪ Real‬ﺍﺳﺖ ﻭ ﻋﺪﺩ ‪ л‬ﻛﻪ ﻫﻤﺎﻥ ‪ 3.14159‬ﺭﺍ ﺑﺮﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬

‫ﺗﺎﺑﻊ ‪ : Frac‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﺍﺯ ﻧﻮﻉ ‪ Real‬ﺩﺍﺭﺩ ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﻧﻴـﺰ ﺍﺯ ﻧـﻮﻉ ‪ Real‬ﺍﺳـﺖ ﻭ ﻗـﺴﻤﺖ ﺍﻋـﺸﺎﺭ ﻋـﺪﺩ ﻭﺭﻭﺩﻱ ﺭﺍ ﺑﺮﻣـﻲ‬
‫;‪A:=12.345‬‬ ‫ﮔﺮﺩﺍﻧﺪ‪ .‬ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﻋﺪﺩ ‪ 0.545‬ﭼﺎﭖ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫;))‪Writeln(Frac(A+1.2‬‬ ‫‪Frac(6.89)=0.89‬‬ ‫‪Frac(5)=0.0‬‬
‫‪FRAC(-3.0245) = -0.0245‬‬
‫ﺗﺴﺖ( ﺩﺳﺘﻮﺭ ;)‪ Write(Frac(-45.0821):4:1‬ﭼﻪ ﭼﻴﺰﻱ ﺭﺍ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ؟‬
‫ﺩ(‪-0.0‬‬ ‫‪-0.1‬‬ ‫ﺝ(‬ ‫ﺏ( ‪0.1‬‬ ‫ﺍﻟﻒ( ‪–0.0821‬‬

‫ﺗﺎﺑﻊ ‪ :Trunc‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻋﺪﺩ ‪ Real‬ﺑﻪ ﻋﻨﻮﺍﻥ ﻭﺭﻭﺩﻱ ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﻭ ﻗﺴﻤﺖ ﺻﺤﻴﺢ ﺁﻥ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ‪ Integer‬ﺑﺮ ﻣـﻲ ﮔﺮﺩﺍﻧـﺪ‪.‬‬
‫‪Trunc(45.874)= 45‬‬ ‫ﭘﺲ ﺧﺮﻭﺟﻲ ﺁﻥ ﻋﺪﺩ ﺻﺤﻴﺢ ﺍﺳﺖ‪ .‬ﺩﻗﺖ ﻛﻨﻴﺪ ﻛﻪ ﻋﺪﺩ ﺭﺍ ﮔﺮﺩ ﻧﻤﻲ ﻛﻨﺪ‪.‬‬
‫‪Trunc(Frac(X)) = 0‬‬ ‫‪Trunc(-24.99) = -24‬‬ ‫‪Trunc(0.125)=0‬‬

‫ﺗﺎﺑﻊ ‪ : INT‬ﺍﻳﻦ ﺗﺎﺑﻊ ﺷﺒﻴﻪ ﺗﺎﺑﻊ ‪ Trunc‬ﺍﺳﺖ ﺑﺎ ﺍﻳﻦ ﺗﻔﺎﻭﺕ ﻛﻪ ﺧﺮﻭﺟﻲ ﺁﻥ ﺍﺯ ﻧﻮﻉ ‪ Real‬ﺍﺳﺖ‪ .‬ﺧﺮﻭﺟﻲ ﺍﻋﺸﺎﺭﻱ ﺩﺍﺭﺩ‪.‬‬
‫‪INT(FRAC(X))=0.0‬‬ ‫‪INT(-24.99)= -24.0‬‬ ‫‪Int(45.874)=45.0‬‬ ‫‪INT(0.125)=0.0‬‬

‫ﺗﺎﺑﻊ ‪ : Round‬ﻭﺭﻭﺩﻱ ﺍﻳﻦ ﺗﺎﺑﻊ ﺍﺯ ﻧﻮﻉ ‪ Real‬ﺍﺳﺖ ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﺍﺯ ﻧﻮﻉ ‪ Longint‬ﺍﺳﺖ ﻭ ﻋﺪﺩ ﻭﺭﻭﺩﻱ ﺭﺍ ﮔﺮﺩ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫‪Round(19.61)è20‬‬ ‫‪Round(52.5)è53‬‬ ‫‪Round(52.48)è52‬‬
‫‪Round(-4.39)è-4‬‬ ‫‪Round(-24.53)è-25‬‬ ‫‪Round(12) è12‬‬

‫ﺗﺎﺑﻊ ‪ : ODD‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻋﺪﺩﺻﺤﻴﺢ)‪ (Integer‬ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﻭﺧﺮﻭﺟﻲ ﺁﻥ ﺍﺯ ‪ Boolean‬ﺍﺳﺖ ﻳﻌﻨـﻲ ‪ True‬ﻳـﺎ ‪ . False‬ﺩﺭ‬
‫ﺻﻮﺭﺗﻲ ﻛﻪ ﻋﺪﺩ ﻭﺭﻭﺩﻱ ﻓﺮﺩ ﺑﺎﺷﺪ ‪ True‬ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ ﻭ ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ ﺯﻭﺝ ﺑﺎﺷﺪ ‪ False‬ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬
‫‪ODD(-21)èTrue‬‬ ‫‪ODD(17)èTrue‬‬ ‫‪ODD(14) èFalse‬‬
‫ﺗﺴﺖ( ﺩﺳﺘﻮﺭ ;))‪ Write(ODD(-1‬ﭼﻪ ﭼﻴﺰﻱ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ؟‬
‫ﺩ(‪True‬‬ ‫ﺝ(‪False‬‬ ‫ﺏ(‪1‬‬ ‫ﺍﻟﻒ( ‪0‬‬
‫ﻧﻜﺘﻪ( ﺩﻗﺖ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪﻛﻪ ﺍﮔﺮ ﻧﻮﻉ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺑﺎ ﺁﻥ ﭼﻴﺰﻱ ﻛﻪ ﺗﺎﺑﻊ ﻧﻴﺎﺯ ﺩﺍﺭﺩ ﻫﻤﺨﻮﺍﻧﻲ ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ ﭘﻴﻐـﺎﻡ ﺧﻄـﺎ ﺻـﺎﺩﺭ ﻣـﻲ ﺷـﻮﺩ‪.‬‬
‫)‪ ODD(12.6‬ﺧﻄﺎﺳﺖ‪.‬‬

‫ﺗﺎﺑﻊ ‪ : Random‬ﺍﻳﻦ ﺗﺎﺑﻊ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﻧﺪﺍﺭﺩ ﺍﻣﺎ ﺧﺮﻭﺟﻲ ﺁﻥ ﻳﻚ ﻋﺪﺩ ‪) Real‬ﺍﻋﺸﺎﺭﻱ( ﺍﺳﺖ ﻭ ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻋﺪﺩ ﺷﺎﻧـﺴﻲ ﺑـﻴﻦ ‪0‬‬
‫‪Random è 0.745‬‬ ‫ﺗﺎ ‪ 1‬ﺭﺍ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ‪. 0≤Random <1 .‬‬

‫ﺗﺎﺑﻊ )‪ : Random(X‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻋﺪﺩ ﺍﺯ ﻧﻮﻉ ‪) Word‬ﺻﺤﻴﺢ( ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﻋﺪﺩﻱ ﺍﺯ ﻧﻮﻉ ‪ Word‬ﺑﻴﻦ ‪ 0‬ﺗﺎ ﻋـﺪﺩ ﻭﺭﻭﺩﻱ ﺑـﻪ‬
‫‪0≤Random(6)<6‬‬ ‫ﺻﻮﺭﺕ ﺷﺎﻧﺴﻲ ﺑﺮﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﺑﺮﺍﻱ ﺍﻳﻨﻜﻪ ﺍﻋﺪﺍﺩ ﺷﺎﻧﺴﻲ ﺗﻮﻟﻴﺪ ﺷﺪﻩ ﺩﺭ ﻫﺮ ﺑﺎﺭ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﻣﺘﻔﺎﻭﺕ ﺑﺎﺷﻨﺪ ﺍﺯ ﭘﺮﻭﺳﻴﺠﺮ ;‪ Randomize‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬

‫ﺗﺎﺑﻊ ‪ : EXP‬ﺩﺭ ﺭﻳﺎﺿﻲ ﻋﺪﺩ ﻧﭙﺮﻥ ﺑﺮﺍﺑﺮ ‪ 2.718‬ﺍﺳﺖ ﻭ ﺑﺎ ﻧﻤﺎﺩ ‪ e‬ﻧﻤﺎﻳﺶ ﺩﺍﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻋﺪﺩ ‪ Real‬ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﻛﻨـﺪ ﻭ‬
‫‪EXP(3)=e3‬‬ ‫ﻳﻚ ﻋﺪﺩ ‪ Real‬ﻧﻴﺰ ﺑﺮﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬
‫)‪ EXP(X‬ﻳﻌﻨﻲ ﻋﺪﺩ ﻧﭙﺮﻥ ﺑﻪ ﺗﻮﺍﻥ ‪. X‬‬
‫‪EXP(0)=1‬‬ ‫‪EXP(1)=e‬‬ ‫‪Exp(Exp(0))=e‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪46‬‬
‫ﺗﺎﺑﻊ ‪ : LN‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻫﻤﺎﻥ ﻟﮕﺎﺭﻳﺘﻢ ﻃﺒﻴﻌﻲ ﺍﺳﺖ‪ .‬ﻭﺭﻭﺩﻱ ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻋﺪﺩ ‪ Real‬ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﻧﻴﺰ ﻳﻚ ﻋﺪﺩ ‪ Real‬ﺍﺳﺖ‪.‬‬
‫‪LN(1)=0‬‬ ‫‪LN(e)=1‬‬ ‫ﭘﻴﻐﺎﻡ ﺧﻄﺎ ‪LN(0)è‬‬ ‫‪LN(X) =LOGeX‬‬
‫ﻧﻜﺘﻪ( ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺗﺎﺑﻊ ‪ LN‬ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﻣﻨﻔﻲ ﻳﺎ ﺻﻔﺮ ﺑﺎﺷﺪ‪.‬ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﺻﺎﺩﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪LN(EXP(0))è0‬‬ ‫‪EXP(LN(X))èX‬‬ ‫‪LN(EXP(X))èX‬‬
‫‪LN(LN(e))è0‬‬ ‫))‪XY=EXP(Y*LN(X‬‬
‫)‪LN(A*B)=LN(A)+LN(B‬‬ ‫)‪LN(A/B) =LN(A)-LN(B‬‬

‫ﺗﻮﺍﺑﻊ ﻣﺜﻠﺜﺎﺗﻲ ‪ SIN‬ﻭ‪ : COS‬ﺍﻳﻦ ﺗﻮﺍﺑﻊ ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﺑﺮﺣﺴﺐ ﺭﺍﺩﻳﺎﻥ ﺩﺭﻳﺎﻓﺖ ﻣـﻲ ﻛﻨﻨـﺪ ) ﺍﺯ ﻧـﻮﻉ ‪ (Real‬ﻭ ﻳـﻚ ﻋـﺪﺩ ‪ Real‬ﺑﺮﻣـﻲ‬
‫ﮔﺮﺩﺍﻧﻨﺪ ﻭ ﻣﻘﺪﺍﺭ ‪ Sin‬ﻳﺎ ‪ Cos‬ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﻛﻨﻨﺪ‪ .‬ﻣﺜﻼ ﺑﺮﺍﻱ ﻣﺤﺎﺳﺒﻪ ‪ Sin‬ﺯﺍﻭﻳﻪ ‪ 30‬ﺩﺭﺟﻪ ﻋﺒﺎﺭﺕ )‪ Sin(30*PI/180‬ﺭﺍ ﻣﻲ ﻧﻮﻳﺴﻴﻢ‪.‬‬

‫ﺗﺎﺑﻊ ‪ : ArcTan‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﭘﺎﺭﻣﺘﺮ ‪ Real‬ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﻭ ﻳﻚ ﻋﺪﺩ ‪ Real‬ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ‪ .‬ﻋـﺪﺩ ﺧﺮﻭﺟـﻲ ﺑﺮﺣـﺴﺐ ﺭﺍﺩﻳـﺎﻥ ﺍﺳـﺖ‪.‬‬
‫ﻣﺜﻼ )‪ ArcTan(X‬ﻣﻘﺪﺍﺭ ﺯﺍﻭﻳﻪ ﺍﻳﻲ ﺭﺍ ﻛﻪ ﺗﺎﻧﮋﺍﻧﺖ ﺁﻥ ﺑﺮﺍﺑﺮ ‪ X‬ﺍﺳﺖ ﺭﺍ ﺑﺮ ﺣﺴﺐ ﺭﺍﺩﻳﺎﻥ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬

‫ﺗﺎﺑﻊ ‪ : Length‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﺭﺷﺘﻪ ﺑﻪ ﻋﻨﻮﺍﻥ ﻭﺭﻭﺩﻱ ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﻳﻚ ﻋﺪﺩ ‪ Integer‬ﺍﺳﺖ‪ .‬ﻭ ﻃﻮﻝ ﺭﺷﺘﻪ ﺩﺭﻳﺎﻓﺘﻲ ﺭﺍ‬
‫‪Length(’’’’)è1‬‬ ‫‪Length(’ALI’+’REZA’)è7‬‬ ‫ﺑﺮﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬
‫‪Length(’ALI’)è3‬‬ ‫‪Length(’AMIN’) è 4‬‬ ‫‪Length(’’)è0‬‬

‫ﺗﺎﺑﻊ ‪ : CHR‬ﺍﺯ ﺍﻳﻦ ﺗﺎﺑﻊ ﺑﺮﺍﻱ ﺩﺭﻳﺎﻓﺖ ﻛﺎﺭﺍﻛﺘﺮ ﻣﻌﺎﺩﻝ ﻛﺪ ‪ ASCII‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﻭﺭﻭﺩﻱ ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻋﺪﺩ ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 255‬ﺍﺳـﺖ )‬
‫ﺍﺯ ﻧﻮﻉ‪ (BYTE‬ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﺍﺯ ﻧﻮﻉ ‪ CHAR‬ﺍﺳﺖ‪CHR(65) è’A’ .‬‬
‫ﺧﻄﺎ ‪CHR(-66)è‬‬ ‫’‪CHR(ABS(-66))è’B‬‬ ‫ﻛﺎﺭﺍﻛﺘﺮ ﺑﻮﻕ ‪CHR(7)è‬‬
‫ﻧﻜﺘﻪ( ﻛﺪ ﺍﺳﻜﻲ ﻛﻠﻴﺪ ‪ ESC‬ﺑﺮﺍﺑﺮ ‪ 27‬ﺍﺳﺖ‪.‬‬

‫ﺗﺎﺑﻊ ‪ :Upcase‬ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺍﺯ ﻧﻮﻉ ﻛﺎﺭﺍﻛﺘﺮ ﺩﺍﺭﺩ ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﻧﻴﺰ ﺍﺯ ﻧﻮﻉ ﻛﺎﺭﺍﻛﺘﺮ)‪ (Char‬ﺍﺳﺖ ﻭ ﺣـﺮﻑ ﻛﻮﭼـﻚ ﺭﺍ ﺑـﻪ ﺣـﺮﻑ‬
‫’‪UPCASE(’A’)è’A‬‬ ‫’‪UPCASE(’d’) è’D‬‬ ‫’‪UPCASE(’n’) è’N‬‬ ‫ﺑﺰﺭﮒ ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﻳﻚ ﻛﻠﻴﺪ ﺭﺍ ﺩﺭ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﻓﺸﺎﺭ ﻣﻲ ﺩﻫﻴﺪ ﻳﻚ ﻳﺎ ﺩﻭ ﻛﺪ ﺗﻮﻟﻴﺪ ﻣﻲ ﺷﻮﺩ ﻭ ﺩﺭ ﺑﺎﻓﺮ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ‪.‬ﺑﻌﻀﻲ ﻛﻠﻴـﺪﻫﺎ‬
‫ﺭﺍ ﺗﻚ ﻛﺪﻱ ﻭ ﺑﻌﻀﻲ ﺭﺍ ﺩﻭﻛﺪﻱ ﻣﻲ ﮔﻮﻳﻨﺪ‪ .‬ﻣﺜﻼ ﻭﻗﺘﻲ ﻛﻠﻴﺪ ‪ A‬ﺭﺍ ﻣﻲ ﺯﻧﻴﺪ ﻛﺪ ‪ 65‬ﺗﻮﻟﻴﺪ ﻣﻲ ﺷﻮﺩ‪ .‬ﺍﻣﺎ ﻭﻗﺘﻲ ﻛﻠﻴﺪ ‪ F1‬ﺭﺍ ﻣﻲ ﺯﻧﻴﺪ ﺩﻭ ﻛـﺪ‬
‫ﺗﻮﻟﻴﺪ ﻣﻲ ﺷﻮﺩ ﺍﻭﻝ ﻛﺪ ‪ 0‬ﻛﻪ ﺑﻪ ﺁﻥ ﻛﺪ ﻧﻮﻝ ﻣﻲ ﮔﻮﻳﻨﺪ ﻭ ﺩﻭﻡ ﻛﺪ‪ 50‬ﺗﻮﻟﻴﺪ ﻣﻲ ﺷﻮﺩ‪ .‬ﻳﺎ ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﻛﻠﻴﺪ ↑ ﺭﺍ ﻣﻲ ﺯﻧﻴﺪ ﻛﺪ ﻫﺎﻱ ‪ 0‬ﻭ ‪72‬‬
‫ﺗﻮﻟﻴﺪ ﻣﻲ ﺷﻮﺩ‪ .‬ﻛﻠﻴﺪ ﻫﺎﻱ ‪ Enter‬ﻭ‪ ESC‬ﺗﻚ ﻛﺪﻱ ﻫﺴﺘﻨﺪ‪ ) .‬ﺩﺭ ﻭﺍﻗﻊ ﺑﻌﻀﻲ ﺍﺯ ﻛﻠﻴﺪ ﻫﺎﻱ ﻛﻨﺘﺮﻟﻲ ﻧﻴﺰ ﻛﻠﻴﺪﻫﺎﻱ ﺗﻚ ﻛﺪﻱ ﻣﻲ ﺑﺎﺷﻨﺪ(‬

‫ﺗﺎﺑﻊ‪ : ReadKey‬ﺍﻳﻦ ﺗﺎﺑﻊ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﻧﺪﺍﺭﺩ ﺍﻣﺎ ﺧﺮﻭﺟﻲ ﺁﻥ ﺍﺯ ﻧﻮﻉ ‪ CHAR‬ﺍﺳﺖ ﻭ ﺑﺎﻓﺮ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﺭﺍ ﺧﻮﺍﻧﺪﻩ ﻭ ﻳﻚ ﻛﺎﺭﺍﻛﺘﺮ ﺍﺯ‬
‫ﺁﻥ ﺭﺍ ﺑﺮ ﻣﻲ ﺩﺍﺭﺩ ﻭ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ‪ .‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻣﺮﺑﻮﻁ ﺑﻪ ﻳﻮﻧﻴﺖ ‪ Crt‬ﺍﺳﺖ ﻛﻪ ﺩﺭ ﺍﻳﻨﺠﺎ ﺑﺤـﺚ ﻣـﻲ ﺷـﻮﺩ‪.‬ﺑﺎﺩﺳـﺘﻮﺭ;‪ C:=ReadKey‬ﺩﺍﺧـﻞ‬
‫ﻣﺘﻐﻴﺮ ‪ C‬ﻳﻚ ﻛﺎﺭﺍﻛﺘﺮ ﺍﺯ ﺑﺎﻓﺮ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ‪ .‬ﺍﮔﺮ ﺑﺎﻓﺮ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﺧﺎﻟﻲ ﺑﺎﺷﺪ ﻣﻨﺘﻈﺮ ﻓـﺸﺎﺭ ﺩﺍﺩﻥ ﻳـﻚ ﻛﻠﻴـﺪ ﻣـﻲ ﻣﺎﻧـﺪ‪ .‬ﺍﮔـﺮ‬
‫ﻛﻠﻴﺪﻫﺎﻱ ﺩﻭﻛﺪﻱ ﺯﺩﻩ ﺷﻮﺩ ﺩﻭ ﻛﺪ ﺗﻮﻟﻴﺪ ﻣﻲ ﺷﻮﺩ ﻭ ﺑﻮﺳﻴﻠﺔ ﺩﻭﺑﺎﺭ ﺧﻮﺍﻧﺪﻥ ﺑﺎﻓﺮ ﻣﻲ ﺗﻮﺍﻥ ﺁﻥ ﺭﺍ ﺗﺸﺨﻴﺺ ﺩﺍﺩ‪.‬‬

‫ﺗﺎﺑﻊ ‪ : ORD‬ﺍﺯ ﺍﻳﻦ ﺗﺎﺑﻊ ﺑﺮﺍﻱ ﺩﺭﻳﺎﻓﺖ ﻋﺪﺩﻱ ﻣﺘﻨﺎﻇﺮ ﺑﺎ ﺗﺮﺗﻴﺐ ﺍﻋﻀﺎﻱ ﻧﻮﻉ ﺩﺍﺩﻩ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﻳﺎ ﺑﻪ ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ ﻣﺮﺗﺒﻪ ﻳـﻚ ﻧـﻮﻉ‬
‫ﺍﺳﻜﺎﻟﺮ ﺭﺍ ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ‪ .‬ﻫﻤﺎﻧﻄﻮﺭ ﻛﻪ ﻗﺒﻼ ﺩﺭ ﻣﻮﺭﺩ ﺍﻧﻮﺍﻉ ﺍﺳﻜﺎﻟﺮ ﮔﻔﺘﻪ ﺷﺪ ﺩﺍﺩﻩ ﻫﺎﻱ ﺍﺳﻜﺎﻟﺮ ﻗﺎﺑﻞ ﺷﻤﺎﺭﺷﻨﺪ ﻭ ﻗﺒﻞ ﻭ ﺑﻌﺪ ﺩﺍﺭﻧـﺪ‪ .‬ﭘـﺎﺭﺍﻣﺘﺮ‬
‫ﻭﺭﻭﺩﻱ ﺗﺎﺑﻊ ‪ ORD‬ﺑﺎﻳﺪ ﻳﻚ ﻧﻮﻉ ﺩﺍﺩﺓ ﺍﺳﻜﺎﻟﺮ)ﺻﺤﻴﺢ – ﻛﺎﺭﺍﻛﺘﺮﻱ – ﺑﻮﻟﻴﻦ( ﺑﺎﺷﺪ ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﻳـﻚ ﻋـﺪﺩ ﺍﺯ ﻧـﻮﻉ ‪) Longint‬ﺻـﺤﻴﺢ(‬
‫‪ORD(’A’)è65‬‬ ‫ﺍﺳﺖ‪.‬‬
‫‪ORD(’B’)è66‬‬ ‫‪ORD(0)è 0‬‬ ‫‪ORD(1)è1‬‬ ‫‪ORD(34)è34‬‬
‫‪ORD(-65)è-65‬‬ ‫‪ORD(FALSE)è0‬‬ ‫‪ORD(TRUE)è 1‬‬
‫ﺧﻄﺎ ‪ORD(25/5)è‬‬ ‫ﺧﻄﺎ ‪ORD (’TRUE’) è‬‬ ‫‪ORD(’1’)è49‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪47‬‬
‫ﺗﺎﺑﻊ ‪ : Pred‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻭﺭﻭﺩﻱ ﺍﺯ ﻧﻮﻉ ﺍﺳﻜﺎﻟﺮ ﺩﺍﺭﺩ ﻭ ﻣﻘﺪﺍﺭ ﻗﺒﻞ ﺍﺯ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺭﺍ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ‪ .‬ﺑﻨـﺎﺑﺮﺍﻳﻦ ﻭﺭﻭﺩﻱ ﻭ ﺧﺮﻭﺟـﻲ ﺁﻥ ﺍﺯ‬
‫’‪Pred(’B’)è’A‬‬ ‫‪Pred(3)è2‬‬ ‫ﻧﻮﻉ ﺍﺳﻜﺎﻟﺮ ﺍﺳﺖ‪.‬‬
‫‪Pred(True) è False‬‬ ‫‪Pred(False) è True‬‬ ‫’‪Pred(’F’)è’E‬‬
‫ﺧﻄﺎ ‪Pred(’AC’)è‬‬ ‫‪Pred (-3) è -4‬‬ ‫‪Pred(1) è0‬‬
‫‪ORD(CHR(PRED(67))) è66‬‬ ‫’‪CHR(ORD(PRED(67))) è’B‬‬
‫‪Pred(ORD(ODD(48)))è-1‬‬ ‫’\’ ‪Pred(’0’) è‬‬ ‫’@’‪Pred(’A’) è‬‬

‫ﺗﺎﺑﻊ ‪ : Succ‬ﺍﻳﻦ ﺗﺎﺑﻊ ﺩﺍﺭﺍﻱ ﻭﺭﻭﺩﻱ ﻭ ﺧﺮﻭﺟﻲ ﺍﺳﻜﺎﻟﺮ ﺍﺳﺖ ﻭ ﻛﺎﺭ ﺁﻥ ﻋﻜﺲ ﻛﺎﺭ ‪ Pred‬ﺍﺳﺖ ﻭ ﻋﻨـﺼﺮ ﺑﻌـﺪﻱ ﻭﺭﻭﺩﻱ ﺭﺍ ﺑﺮﻣـﻲ ﮔﺮﺩﺍﻧـﺪ‪.‬‬
‫‪SUCC(1) è 2‬‬ ‫’‪SUCC(’A’)è’B‬‬ ‫‪SUCC(-7) è-6‬‬
‫‪SUCC(Pred(X))èX‬‬ ‫‪SUCC(False) è True‬‬ ‫‪SUCC(True) èTrue‬‬
‫‪ORD(SUCC(’A’)) è66‬‬ ‫‪SUCC(10) è 11‬‬ ‫’[’‪SUCC(’Z’) è‬‬
‫ﺧﻄﺎ ‪SUCC ( 5.7) è‬‬ ‫‪Succ(’9’) è‬‬ ‫‪SUCC(A)=A+1‬‬

‫ﺩﺭ ﺍﺩﺍﻣﻪ ﺗﻌﺪﺍﺩﻱ ﭘﺮﻭﺳﻴﺠﺮﻫﺎﻱ )ﺯﻳﺮﺭﻭﺍﻝ ﻫﺎﻱ( ﻛﺘﺎﺑﺨﺎﻧﻪ ﺍﻳﻲ ﺭﺍ ﺗﻮﺿﻴﺢ ﻣﻲ ﺩﻫﻴﻢ‪ .‬ﭘﺮﻭﺳـﻴﺠﺮﻫﺎ ﺷـﺒﻴﻪ ﺗﻮﺍﺑـﻊ ﻫـﺴﺘﻨﺪ ﺑـﺎ ﺍﻳـﻦ ﺗﻔـﺎﻭﺕ ﻛـﻪ‬
‫ﺧﺮﻭﺟﻲ ﻧﺪﺍﺭﻧﺪ ﻭ ﻣﻘﺪﺍﺭﻱ ﺭﺍ ﺑﺮﻧﻤﻲ ﮔﺮﺩﺍﻧﻨﺪ‪ .‬ﺍﻟﺒﺘﻪ ﻣﻲ ﺗﻮﺍﻧﻨﺪ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ‪ .‬ﭘﺮﻭﺳﻴﺠﺮﻫﺎ ﭼﻮﻥ ﺧﺮﻭﺟﻲ ﻧﺪﺍﺭﻧﺪ ﻧﻤﻲ ﺗﻮﺍﻥ ﺁﻧﻬـﺎ‬
‫ﺭﺍ ﺩﺭ ﻋﺒﺎﺭﺍﺕ ﺻﺪﺍ ﺯﺩ)ﻓﺮﺍﺧﻮﺍﻧﻲ ﻛﺮﺩ(‪ .‬ﭘﺮﻭﺳﻴﺠﺮﻫﺎ ﺭﺍ ﺑﺎﻳﺪ ﺑﻪ ﺗﻨﻬﺎﻳﻲ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻛﺮﺩ‪ .‬ﺑـﻪ ﻋﻨـﻮﺍﻥ ﻣﺜـﺎﻝ ﺩﺳـﺘﻮﺭ ;)‪Writeln(ABS(-5)*2‬‬
‫ﺻﺤﻴﺢ ﺍﺳﺖ ﺯﻳﺮﺍ ‪ ABS‬ﻳﻚ ﺗﺎﺑﻊ ﺍﺳﺖ ﻭ ﻣﻲ ﺗﻮﺍﻥ ﺁﻥ ﺭﺍ ﺩﺭ ﻋﺒﺎﺭﺍﺕ ﻭ ﺩﺳﺘﻮﺭﺍﺕ ﺩﻳﮕﺮ ﺑـﻪ ﻛـﺎﺭ ﺑـﺮﺩ‪ .‬ﺩﺳـﺘﻮﺭ ;‪ C:=DEC(A)*2‬ﺍﺷـﺘﺒﺎﻩ‬
‫ﺍﺳﺖ ﺯﻳﺮﺍ ‪ DEC‬ﻳﻚ ﭘﺮﻭﺳﻴﺠﺮ ﺍﺳﺖ ﻭ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺩﺭ ﻋﺒﺎﺭﺍﺕ ﻳﺎ ﺩﺳﺘﻮﺭ ﺧﺮﻭﺟﻲ ﻗﺮﺍﺭ ﮔﻴﺮﺩ ﻭ ﺑﺎﻳﺪ ﺑﻪ ﺻﻮﺭﺕ ;)‪ DEC(A‬ﻓﺮﺍﺧﻮﺍﻧﻲ ﺷﻮﺩ‪.‬ﺩﺭ‬
‫ﻓﺼﻞ ﺑﻌﺪﻱ ﺩﺭ ﻣﻮﺭﺩ ﺗﻮﺍﺑﻊ ﻭ ﭘﺮﻭﺳﻴﺠﺮﻫﺎ ﻭ ﺍﺧﺘﻼﻑ ﺁﻧﻬﺎ ﺑﻴﺸﺘﺮ ﺑﺤﺚ ﻣﻲ ﺷﻮﺩ‪.‬‬

‫ﭘﺮﻭﺳﻴﺠﺮ ‪ : INC‬ﺍﻳﻦ ﭘﺮﻭﺳﻴﺠﺮ ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺍﺯ ﻧﻮﻉ ﺍﺳﻜﺎﻟﺮ ﺩﺍﺭﺩ ﻭ ﺑﺎﻳﺪ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺁﻥ ﺣﺘﻤﺎ ﻣﺘﻐﻴﺮ ﻳﺎ ﺛﺎﺑـﺖ ﺑـﺎﻧﻮﻉ ﺑﺎﺷـﺪ‪ .‬ﺑـﻪ‬
‫ﻣﺜﺎﻟﻬﺎﻱ ﺯﻳﺮ ﺩﻗﺖ ﻛﻨﻴﺪ‪:‬‬
‫;‪A:=12‬‬ ‫;‪A:=16‬‬ ‫;‪S:=8‬‬ ‫;‪H:=45‬‬
‫;)‪INC(A‬‬ ‫;)‪INC(A,5‬‬ ‫;)‪INC(S,-3‬‬ ‫;)‪INC(H,0‬‬
‫;)‪Writeln(A‬‬ ‫;)‪Writeln(A‬‬ ‫;)‪Writeln(S‬‬ ‫;)‪Writeln(H‬‬

‫ﻧﻜﺘﻪ( ﺩﺳﺘﻮﺭ ;)‪ INC(4‬ﻏﻠﻂ ﺍﺳﺖ‪.‬ﺯﻳﺮﺍ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﻧﺒﺎﻳﺪ ﺛﺎﺑﺖ ﺑﺎﺷﺪ‪ .‬ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﻧﺒﺎﻳﺪ ﻋﺒﺎﺭﺕ ﺑﺎﺷﺪ‪.‬‬
‫;’‪Z:=’B‬‬ ‫;‪M:=5.3‬‬ ‫ﻧﻜﺘﻪ( ﭘﺮﻭﺳﻴﺠﺮ ;)‪ INC(A,4‬ﻣﻌﺎﺩﻝ ﺩﺳﺘﻮﺭ ;‪ A:=A+4‬ﺍﺳﺖ ﻭ ﭘﺮﻭﺳﻴﺠﺮ ;)‪INC(A‬‬
‫;)‪INC(Z‬‬ ‫;)‪INC(M+1‬‬ ‫ﻣﻌﺎﺩﻝ ;‪ A:=A+1‬ﺍﺳﺖ‪.‬‬
‫;)‪Write(Z‬‬ ‫;)‪Write(M‬‬

‫ﭘﺮﻭﺳﻴﺠﺮ ‪ : DEC‬ﺍﻳﻦ ﭘﺮﻭﺳﻴﺠﺮ ﻋﻜﺲ ﭘﺮﻭﺳﻴﺠﺮ ‪ INC‬ﺍﺳﺖ ﻭ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻭﺭﻭﺩﻱ ﺁﻥ ﻧﻴﺰ ﺷﺒﻴﻪ ‪ INC‬ﺍﺳﺖ‪.‬‬
‫;‪S:=5‬‬ ‫;‪F:=12‬‬ ‫;’‪H:=’C‬‬ ‫;‪D:=5‬‬
‫;)‪DEC(S‬‬ ‫;)‪DEC(F,4‬‬ ‫;)‪DEC(H,2‬‬ ‫;)‪DEC(D,-3‬‬
‫;)‪Write(S‬‬ ‫;)‪Writeln(F‬‬ ‫;)‪Writeln(H‬‬ ‫;)‪Writeln(D‬‬

‫ﻧﻜﺘﻪ( ;)‪ INC(A,-1‬ﻣﻌﺎﺩﻝ;)‪ DEC(A‬ﺍﺳﺖ ﻭ ;)‪ DEC(B,-3‬ﻣﻌﺎﺩﻝ ;)‪ INC(B,3‬ﺍﺳﺖ‪.‬‬

‫ﻧﻜﺘﻪ( ;)‪ DEC(A,5‬ﻣﻌﺎﺩﻝ ;‪ A:=A-5‬ﺍﺳﺖ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪48‬‬
‫ﺗﺴﺖ(‬
‫‪ -١‬ﺧﺮﻭﺟﻲ ﺗﺎﺑﻊ ‪ INT‬ﺍﺯ ﭼﻪ ﻧﻮﻋﻲ ﺍﺳﺖ؟‬
‫ﺩ(‪Boolean‬‬ ‫ﺝ( ‪Real‬‬ ‫ﺏ( ‪Char‬‬ ‫ﺍﻟﻒ( ‪Integer‬‬
‫‪ - ٢‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﺑﻪ ﺗﺮﺗﻴﺐ ﻛﺪﺍﻡ ﺍﺳﺖ؟ )ﭼﭗ ﺑﻪ ﺭﺍﺳﺖ(‬
‫;‪A:=10; B:=-13.6‬‬
‫;)‪DEC(A‬‬ ‫ﺏ(‪10,-14,-14‬‬ ‫ﺍﻟﻒ(‪11,-14,-13‬‬
‫;))‪Writeln(A,Round(B),Trunc(B‬‬ ‫ﺩ(‪9,-14,-13‬‬ ‫ﺝ(‪9,-13,-14‬‬

‫;))‪Write(CHR(ORD(PRED(’B’))+2‬‬ ‫‪ -٣‬ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫ﺩ( ‪D‬‬ ‫ﺝ( ‪C‬‬ ‫ﺏ(‪68‬‬ ‫ﺍﻟﻒ(‪67‬‬
‫‪ -٤‬ﺣﺎﺻﻞ ﺗﺎﺑﻊ ‪ Frac‬ﺍﺯ ﭼﻪ ﻧﻮﻋﻲ ﺍﺳﺖ؟‬
‫ﺩ(‪Real‬‬ ‫ﺝ(‪Word‬‬ ‫ﺏ( ‪Integer‬‬ ‫ﺍﻟﻒ( ‪Char‬‬
‫‪ -٥‬ﻧﻮﻉ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﻭ ﺧﺮﻭﺟﻲ ﺗﺎﺑﻊ )‪ Odd(X‬ﭼﻴﺴﺖ؟‬
‫ﺩ( ﺻﺤﻴﺢ ‪ ،‬ﺻﺤﻴﺢ‬ ‫ﺝ( ﺻﺤﻴﺢ‪ ،‬ﻣﻨﻄﻘﻲ‬ ‫ﺏ(ﺍﻋﺸﺎﺭﻱ‪ ،‬ﺍﻋﺸﺎﺭﻱ‬ ‫ﺍﻟﻒ( ﺍﻋﺸﺎﺭﻱ ‪ ،‬ﻣﻨﻄﻘﻲ‬

‫‪For K:=1 To 3 Do‬‬ ‫‪ - ٦‬ﺑﺎ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎﺑﻞ ﺩﺭ ﺧﺮﻭﺟﻲ ﭼﻪ ﭼﻴﺰﻱ ﭼﺎﭖ ﺧﻮﺍﻫﺪ ﺷﺪ؟‬
‫‪For M:=2 To 6 Do‬‬ ‫ﺝ(‪108‬‬ ‫ﺏ(‪109‬‬ ‫‪1‬‬ ‫ﺍﻟﻒ(‬
‫‪Begin‬‬
‫ﺩ( ‪2‬‬
‫;))‪Z:=frac(Int(K*M‬‬
‫;‪W:=Z*M+1‬‬
‫;‪End‬‬ ‫‪ - ٧‬ﻛﺪﺍﻣﻴﻚ ﺍﺯ ﺗﻮﺍﺑﻊ ﭘﺎﺳﻜﺎﻝ ﻣﻲ ﺗﻮﺍﻧﺪ ﻋﺪﺩ ‪ 6.6‬ﺭﺍ ﺑﻪ ‪ 6‬ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﺪ؟‬
‫;)‪Write(W:2:0‬‬
‫ﺏ(‪Round‬‬ ‫ﺍﻟﻒ(‪ODD‬‬
‫ﺩ(‪Frac‬‬ ‫ﺝ(‪Trunc‬‬
‫‪ -٨‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺣﺮﻑ ‪ F‬ﺭﺍ ﭼﺎﭖ ﻣﻲ ﻛﻨﺪ؟‬
‫ﺏ( ;))’‪Write(ORD(’F‬‬ ‫ﺍﻟﻒ( ;)))’‪Write(CHR(ORD(’F‬‬
‫ﺩ( ;))’‪Write(Pred(’F‬‬ ‫ﺝ( ;)))’‪Write(ORD(CHR(’F‬‬
‫‪ -٩‬ﺣﺎﺻﻞ ﺍﺟﺮﺍﻱ ﺣﻠﻘﻪ ﻣﻘﺎﺑﻞ ﭼﻴﺴﺖ؟‬
‫ﺏ( ‪5 7 9‬‬ ‫ﺍﻟﻒ( ‪6 8 10‬‬
‫‪For A:=-5 Downto -10 Do‬‬
‫‪Begin‬‬ ‫ﺩ( ‪-6 -8 -10‬‬ ‫ﺝ(ﻫﻴﭻ ﭼﻴﺰ ﺩﺭ ﺧﺮﻭﺟﻲ ﭼﺎﭖ ﻧﻤﻲ ﺷﻮﺩ‬
‫;)‪Write(Ord(ABS(A):2‬‬
‫;)‪Dec(A‬‬
‫;‪End‬‬

‫))‪Write(Round(-13.9‬‬ ‫‪-١٠‬ﭘﺲ ﺍﺯ ﺍﺟﺮﺍﻱ ﻓﺮﻣﺎﻥ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬

‫ﺩ(‪14‬‬ ‫ﺝ(‪13‬‬ ‫ﺏ(‪-13‬‬ ‫ﺍﻟﻒ(‪-14‬‬

‫;‪A:=100‬‬ ‫‪ - ١١‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫;))‪Writeln(DEC(A,2‬‬ ‫ﺩ(ﺧﻄﺎ‬ ‫ﺝ( ‪100‬‬ ‫ﺏ(‪102‬‬ ‫ﺍﻟﻒ( ‪98‬‬

‫‪-١٢‬ﻛﺪﺍﻣﻴﻚ ﺍﺯ ﺭﻫﻨﻤﻮﺩﻫﺎﻱ ﺯﻳﺮ ﺑﺎﻋﺚ ﻣﻴﺸﻮﺩ ﻛﻪ ﺩﺍﺩﻩ ﻫﺎﻱ ‪ ٨٠٨٧‬ﺭﺍ ﺯﻣﺎﻧﻲ ﺑﺘﻮﺍﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ ﻛﻪ ﻛﻤﻚ ﭘﺮﺩﺍﺯﺷﮕﺮ ‪ ٨٠٨٧‬ﻣﻮﺟﻮﺩ ﺑﺎﺷﺪ؟‬
‫ﺩ(ﻫﻴﭽﻜﺪﺍﻡ‬ ‫ﺝ( }‪{$N+,E+‬‬ ‫ﺏ(}‪{$N+,E-‬‬ ‫ﺍﻟﻒ(}‪{$N+‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪49‬‬
‫‪-١٣‬ﻧﺘﻴﺠﺔ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭ;))‪ Write(Succ(True‬ﭼﻴﺴﺖ؟‬
‫ﺩ(ﺧﻄﺎﻱ ‪Run Time Erro‬‬ ‫ﺝ(‪1‬‬ ‫ﺏ(‪True‬‬ ‫ﺍﻟﻒ(‪False‬‬
‫;)))))’‪WRITE(CHR(ord(Pred(Upcase(’b‬‬ ‫‪-١٤‬ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭ ﺯﻳﺮ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪65‬‬ ‫ﺝ(‪a‬‬ ‫ﺏ(‪C‬‬ ‫ﺍﻟﻒ(‪A‬‬
‫)‪INT(A+B)/FRAC(B)+SQR(A‬‬ ‫‪-١٥‬ﻋﺒﺎﺭﺕ ﻣﻘﺎﺑﻞ ﻣﻌﺎﺩﻝ ﻛﺪﺍﻡ ﻋﺒﺎﺭﺕ ﺟﺒﺮﻱ ﺍﺳﺖ؟‬
‫ﺩ(‪[A+B] +A2‬‬ ‫ﺝ (‪[A+B] +A2‬‬ ‫ﺏ( ]‪[A+B‬‬ ‫ﺍﻟﻒ( ]‪[A+B‬‬
‫‪2‬‬
‫]‪[B‬‬ ‫]‪B-[B‬‬ ‫‪B-[B]+A‬‬ ‫‪[B]+A2‬‬
‫;)))‪X:=SQRT(ABS(INT(-9.1‬‬ ‫‪-١٦‬ﭘﺲ ﺍﺯ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭ ﺭﻭﺑﺮﻭ ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ‪ X‬ﻛﺪﺍﻡ ﺧﻮﺍﻫﺪ ﺑﻮﺩ؟‬
‫ﺩ(‪3‬‬ ‫ﺝ(‪-3‬‬ ‫ﺏ( ‪2.8‬‬ ‫ﺍﻟﻒ(‪-2.8‬‬
‫‪-١٧‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺍﺯ ﻛﻠﻤﺎﺕ ﺭﺯﺭﻭ ﺷﺪﻩ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﻣﻲ ﺑﺎﺷﺪ؟‬
‫ﺩ(‪TRUE‬‬ ‫ﺝ(‪VAR‬‬ ‫ﺏ(‪Readln‬‬ ‫ﺍﻟﻒ(‪Integer‬‬
‫;))‪Write(Ord(0‬‬ ‫‪-١٨‬ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪True‬‬ ‫ﺝ(‪False‬‬ ‫ﺏ(‪1‬‬ ‫ﺍﻟﻒ(‪0‬‬
‫;)‪X:=Pred(3.5‬‬ ‫‪-١٩‬ﭘﺲ ﺍﺯ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭ ﺭﻭﺑﺮﻭ ﻣﻘﺪﺍﺭ ‪ X‬ﻛﺪﺍﻡ ﺧﻮﺍﻫﺪ ﺑﻮﺩ؟‬
‫ﺩ(ﺍﺯ ﺗﺎﺑﻊ ‪ Pred‬ﺍﺳﺘﻔﺎﺩﺓ ﻏﻴﺮ ﻣﺠﺎﺯ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬ ‫ﺝ(‪4‬‬ ‫ﺏ(‪3‬‬ ‫ﺍﻟﻒ(‪2‬‬
‫;))‪Write(ODD(2‬‬ ‫‪-٢٠‬ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪True‬‬ ‫ﺝ(‪False‬‬ ‫ﺏ(‪3‬‬ ‫ﺍﻟﻒ(‪1‬‬
‫‪-٢١‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ))‪ CHR(ORD(’a’) AND ($CF‬ﺩﺭ ﺧﺮﻭﺟﻲ ﺑﺮﺍﺑﺮ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺍﺳﺖ؟‬
‫ﺩ(‪a‬‬ ‫ﺝ(‪A‬‬ ‫ﺏ(‪65‬‬ ‫ﺍﻟﻒ(‪$97‬‬
‫)‪5+2/8*3-SQRT(8 DIV 2) +2 MOD Round(6 div 4‬‬ ‫‪-٢٢‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬
‫ﺩ(‪5.25‬‬ ‫ﺝ(‪4.75‬‬ ‫ﺏ(‪3.75‬‬ ‫ﺍﻟﻒ(‪-0.375‬‬
‫‪For A:=1 to 150 Do‬‬ ‫‪ - ٢٣‬ﺧﺮﻭﺟﻲ ﻗﻄﻌﻪ ﺑﺮﻧﺎﻣﻪ ﭼﻴﺴﺖ؟‬
‫;‪X:=Succ(Abs((A+1))+125 Mod 5 – 19 Div 3‬‬ ‫ﺏ(‪187‬‬ ‫ﺍﻟﻒ(‪153‬‬
‫ﺩ(‪146‬‬ ‫ﺝ(‪790‬‬
‫‪Round(Exp(Ln(5.6)-Ln(2))+ 10 Mod -3‬‬ ‫‪-٢٤‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﻣﻘﺎﺑﻞ ﭼﻴﺴﺖ؟‬
‫ﺩ(‪3‬‬ ‫ﺝ(‪4‬‬ ‫ﺏ(‪2‬‬ ‫ﺍﻟﻒ(‪5‬‬
‫‪ -٢٥‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫;‪D:=20‬‬ ‫ﺩ(‪20‬‬ ‫ﺝ(‪13‬‬ ‫ﺏ(‪0‬‬ ‫ﺍﻟﻒ( ‪32‬‬
‫;)‪Writeln($D‬‬
‫‪ -٢٦‬ﻛﺪﺍﻡ ﺭﺍﺑﻄﻪ ﺻﺤﻴﺢ ﺍﺳﺖ؟)‪ X‬ﻳﻚ ﻋﺪﺩ ﺍﻋﺸﺎﺭﻱ ﺍﺳﺖ (‬
‫ﺏ()‪X=TRUNC(X)+FRAC(X‬‬ ‫ﺍﻟﻒ( )‪X=TRUNC(X‬‬
‫ﺩ( )‪X=Round(X) +INT(X‬‬ ‫ﺝ()‪X=Round(X)+Frac(X‬‬
‫)))‪Trunc(Exp(3*Ln(2‬‬ ‫‪-٢٧‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬
‫ﺩ(‪9‬‬ ‫ﺝ(‪5‬‬ ‫ﺏ(‪8‬‬ ‫ﺍﻟﻒ(‪6‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪50‬‬
‫ﯾﻮﻧﯿﺖ ‪: Unit‬‬
‫ﺗﻮﺍﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ ﺍﻳﻲ ﻛﻪ ﺩﺭ ﻗﺴﻤﺖ ﻗﺒﻠﻲ ﺑﻴﺎﻥ ﻛﺮﺩﻳﻢ ﻫﻤﮕﻲ ﺩﺍﺧﻞ ﻳﻚ ﻓﺎﻳﻞ ﻫﺴﺘﻨﺪ ﻛﻪ ﻗﺒﻼ ﺗﻌﺮﻳـﻒ ﺷـﺪﻩ ﺍﻧـﺪ‪ .‬ﺍﻳـﻦ ﺗﻮﺍﺑـﻊ ﺗﻮﺳـﻂ ﺑﺮﻧﺎﻣـﻪ‬
‫ﻧﻮﻳﺴﺎﻥ ﺩﻳﮕﺮ ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺍﺳﺖ ﻭ ﺷﻤﺎ ﻣﻲ ﺗﻮﺍﻧﻴﺪ ﺍﺯ ﺁﻧﻬﺎ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﺪ‪ .‬ﻳﻮﻧﻴﺖ‪ ،‬ﻣﺠﻤﻮﻋﻪ ﺍﻱ ﺍﺯ ﺗﻌﺎﺭﻳﻒ ﺷﺎﻣﻞ ﻧﻮﻉ ﺩﺍﺩﻩ ﻫﺎ‪ ،‬ﺛﺎﺑﺘﻬﺎ‪ ،‬ﻣﺘﻐﻴﺮﻫﺎ‬
‫ﻭ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺍﺳﺖ ﻛﻪ ﺑﻪ ﻃﻮﺭ ﻣﺴﺘﻘﻞ ﺗﺮﺟﻤﻪ ﻣﻲ ﺷﻮﺩ ﻭ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻫﺎﻱ ﺩﻳﮕﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﻫﺮ ﻳﻮﻧﻴﺖ ﺩﺭ ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ ﭘﺴﻮﻧﺪ ‪TPU‬‬
‫ﺫﺧﻴﺮﻩ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺗﻮﺭﺑﻮﭘﺎﺳﻜﺎﻝ ‪ ٧‬ﺩﺍﺭﺍﻱ ﺗﻌﺪﺍﺩﻱ ﻳﻮﻧﻴﺖ ﺍﺳﺖ ﻛﻪ ﻫﺮ ﻛﺪﺍﻡ ﺍﺯ ﺁﻧﻬﺎ ﺷـﺎﻣﻞ ﺗﻌـﺪﺍﺩﻱ ﺯﻳﺮﺑﺮﻧﺎﻣـﻪ ﺍﺳـﺖ‪ .‬ﻣﺎﻧﻨـﺪ ﻳﻮﻧﻴـﺖ ﻫـﺎﻱ‬
‫‪ CRT‬ﻭ ‪ ) Graph‬ﺗﻮﺍﺑﻌﻲ ﺟﻬﺖ ﺭﺳﻢ ﺧﻂ ﻭ ﺩﺍﻳﺮﻩ ﻭ ﺍﺷﻜﺎﻝ ﮔﺮﺍﻓﻴﻜﻲ( ﻭ ‪ System‬ﻭ ‪ Dos‬ﻭ …‪.‬‬
‫ﻫﺮ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ ﺗﻮﺍﻧﺪ ﻳﻮﻧﻴﺖ ﺍﻳﺠﺎﺩ ﻛﻨﺪ ﻭ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻫﺎﻱ ﺧﻮﺩ ﺍﺯ ﺁﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﺪ‪.‬‬
‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﻣﻲ ﺧﻮﺍﻫﻴﻢ ﺍﺯ ﺗﻮﺍﺑﻊ ﻳﺎ ﺑﻄﻮﺭﻛﻠﻲ ﺍﺯ ﺗﻌﺎﺭﻳﻒ ﻣﻮﺟﻮﺩ ﺩﺭ ﻳﻚ ﻳﻮﻧﻴﺖ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﻢ ﺑﺎﻳﺪ ﺩﺭ ﻗـﺴﻤﺖ ﺗﻌـﺎﺭﻳﻒ ﻳﻮﻧﻴـﺖ ﺭﺍ ﻣـﺸﺨﺺ‬
‫;‪Uses Crt‬‬ ‫ﻛﻨﻴﻢ‪ .‬ﺑﺮﺍﻱ ﺍﻳﻦ ﻛﺎﺭ ﺍﺯ ﻛﻠﻤﺔ ﺫﺧﻴﺮﻩ ﺷﺪﺓ ‪ Uses‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﻣﺎﻧﻨﺪ‬

‫ﻳﻮﻧﻴﺖ ‪ System‬ﺷﺎﻣﻞ ﺗﻌﺎﺭﻳﻒ ﭘﺮﻛﺎﺭﺑﺮﺩ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺗﻮﺭﺑﻮﭘﺎﺳﻜﺎﻝ ﺍﺳﺖ ﻣﺎﻧﻨﺪ ﺩﺳﺘﻮﺭﺍﺕ ‪ Readln‬ﻭ ‪ Writeln‬ﻭ‪ integer‬ﻭ‪ real‬ﻭ ﻏﻴﺮﻩ‪.‬‬
‫ﺗﻮﺍﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ ﺍﻱ ﻛﻪ ﻗﺒﻼ ﺑﻴﺎﻥ ﺷﺪ ﻧﻴﺰ ﺩﺭ ﻳﻮﻧﻴﺖ ‪ System‬ﻗﺮﺍﺭ ﺩﺍﺭﻧﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﻳﻮﻧﻴﺖ ‪ system‬ﺍﺯ ﺳﻮﻱ ﻣﺘﺮﺟﻢ ﺑﻪ ﻃﻮﺭ ﺧﻮﺩﻛﺎﺭ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ ﻭ ﻧﻴﺎﺯﻱ ﺑﻪ ﺗﻌﺮﻳﻒ ﺁﻥ ﺩﺭ ﻗﺴﻤﺖ ‪ Uses‬ﻧﻴﺴﺖ‪.‬‬
‫ﺩﺭ ﻗﺴﻤﺖ ﻫﺎﻱ ﺑﻌﺪﻱ ﺗﻌﺪﺍﺩﻱ ﺍﺯ ﺗﻮﺍﺑﻊ ﻣﻮﺟﻮﺩ ﺩﺭﻳﻮﻧﻴﺖ ‪ Crt‬ﺭﺍ ﺑﻴﺎﻥ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫زﯾﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ )ﺗﻮاﺑﻊ و ﭘﺮوﺳﯿﺠﺮﻫﺎ(‪:‬‬
‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﻣﻲ ﺧﻮﺍﻫﻴﻢ ﻳﻚ ﺑﺮﻧﺎﻣﺔ ﺑﺰﺭﮒ ﺑﻨﻮﻳﺴﻴﻢ ﺗﻌﺪﺍﺩ ﺩﺳﺘﻮﺭﺍﺕ ﺁﻥ )ﺗﻌﺪﺍﺩ ﺧﻄﻮﻁ ﺑﺮﻧﺎﻣﻪ( ﺑﺴﻴﺎﺭ ﺯﻳﺎﺩ ﻣـﻲ ﺷـﻮﺩ ﻛـﻪ ﺩﺭ ﺍﻳـﻦ ﺻـﻮﺭﺕ‬
‫ﻋﻴﺐ ﻳﺎﺑﻲ ﺑﺮﻧﺎﻣﻪ ﻣﺸﻜﻞ ﻭ ﻭﻗﺖ ﮔﻴﺮ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪ .‬ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺑﻪ ﻗﻄﻌﺎﺕ ﻛﻮﭼﻜﺘﺮﻱ ﺗﻘﺴﻴﻢ ﻣﻲ ﻛﻨـﻴﻢ ﻭ ﺑـﺮﺍﻱ ﻫـﺮ ﻗﻄﻌـﻪ ﻳـﻚ‬
‫ﺯﻳﺮﺑﺮﻧﺎﻣﻪ )ﺯﻳﺮﺍﻟﮕﻮﺭﻳﺘﻢ( ﻣﻲ ﻧﻮﻳﺴﻴﻢ‪ .‬ﺣﺎﻝ ﺗﺮﻛﻴﺐ ﻫﻤﺔ ﺍﻳﻦ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺑﺮﻧﺎﻣﺔ ﺍﺻﻠﻲ ﺭﺍ ﺗﺸﻜﻴﻞ ﻣﻲ ﺩﻫﻨﺪ‪ .‬ﺣﺎﻝ ﻫﺮ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻣﻲ ﺗﻮﺍﻧﺪ ﺑـﻪ‬
‫ﺗﻨﻬﺎﻳﻲ ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﻭ ﺑﻪ ﻃﻮﺭ ﻣﺴﺘﻘﻞ ﺁﺯﻣﺎﻳﺶ ﺷﻮﺩ‪ .‬ﻫﺮ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻣﺎﻧﻨﺪ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﺩﺍﺭﺍﻱ ﺑﺨﺸﻬﺎﻱ ﻋﻨﻮﺍﻥ‪ ،‬ﺗﻌﺎﺭﻳﻒ ﻭ ﺑﻼﻙ ﺍﺳﺖ‪ .‬ﺯﻳﺮﺑﺮﻧﺎﻣﻪ‬
‫ﻫﺎ ﺑﻪ ﺩﻭ ﺩﺳﺘﻪ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ‪ :‬ﺗﺎﺑﻊ )ﻓﺎﻧﻜﺸﻦ( ﻭ ﭘﺮﺩﺍﺯﻩ)ﺯﻳﺮﺭﻭﺍﻝ ﻳﺎ ﭘﺮﻭﺳﻴﺠﺮ(‪ .‬ﺍﻳﻦ ﺩﻭ ﺩﺳﺘﻪ ﺷﺒﺎﻫﺖ ﻫﺎ ﻭ ﺍﺧﺘﻼﻓﺎﺗﻲ ﺑﺎ ﻫﻢ ﺩﺍﺭﻧﺪ ﻛﻪ‬
‫ﺑﻴﺎﻥ ﺧﻮﺍﻫﺪ ﺷﺪ‪.‬‬
‫ﻣﺰﺍﻳﺎﻱ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ‪ -١ :‬ﻗﺎﺑﻠﻴﺖ ﺧﻮﺍﻧﺎﻳﻲ ﺑﺮﻧﺎﻣﻪ ﺍﻓﺰﺍﻳﺶ ﻣـﻲ ﻳﺎﺑـﺪ‪-٢ .‬ﺩﺭﻙ ﻣـﺴﺎﺋﻞ ﻛـﻮﭼﻜﺘﺮ ﺁﺳـﺎﻧﺘﺮ ﺍﺳـﺖ‪ -٣ .‬ﺍﺯ ﻳـﻚ‬
‫ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻣﻲ ﺗﻮﺍﻥ ﺩﺭ ﻳﻚ ﻳﺎ ﭼﻨﺪ ﺑﺮﻧﺎﻣﻪ ﻣﺨﺘﻠﻒ ﺑﻪ ﺩﻓﻌﺎﺕ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ‪-٤ .‬ﺍﺷﻜﺎﻝ ﺯﺩﺍﻳﻲ ﺁﺳﺎﻧﺘﺮ ﺍﺳﺖ‪ -٥ .‬ﻛﺎﺭﮔﺮﻭﻫﻲ ﺭﺍ ﺍﻣﻜﺎﻥ ﭘﺬﻳﺮ‬
‫ﻣﻲ ﻛﻨﺪ‪ -٦ .‬ﺳﺮﻋﺖ ﻃﺮﺍﺣﻲ ﻭ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺑﺎﻻ ﻣﻲ ﺑﺮﺩ‪.‬‬

‫ﻧﮑﺘﻪ(ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺩﺭ ﺑﺎﻻﻱ ﺑﻼﻙ ﺍﺻﻠﻲ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬

‫ﭘﺮدازه ﻫﺎ ) زﯾﺮروال‪ -‬ﭘﺮوﺳﯿﺠﺮﻫﺎ( ‪:‬‬
‫ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﻳﻚ ﭘﺮﺩﺍﺯﻩ ﺍﺯ ﻛﻠﻤﺔ ﺭﺯﺭﻭ ﺷﺪﻩ ‪ Procedure‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﺷﻜﻞ ﻛﻠﻲ ‪:‬‬
‫;)ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻭﺭﻭﺩﻱ ﻭ ﻧﻮﻉ ﺁﻧﻬﺎ ( ﻧﺎﻡ ﭘﺮﺩﺍﺯﻩ ‪Procedure‬‬
‫ﺗﻌﺎﺭﻳﻒ ﻣﺮﺑﻮﻁ ﺑﻪ ﺍﻳﻦ ﭘﺮﺩﺍﺯﻩ‬
‫‪Begin‬‬
‫‪……..‬‬
‫;‪End‬‬
‫ﻧﺎﻡ ﭘﺮﺩﺍﺯﻩ ﭼﻮﻥ ﻳﻚ ﺷﻨﺎﺳﻪ ﻏﻴﺮﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺍﺳﺖ ﺑﺎﻳﺪ ﺍﺯ ﻗﻮﺍﻧﻴﻦ ﻧﺎﻡ ﮔﺬﺍﺭﻱ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻏﻴﺮﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﭘﻴﺮﻭﻱ ﻛﻨـﺪ‪ .‬ﺗﻌـﺎﺭﻳﻒ ﻣﺮﺑـﻮﻁ ﺑـﻪ ﻫـﺮ‬
‫ﭘﺮﺩﺍﺯﻩ ﻣﺨﺼﻮﺹ ﻫﻤﺎﻥ ﭘﺮﺩﺍﺯﻩ ﺍﺳﺖ ﻭ ﻓﻘﻂ ﺩﺭ ﻣﺤﺪﻭﺩﺓ ﻫﻤﺎﻥ ﭘﺮﺩﺍﺯﻩ ﻣﻲ ﺗﻮﺍﻧﺪ ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ‪ .‬ﻗﺴﻤﺖ ﺗﻌﺎﺭﻳﻒ ﻣﻲ ﺗﻮﺍﻧﺪ ﺷﺎﻣﻞ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ‬
‫ﻳﺎ ﺛﺎﺑﺖ ﻳﺎ ﻫﺮ ﺷﻨﺎﺳﺔ ﺩﻳﮕﺮ) ﺣﺘﻲ ﻳﻚ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺩﻳﮕﺮ( ﺑﺎﺷﺪ‪.‬‬
‫ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺍﺻﻠﻲ ﻣﻲ ﺗﻮﺍﻥ ﻳﻚ ﭘﺮﺩﺍﺯﻩ ﺭﺍ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻛﺮﺩ)ﺻﺪﺍ ﺯﺩ(‪ .‬ﺑﺮﺍﻱ ﺍﻳﻦ ﻛﺎﺭ ﻓﻘﻂ ﻧﺎﻡ ﺁﻥ ﺭﺍ ﻧﻮﺷـﺘﻪ ﻭ ﭘﺎﺭﺍﻣﺘﺮﻫـﺎﻱ ﻭﺭﻭﺩﻱ ﺁﻥ ﺭﺍ ﺑـﻪ ﺁﻥ‬
‫ﺗﺤﻮﻳﻞ ﻣﻲ ﺩﻫﻴﻢ‪ .‬ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺩﺭ ﺑﻼﻙ ﺍﺻﻠﻲ ﭘﺮﻭﺳﻴﺠﺮ ﺭﺍ ﺻﺪﺍ ﻣﻲ ﺯﻧﻴﻢ ﻛﻨﺘﺮﻝ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻗﺴﻤﺖ ﭘﺮﻭﺳﻴﺠﺮ ﺻﺪﺍﺯﺩﻩ ﺷﺪﻩ ﻣﻲ ﺭﻭﺩ ﻭ‬
‫ﻫﻤﺔ ﺩﺳﺘﻮﺭﺍﺕ ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺩﺭ ﻗﺴﻤﺖ ﺩﺳﺘﻮﺭﺍﺕ ﺁﻥ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﻭ ﺳﭙﺲ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﺍﺻﻠﻲ ﺑﺮﻣﻲ ﮔﺮﺩﺩ ﻭ ﺩﻧﺒﺎﻟﺔ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺍﺟﺮﺍ ﻣﻲ ﻛﻨﺪ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪51‬‬
‫ﻧﻜﺘﻪ( ﺩﻗﺖ ﻛﻨﻴﺪ ﻛﻪ ﻫﺮ ﭘﺮﻭﺳﻴﺠﺮ ﺩﺍﺭﺍﻱ ﻗﺴﻤﺖ ﺩﺳﺘﻮﺭﺍﺕ ﺍﺳﺖ ﻛﻪ ﺑﺎ ‪ END‬ﺑﺎ ﻋﻼﻣﺖ ; ﺑﻪ ﭘﺎﻳﺎﻥ ﻣﻲ ﺭﺳﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﻣﻲ ﺗﻮﺍﻧﺪ ﭼﻨﺪﻳﻦ ﭘﺮﻭﺳﻴﺠﺮ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬

‫‪Var‬‬ ‫;‪H:integer‬‬ ‫ﻣﺜﺎﻝ(ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﭘﺮﻭﺳﻴﺠﺮ ‪ Power‬ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﻣﺘﻐﻴﺮ ‪ Z‬ﻣﺮﺑﻮﻁ ﺑﻪ‬
‫;)‪Procedure Power(M:integer‬‬ ‫ﭘﺮﻭﺳﻴﺠﺮ ‪ Power‬ﺍﺳﺖ ﻛﻪ ﺍﺻﻄﻼﺣﺎ ﺑﻪ ﺍﻳﻦ ﻣﺘﻐﻴﺮ‪ ،‬ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ ﻣﻲ ﮔﻮﻳﻨﺪ‪.‬‬
‫‪Var‬‬
‫ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﭘﺮﻭﺳﻴﺠﺮ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﻳﻚ ﻋﺪﺩ ‪ Integer‬ﺍﺳﺖ‪.‬‬
‫;‪Z:integer‬‬
‫‪Begin‬‬ ‫ﻧﻜﺘﻪ(ﺗﻌﺪﺍﺩ ﻭ ﻧﻮﻉ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻭﺭﻭﺩﻱ ﺑﺎ ﺁﻧﭽﻪ ﺩﺭ ﻫﻨﮕﺎﻡ ﻓﺮﺍﺧﻮﺍﻧﻲ ﺑﻪ ﺁﻥ ﺗﺤﻮﻳﻞ ﻣﻲ ﺩﻫﻴﻢ‬
‫;‪Z:=M*M‬‬ ‫ﺑﺎﻳﺪ ﻫﻤﺨﻮﺍﻧﻲ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﺩﺭ ﻏﻴﺮ ﺻﻮﺭﺕ ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﺩﺭ ﺯﻣﺎﻥ ﺗﺮﺟﻤﻪ ﺻﺎﺩﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫;)‪Writreln(Z,H‬‬
‫;)’*’(‪Writeln‬‬ ‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺍﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ ﺍﺑﺘﺪﺍ ﺑﻠﻮﻙ ﺍﺻﻠﻲ ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ ﻳﻌﻨﻲ ;‪H:=6‬‬
‫;‪End‬‬ ‫ﻭ ;)’@’(‪ Writeln‬ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﻧﺪ ﺳﭙﺲ ﺑﺎ ﻓﺮﺍﺧﻮﺍﻧﻲ ﭘﺮﻭﺳﻴﺠﺮ ﺑﻪ ﺩﺍﺧﻞ ﺑﻼﻙ‬
‫‪Begin‬‬ ‫ﺩﺳﺘﻮﺭﺍﺕ ﭘﺮﻭﺳﻴﺠﺮ ‪ Power‬ﻣﻲ ﺭﻭﻳﻢ ﻭ ﺩﺳﺘﻮﺭ ;‪ Z:=M*M‬ﻭ ;)‪ Writeln(Z,H‬ﻭ‬
‫;‪H:=6‬‬
‫;)’*’(‪ Writeln‬ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﻧﺪ ﺑﺎ ﺭﺳﻴﺪﻥ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﺑﻼﻙ ﭘﺮﻭﺳﻴﺠﺮ ﺑﻪ ﺑﻼﻙ ﺍﺻﻠﻲ‬
‫;)’@’(‪Writeln‬‬
‫;)‪Power(H‬‬ ‫ﺑﺎﺯﻣﻲ ﮔﺮﺩﺩ ﻭ ﺩﺳﺘﻮﺭ ;)’‪ Writeln(’$‬ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ ﻭ ﺑﺮﻧﺎﻣﻪ ﺧﺎﺗﻤﻪ ﻣﻲ ﻳﺎﺑﺪ‪.‬‬
‫;)’‪Writeln(’$‬‬ ‫ﺩﻗﺖ ﻛﻨﻴﺪ ﻛﻪ ﺗﺎ ﺯﻣﺎﻧﻲ ﻛﻪ ﭘﺮﺩﺍﺯﻩ ﺭﺍ ﺻﺪﺍ ﻧﻜﻨﻴﻢ ﭘﺮﺩﺍﺯﻩ ﺍﺟﺮﺍ ﻧﻤﻲ ﺷﻮﺩ‪.‬‬
‫‪End.‬‬
‫ﺩﺭ ﻣﻮﺭﺩ ﻣﺘﻐﻴﺮ ‪ Z‬ﺑﺎﻳﺪ ﮔﻔﺖ ﻛﻪ ﺍﻳﻦ ﻣﺘﻐﻴﺮ ﻳﻚ ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ ﺍﺳﺖ ﻳﻌﻨﻲ ﻓﻘﻂ ﺩﺭ ﺑﻼﻙ ﻣﺮﺑﻮﻁ ﺑﻪ ﭘﺮﻭﺳﻴﺠﺮ ‪ Power‬ﻗﺎﺑﻞ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺳﺖ‪.‬‬
‫ﺍﮔﺮ ﺍﻳﻦ ﻣﺘﻐﻴﺮ ﺭﺍ ﺩﺭ ﺑﻼﻙ ﺍﺻﻠﻲ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﻢ ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﺻﺎﺩﺭ ﻣﻲ ﺷﻮﺩ‪ ).‬ﺩﺭ ﺯﻣﺎﻥ ﺗﺮﺟﻤﻪ( ﻋﻤﺮ ﻣﺘﻐﻴﺮﻫﺎﻱ ﻣﺤﻠﻲ ﺍﺯ ﺯﻣﺎﻧﻲ ﺁﻏﺎﺯ ﻣﻲ ﺷﻮﺩ‬
‫ﻛﻪ ﺩﺳﺘﻮﺭ ﺻﺪﺍﺯﺩﻥ ﭘﺮﻭﺳﻴﺠﺮ ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ ﻭ ﺯﻣﺎﻧﻲ ﻋﻤﺮ ﺁﻧﻬﺎ ﺑﻪ ﭘﺎﻳﺎﻥ ﻣﻲ ﺭﺳﺪ ﻛﻪ ﺍﺟﺮﺍﻱ ﭘﺮﻭﺳﻴﺠﺮ ﺑﻪ ﭘﺎﻳﺎﻥ ﺑﺮﺳﺪ ﻭ ﺑﻪ ﻣﺤﻞ ﺻﺪﺍ ﺯﺩﻥ‬
‫ﺁﻥ ﺑﺮﮔﺮﺩﻳﻢ‪.‬‬
‫ﺍﻣﺎ ﺩﺭ ﻣﻮﺭﺩ ﻣﺘﻐﻴﺮ ‪ H‬ﺑﺎﻳﺪ ﮔﻔﺖ ﻛﻪ ﺍﻳﻦ ﻣﺘﻐﻴﺮ ﻳﻚ ﻣﺘﻐﻴﺮ ﺳﺮﺍﺳﺮﻱ ﺍﺳﺖ ﻳﻌﻨﻲ ﺩﺭ ﻫﻤﻪ ﺟﺎﻱ ﺑﺮﻧﺎﻣﻪ ﻗﺎﺑﻞ ﺩﺳﺘﺮﺳﻲ ﺍﺳﺖ‪ .‬ﻋﻤﺮ ﻣﺘﻐﻴﺮﻫﺎﻱ‬
‫ﺳﺮﺍﺳﺮﻱ ﺍﺯ ﺯﻣﺎﻥ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺷﺮﻭﻉ ﻣﻲ ﺷﻮﺩ ﻭ ﺗﺎ ﺯﻣﺎﻧﻲ ﻛﻪ ﺑﺮﻧﺎﻣﻪ ﭘﺎﻳﺎﻥ ﻳﺎﺑﺪ ﺍﺩﺍﻣﻪ ﺩﺍﺭﺩ‪.‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﻣﺪﺕ ﻋﻤﺮ ﺁﻧﻬـﺎ‪ ،‬ﻣـﺪﺕ ﺯﻣـﺎﻥ ﺍﺟـﺮﺍﻱ‬
‫ﺑﺮﻧﺎﻣﻪ ﺍﺳﺖ ﻭ ﻃﻮﻻﻧﻲ ﺍﺳﺖ‪ .‬ﻣﺜﻼ ﻣﺘﻐﻴﺮ ‪ H‬ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺩﺭ ﺑﻼﻙ ﺍﺻﻠﻲ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ ﻭ ﺩﺭ ﭘﺮﺩﺍﺯﺓ ‪ Power‬ﻧﻴﺰ ﻣﻲ ﺗﻮﺍﻧﺪ ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ‪.‬‬

‫ﻧﻜﺘﻪ( ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻭﺭﻭﺩﻱ ﻧﻴﺰ ﻣﺎﻧﻨﺪ ﻣﺘﻐﻴﺮﻫﺎﻱ ﻣﺤﻠﻲ ﻫﺴﺘﻨﺪ ﻭ ﻣﺪﺕ ﻋﻤﺮ ﺁﻧﻬﺎ ﺑﻪ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﭘﺮﻭﺳﻴﺠﺮ ﺑﺴﺘﮕﻲ ﺩﺍﺭﺩ ﻳﻌﻨـﻲ ﻭﻗﺘـﻲ‬
‫ﭘﺮﻭﺳﻴﺠﺮ ﺍﺟﺮﺍﻳﺶ ﺗﻤﺎﻡ ﻣﻲ ﺷﻮﺩ ﻋﻤﺮ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻭﺭﻭﺩﻱ ﻧﻴﺰ ﺗﻤﺎﻡ ﻣﻲ ﺷﻮﺩ‪ .‬ﺩﺭ ﻣﺜﺎﻝ ﺑﺎﻻ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ‪ M‬ﻓﻘﻂ ﺩﺭ ﺑﻼﻙ ﭘﺮﻭﺳﻴﺠﺮ ﻗﺎﺑـﻞ‬
‫ﺍﺳﺘﻔﺎﺩﻩ ﺍﺳﺖ‪.‬‬
‫ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﭘﺎﺭﺍﻣﺘﺮﻫﺎ ﺑﻪ ﺩﻭ ﺩﺳﺘﻪ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ‪:‬‬
‫‪ - ١‬ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻣﺠﺎﺯﻱ ﯾﺎ ﺻﻮري)ﻇﺎﻫﺮﻱ( )‪(Formal parameters‬‬
‫)‪(Actual parameters‬‬ ‫‪ - ٢‬ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻭﺍﻗﻌﻲ)ﺣﻘﻴﻘﻲ(‬

‫ﺑﻪ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻳﻲ ﻛﻪ ﻫﻨﮕﺎﻡ ﺗﻌﺮﻳﻒ ﭘﺮﻭﺳﻴﺠﺮ ﻣﻮﺭﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﻧﺪ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺠﺎﺯﻱ ﻣﻲ ﮔﻮﻳﻨﺪ‪ .‬ﺑﻪ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻳﻲ ﻛﻪ ﻫﻨﮕﺎﻡ ﻓﺮﺍﺧﻮﺍﻧﻲ‬
‫ﭘﺮﻭﺳﻴﺠﺮ ﺗﺤﻮﻳﻞ ﭘﺮﻭﺳﻴﺠﺮ ﻣﻲ ﺷﻮﻧﺪ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻭﺍﻗﻌﻲ ﻣﻲ ﮔﻮﻳﻨﺪ‪ .‬ﺩﺭ ﺍﺯﺍﻱ ﻫﺮ ﭘﺎﺭﺍﻣﺘﺮﻣﺠﺎﺯﻱ ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺍﻗﻌﻲ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪.‬ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ‬
‫ﻣﺠﺎﺯﻱ ﺑﻪ ﺳﻪ ﺩﺳﺘﻪ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ‪:‬‬

‫‪ -1‬ﭘﺎراﻣﺘﺮﻫﺎي ﻣﻘﺪار)ارزﺷﯽ – ‪(value‬‬

‫‪ -2‬ﭘﺎراﻣﺘﺮﻫﺎي ﻣﺘﻐﯿﺮ)ﻣﺮﺟﻊ‪(Variable-‬‬
‫‪ -3‬ﭘﺎراﻣﺘﺮﻫﺎي ﺛﺎﺑﺖ)‪(const‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪52‬‬
‫ﭘﺎراﻣﺘـﺮ ﻣﻘـﺪار)‪ (Value‬ﯾﺎ ﭘﺎراﻣﺘﺮ ورودي)‪: (Call by Value‬‬
‫ﭘﺎﺭﺍﻣﺘﺮ ﻣﻘﺪﺍﺭ ﺑﻪ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻳﻲ ﮔﻔﺘﻪ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﻓﻘـﻂ ﻣﻲ ﺗﻮﺍﻥ ﺍﺯ ﺁﻧﻬﺎ ﺑﺮﺍﻱ ﺍﺭﺳﺎﻝ ﻣﻘﺎﺩﻳﺮ ﺑﻪ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ‪ .‬ﺑﻪ ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ‬
‫ﺑﺮﺍﻱ ﻭﺭﻭﺩ ﺩﺍﺩﻩ ﻫﺎ ﺑﻪ ﭘﺮﻭﺳﻴﺠﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﺍﮔﺮ ﺍﻳﻦ ﭘﺎﺭﺍﻣﺘﺮ )ﭘﺎﺭﺍﻣﺘﺮ ﻣﺠﺎﺯﻱ ﻣﻘﺪﺍﺭ( ﺗﻐﻴﻴﺮ ﻛﻨﺪ ﻫﻴﭻ ﺗﺎﺛﻴﺮﻱ ﺑـﺮ ﺭﻭﻱ ﭘـﺎﺭﺍﻣﺘﺮ ﻭﺍﻗﻌـﻲ‬
‫ﺁﻥ ﻧﺪﺍﺭﺩ‪ .‬ﻣﺜﺎﻝ‪:‬‬
‫;‪Var Z,K:Real‬‬
‫;)‪Procedure ADD(D:Real; Var N:Real‬‬ ‫ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﭘﺎﺭﺍﻣﺘﺮﻭﺭﻭﺩﻱ ‪ D‬ﺍﺯ ﻧﻮﻉ ‪ Value‬ﺍﺳﺖ ﻫﻨﮕﺎﻣﻲ ﻛﻪ‬
‫‪Begin‬‬ ‫ﭘﺮﻭﺳﻴﺠﺮ ‪ Add‬ﻓﺮﺍﺧﻮﺍﻧﻲ ﻣﻲ ﺷﻮﺩ ﻣﻘﺪﺍﺭ ‪ K‬ﻭﺍﺭﺩ ‪ D‬ﻣﻲ ﺷﻮﺩ ﻭ‬
‫;‪D:=D+2‬‬ ‫ﭼﻮﻥ ‪ D‬ﺍﺯ ﻣﻘﺪﺍﺭ)‪ (Value‬ﺍﺳﺖ ﺗﻐﻴﻴﺮﺍﺕ ‪ D‬ﻫﻴﭻ ﺗﺎﺛﻴﺮﻱ ﺑﺮ ﺭﻭﻱ ‪K‬‬
‫;‪N:=N+5‬‬
‫ﻧﺪﺍﺭﺩ‪ .‬ﺍﻣﺎ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺠﺎﺯﻱ ‪ N‬ﺍﺯ ﻧﻮﻉ ﻣﺘﻐﻴﺮ)‪ (Variable‬ﺍﺳﺖ‪ .‬ﻛﻪ‬
‫;)‪Writeln(D+N‬‬
‫;‪End‬‬ ‫ﺑﺤﺚ ﺧﻮﺍﻫﺪ ﺷﺪ‪ .‬ﺩﺭ ﺍﻳﻦ ﺑﺮﻧﺎﻣﻪ ﻣﻘﺪﺍﺭ ‪ K‬ﺍﺑﺘﺪﺍ ‪ 14‬ﺍﺳﺖ ﻭ ﻫﻨﮕﺎﻣﻲ ﻛﻪ‬
‫‪Begin‬‬ ‫ﭘﺮﻭﺳﻴﺠﺮ ‪ Add‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﻫﻤﭽﻨﺎﻧﭽﻪ ‪ 14‬ﻣﻲ ﻣﺎﻧﺪ‪.‬‬
‫;‪K:=14; Z:=25‬‬ ‫ﭘﺎﺭﺍﻣﺘﺮ ﻭﺍﻗﻌﻲ ﻣﺮﺑﻮﻁ ﺑﻪ ﺍﻳﻦ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺠﺎﺯﻱ ﻣﻲ ﺗﻮﺍﻧﺪ ﺛﺎﺑﺖ ﻳﺎ ﻣﺘﻐﻴﺮ ﻳﺎ‬
‫;)‪ADD(K,Z‬‬
‫;)‪Writeln(K,Z‬‬ ‫ﻳﻚ ﻋﺒﺎﺭﺕ ﺑﺎﺷﺪ‪ .‬ﻣﺜﻼ ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ﻫﻨﮕﺎﻡ ﻓﺮﺍﺧﻮﺍﻧﻲ ‪ ADD‬ﻣﻲ ﺗﻮﺍﻥ‬
‫‪End.‬‬ ‫ﻋﺒﺎﺭﺕ ;)‪ Add(K*3,Z‬ﺭﺍ ﻗﺮﺍﺭ ﺩﺍﺩ‪.‬‬

‫ﺗﻤﺮﯾﻦ ( ﻣﺸﺨﺺ ﮐﻨﯿﺪ ﮐﻪ ﺑﺎ اﺟﺮاي ﺑﺮﻧﺎﻣﻪ زﯾﺮ ﺑﺮاي دﺳﺘﻮرﻫﺎي ‪ Writeln‬ﭼﻪ اﻋﺪادي در ﺧﺮوﺟﯽ ﭼﺎپ ﻣﯽ ﺷﻮﻧﺪ؟‬

‫;‪program ex1‬‬ ‫راﻫﻨﻤﺎﯾﯽ ‪ :‬ﺑﺮاي ﺟﻮاب دادن ﺑﻪ اﯾﻨﮕﻮﻧﻪ ﺳﻮاﻟﻬﺎ اﺑﺘﺪا ﺟﺪوﻟﯽ ﻣﻄﺎﺑﻖ‬
‫ﺟﺪول زﯾﺮ رﺳﻢ ﻣﯽ ﻧﻤﺎﯾﯿﻢ و ﺳﭙﺲ ﺑﺎ ﻣﻘﺪار دﻫﯽ ﻣﺘﻐﯿﺮﻫﺎ ﺑﻪ راﺣﺘﯽ و‬
‫‪var‬‬
‫;‪x,k:integer‬‬
‫;)‪procedure test(m:integer;n:integer‬‬ ‫ﺑﺎ ﮐﻤﺘﺮﯾﻦ اﺷﺘﺒﺎه ﭘﺎﺳﺦ ﺻﺤﯿﺢ را ﺑﺪﺳﺖ ﻣﯽ آورﯾﻢ ‪:‬‬
‫‪var‬‬
‫;‪z:integer‬‬
‫‪begin‬‬ ‫ﺳﺮاﺳﺮي‬ ‫ﺳﺮاﺳﺮي‬ ‫ﻣﺤﻠﯽ‬ ‫ﻣﺤﻠﯽ‬ ‫ﻣﺤﻠﯽ‬
‫;‪z:=m+n‬‬
‫;‪m:=m+2‬‬
‫‪x‬‬ ‫‪k‬‬ ‫‪m‬‬ ‫‪n‬‬ ‫‪z‬‬
‫;‪n:=n+7‬‬ ‫‪12‬‬ ‫‪50‬‬ ‫‪12‬‬ ‫‪50‬‬ ‫‪62‬‬
‫;‪x:=x+1‬‬ ‫‪13‬‬ ‫‪14‬‬ ‫‪57‬‬
‫;)‪writeln(x,m,n‬‬
‫;‪end‬‬
‫‪begin‬‬
‫ﻫﻤﺎن ﻃﻮر ﮐﻪ ﻣﺸﺎﻫﺪه ﻣﯽ ﮐﻨﯿﺪ ﺑﺎ اﺟﺮاي ﺑﺮﻧﺎﻣﻪ روﺑـﺮو در دﺳـﺘﻮر‬
‫;‪x:=12‬‬
‫;‪k:=50‬‬ ‫‪ Writeln‬داﺧﻞ ﭘﺮوﺳﯿﺠﺮ ﺑﺮاي ﻣﺘﻐﯿﺮﻫﺎي ‪x‬و‪m‬و‪ n‬ﺑﻪ ﺗﺮﺗﯿﺐ اﻋـﺪاد‬
‫;)‪test(x,k‬‬
‫‪ 13‬و ‪ 14‬و ‪ 57‬وﺑﺮاي دﺳﺘﻮر ‪ Writeln‬داﺧﻞ ﺑﻼك اﺻـﻠﯽ ﺑﺮﻧﺎﻣـﻪ‬
‫;)‪writeln(x,k‬‬
‫‪end.‬‬ ‫ﺑﺮاي ﻣﺘﻐﯿﺮﻫﺎي ‪x‬و‪ k‬ﺑﻪ ﺗﺮﺗﯿﺐ اﻋﺪاد ‪ 13‬و ‪ 50‬ﭼﺎپ ﻣﯽ ﺷﻮد‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪53‬‬
‫ﺗﻤﺮﯾﻦ ( ﻣﺸﺨﺺ ﮐﻨﯿﺪ ﮐﻪ ﺑﺎ اﺟﺮاي ﺑﺮﻧﺎﻣﻪ زﯾﺮ ﺑﺮاي دﺳﺘﻮرﻫﺎي ‪ Writeln‬ﭼﻪ اﻋﺪادي در ﺧﺮوﺟﯽ ﭼﺎپ ﻣﯽ ﺷﻮﻧﺪ؟‬

‫رﺳﻢ ﺟﺪول ‪:‬‬

‫;‪program ex2‬‬
‫‪var‬‬
‫;‪x,k:integer‬‬ ‫ﺳﺮاﺳﺮي‬ ‫ﻣﺤﻠﯽ‬ ‫ﺳﺮاﺳﺮي‬ ‫ﻣﺤﻠﯽ‬ ‫ﻣﺤﻠﯽ‬
‫;)‪procedure test(m:integer;k:integer‬‬
‫‪var‬‬ ‫‪x‬‬ ‫'‪x‬‬ ‫‪k‬‬ ‫‪m‬‬ ‫'‪k=k‬ﻣﺤﻠﯽ‬
‫;‪x:integer‬‬
‫‪begin‬‬ ‫‪12‬‬ ‫‪62‬‬ ‫‪50‬‬ ‫‪12‬‬ ‫‪50‬‬
‫;‪x:=m+k‬‬ ‫‪63‬‬ ‫‪14‬‬ ‫‪57‬‬
‫;‪m:=m+2‬‬
‫;‪k:=k+7‬‬
‫;‪x:=x+1‬‬ ‫ﺣﺎل ﺷﻤﺎ ﻣﺸﺨﺺ ﮐﻨﯿﺪ ﮐﻪ ﺑﺎ اﺟﺮاي اﯾﻦ ﺑﺮﻧﺎﻣﻪ ﭼﻪ اﻋﺪادي ﺑـﺮاي‬
‫;)‪writeln(x,m,k‬‬
‫;‪end‬‬ ‫دو دﺳﺘﻮر ‪ Writeln‬در ﺧﺮوﺟﯽ ﭼﺎپ ﺧﻮاﻫﺪ ﺷﺪ؟‬
‫‪begin‬‬
‫;‪x:=12‬‬ ‫;)‪writeln(x,m,k‬‬ ‫‪…………………….‬‬
‫;‪k:=50‬‬
‫;)‪test(x,k‬‬ ‫;)‪writeln(x,k‬‬ ‫‪…………………….‬‬
‫;)‪writeln(x,k‬‬
‫‪end.‬‬

‫ﭘﺎراﻣﺘـﺮ ﻣﺘﻐﯿـﺮ)‪ (Variable‬ﯾﺎ ﻣﺮﺟـﻊ)‪: (Call by Reference‬‬

‫ﺍﻳﻦ ﭘﺎﺭﺍﻣﺘﺮ ﺑﺮﺍﻱ ﺩﺭﻳﺎﻓﺖ ﻭ ﺍﺭﺳﺎﻝ ﻣﻘﺎﺩﻳﺮ ﺑﻪ ﭘﺮﻭﺳﻴﺠﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ ﻳﻌﻨﻲ ﻫﻢ ﺑﺮﺍﻱ ﻭﺭﻭﺩﻱ ﺩﺍﺩﻩ ﻫﺎ ﺑﻪ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ ﻭ‬
‫ﻫﻢ ﺑﺮﺍﻱ ﺩﺭﻳﺎﻓﺖ ﺩﺍﺩﻩ ﺍﺯ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ‪ .‬ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺑﻪ ﺍﻳﻦ ﭘﺎﺭﺍﻣﺘﺮﻫﺎ‪ ،‬ﭘﺎﺭﺍﻣﺘﺮ ﺧﺮﻭﺟﻲ ﻧﻴﺰ ﻣﻲ ﮔﻮﻳﻨﺪ‪ .‬ﻧﺸﺎﻧﺔ ﭘﺎﺭﺍﻣﺘﺮﺧﺮﻭﺟﻲ ﻭﺟﻮﺩ ﻛﻠﻤﺔ‬
‫‪ Var‬ﻗﺒﻞ ﺍﺯ ﻧﺎﻡ ﭘﺎﺭﺍﻣﺘﺮ ﺩﺭ ﺧﻂ ﻋﻨﻮﺍﻥ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺍﺳﺖ‪ .‬ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺮﺟﻊ )ﺧﺮﻭﺟﻲ( ﺩﺭ ﺑﺪﻧﺔ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﻣﻲ ﻛﻨﺪ ﺗﻐﻴﻴﺮﺍﺕ ﺁﻥ‬
‫ﺩﺭ ﭘﺎﺭﺍﻣﺘﺮﻭﺍﻗﻌﻲ ﺁﻥ ﺍﻋﻤﺎﻝ ﻣﻲ ﺷﻮﺩ‪ .‬ﻣﻲ ﺗﻮﺍﻥ ﮔﻔﺖ ﻛﻪ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺮﺟﻊ ﻭ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺍﻗﻌﻲ ﺁﻥ ﻳﻚ ﻣﺤﻞ ﺩﺭ ﺣﺎﻓﻈﻪ ﻫﺴﺘﻨﺪ ﺑﺎ ﺩﻭ ﻧﺎﻡ‪.‬‬
‫ﺩﺭ ﻣﺜﺎﻝ ﺻﻔﺤﻪ ﻗﺒﻞ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺠﺎﺯﻱ ‪ N‬ﺍﺯ ﻧﻮﻉ ﻣﺮﺟﻊ ﺍﺳﺖ ﻛﻪ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺍﻗﻌﻲ ﺁﻥ ‪ Z‬ﺍﺳﺖ‪ Z .‬ﻣﻘﺪﺍﺭ ‪ 25‬ﺭﺍ ﺗﺤﻮﻳـﻞ ‪ N‬ﻣـﻲ ﺩﻫـﺪ ﺳـﭙﺲ ﺩﺭ‬
‫ﺑﺪﻧﻪ ﭘﺮﻭﺳﻴﺠﺮ ;‪ N:=N+5‬ﺍﺟﺮﺍ ﻣﻲ ﺷﻮﺩ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ‪ N‬ﻣﺴﺎﻭﻱ ‪ 30‬ﻣـﻲ ﺷـﻮﺩ ﻭ ﭼـﻮﻥ ﻳـﻚ ﭘـﺎﺭﺍﻣﺘﺮ ﻣﺮﺟـﻊ ﺍﺳـﺖ ‪ Z‬ﻧﻴـﺰ ‪ 30‬ﻣـﻲ‬
‫ﺷﻮﺩ‪.‬ﻭﻗﺘﻲ ﭘﺮﻭﺳﻴﺠﺮ ﺗﻤﺎﻡ ﻣﻲ ﺷﻮﺩ ‪ Z‬ﻣﺴﺎﻭﻱ ‪ 30‬ﺷﺪﻩ ﺍﺳﺖ‪.‬‬
‫ﻧﻜﺘﻪ( ﭘﺎﺭﺍﻣﺘﺮ ﻭﺍﻗﻌﻲ ﻣﺮﺑﻮﻁ ﺑﻪ ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺠﺎﺯﻱ ﻣﺮﺟﻊ)ﻣﺘﻐﻴﺮ( ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﻳﻚ ﻣﺘﻐﻴﺮ)ﯾﺎﺛﺎﺑﺖ ﺑﺎ ﻧﻮﻉ( ﺑﺎﺷﺪ ﺩﺭ ﻏﻴﺮ ﺍﻳﻦ ﺻﻮﺭﺕ ﺧﻄﺎ‬
‫ﺍﺳﺖ‪ .‬ﻣﺜﻼ ﺩﺭ ﻣﺜﺎﻝ ﻗﺒﻠﻲ ﻧﻤﻲ ﺗﻮﺍﻥ ﺑﺠﺎﻱ ;)‪ ADD(K,Z‬ﺩﺳﺘﻮﺭ;)‪ ADD(K,Z*4‬ﺭﺍ ﻧﻮﺷﺖ‪.‬‬

‫ﻣﺘﻐﻴﺮ ‪ K‬ﺩﺭ ﺑﻼﻙ ﺍﺻﻠﻲ‬ ‫ﻣﺘﻐﻴﺮ‪ D‬ﺩﺭ ﺑﻼﻙ ﻓﺮﻋﻲ‬

‫ﻣﺘﻐﻴﺮ ‪ Z‬ﺩﺭ ﺑﻼﻙ ﺍﺻﻠﻲ‬ ‫ﻣﺘﻐﻴﺮ ‪ N‬ﺩﺭ ﺑﻼﻙ ﻓﺮﻋﻲ ﻳﺎ ﻫﻤﺎﻥ‪Z‬‬

 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪54‬‬
‫ﺗﻤﺮﯾﻦ ( ﻣﺸﺨﺺ ﮐﻨﯿﺪ ﮐﻪ ﺑﺎ اﺟﺮاي ﺑﺮﻧﺎﻣﻪ زﯾﺮ ﺑﺮاي دﺳﺘﻮرﻫﺎي ‪ Writeln‬ﭼﻪ اﻋﺪادي در ﺧﺮوﺟﯽ ﭼﺎپ ﻣﯽ ﺷﻮﻧﺪ؟‬

‫;‪program T‬‬ ‫رﺳﻢ ﺟﺪول ‪:‬‬

‫‪var‬‬
‫;‪x,k:integer‬‬ ‫‪-‬‬ ‫ﺳﺮاﺳﺮي‬ ‫ﻣﺤﻠﯽ‬
‫;)‪proceduretest(var m:integer;k:integer‬‬
‫‪) m‬ﻣﺮﺟﻊ(‬ ‫‪k‬‬
‫‪begin‬‬ ‫'‪k=k‬ﻣﺤﻠﯽ‬
‫;‪m:=m+1‬‬ ‫‪x‬‬
‫;‪x:=x+4‬‬
‫;‪k:=k+7‬‬ ‫‪20‬‬ ‫‪8‬‬ ‫‪8‬‬
‫;)‪writeln(x,m,k‬‬ ‫‪21‬‬ ‫‪15‬‬
‫;‪end‬‬
‫‪begin‬‬ ‫‪25‬‬
‫;‪x:=20‬‬
‫;‪k:=8‬‬
‫;)‪test(x,k‬‬ ‫;)‪writeln(x,m,k‬‬ ‫‪…………………….‬‬
‫;)‪writeln(x,k‬‬
‫;)‪writeln(x,k‬‬ ‫‪…………………….‬‬
‫‪end.‬‬

‫ﭘﺎراﻣﺘـﺮﺛﺎﺑﺖ)‪:(Const‬‬
‫ﺍﻳﻦ ﭘﺎﺭﺍﻣﺘﺮﻫﺎ ﻣﺎﻧﻨﺪ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻣﺮﺟﻊ ﻫﺴﺘﻨﺪ ﺑﺎ ﺍﻳﻦ ﺗﻔﺎﻭﺕ ﻛﻪ ﻣﻘﺪﺍﺭ ﭘﺎﺭﺍﻣﺘﺮ ﺛﺎﺑﺖ ﺭﺍ ﺩﺭ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻧﻤﻲ ﺗﻮﺍﻥ ﺗﻐﻴﻴﺮ ﺩﺍﺩ‪ .‬ﺑـﺮﺍﻱ‬
‫ﺷﻨﺎﺳﺎﻳﻲ ﺍﻳﻦ ﭘﺎﺭﻣﺘﺮﻫﺎ ﺍﺯ ﻛﻠﻤﺔ‪ Const‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﺍﮔﺮ ﻣﻘﺪﺍﺭ ﺁﻥ ﺭﺍ ﺩﺭ ﺑﺪﻧﺔ ﺑﻼﻙ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﺩﻫﻴﻢ ﺩﺭ ﺯﻣﺎﻥ ﺗﺮﺟﻤـﻪ ﺧﻄـﺎ ﺭﺥ‬
‫ﻣﻲ ﺩﻫﺪ‪.‬‬
‫;‪program T‬‬
‫‪var‬‬ ‫ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﭘﺎﺭﺍﻣﺘﺮ ‪ w‬ﺍﺯ ﻧﻮﻉ ﺛﺎﺑﺖ ﺍﺳﺖ ﻭ‬
‫;‪x:integer‬‬ ‫ﻧﻤﻲ ﺗﻮﺍﻥ ﻣﻘﺪﺍﺭ ‪ w‬ﺭﺍ ﺩﺭ ﺑﺪﻧﺔ ﭘﺮﻭﺳﻴﺠﺮ ‪ test‬ﺗﻐﻴﻴﺮ ﺩﺍﺩ‪.‬‬
‫;)‪procedure test(const w:integer‬‬
‫‪begin‬‬
‫;‪w:=w+1‬‬ ‫ﻧﻜﺘﻪ( ﭘﺎﺭﺍﻣﺘﺮ ﻭﺍﻗﻌﻲ ﻣﺮﺑﻮﻁ ﺑﻪ ﭘﺎﺭﺍﻣﺘﺮﺛﺎﺑﺖ ﻣﻲ ﺗﻮﺍﻧﺪ‬
‫;)‪writeln(w‬‬ ‫ﻣﺘﻐﻴﺮﺛﺎﺑﺖ ﻳﺎ ﻋﺒﺎﺭﺕ ﺑﺎﺷﺪ‪.‬‬
‫;‪end‬‬
‫ﻣﺘﻐﻴﺮ ‪ w‬ﻣﺤﻠﻲ ﺍﺳﺖ ﻭ ﻣﺘﻐﻴﺮ ‪ x‬ﺳﺮﺍﺳﺮﻱ ﻫﺴﺖ‪.‬‬
‫‪begin‬‬
‫;‪x:=20‬‬
‫;)‪test(x‬‬
‫;)‪writeln(x‬‬
‫‪end.‬‬

‫ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫;)‪Procedure M(Var x,y:Integer ; Z:Integer‬‬
‫‪Begin‬‬ ‫ﻧﻜﺘﻪ( ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﻣﺘﻐﻴﺮﻫﺎﻱ ‪ A,B,C‬ﺳﺮﺍﺳﺮﻱ ﻧﻴﺴﺘﻨﺪ ﺯﻳﺮﺍ‬
‫;‪X:=X-Y*2‬‬ ‫ﺍﻳﻦ ﻣﺘﻐﻴﺮﻫﺎ ﺩﺭ ﭘﺎﻳﻴﻦ ﭘﺮﻭﺳﻴﺠﺮ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺍﻧﺪ‪ .‬ﺍﻳﻦ ﻣﺘﻐﻴﺮﻫﺎﻱ‬
‫;‪X:=X div Y Mod X‬‬
‫;‪Z:=X+Y‬‬ ‫ﻣﺤﻠﻲ ﻫﺴﺘﻨﺪ ﻭ ﻣﻨﻄﻘﻪ ﻗﺎﺑﻞ ﺍﺳﺘﻔﺎﺩﻩ ﺁﻧﻬﺎ ﺩﺭ ﺑﻼﻙ ﺍﺻﻠﻲ ﺑﺮﻧﺎﻣﻪ ﺍﺳﺖ‪.‬‬
‫;‪End‬‬
‫‪Var‬‬ ‫ﻧﻜﺘﻪ(‬
‫;‪A,B,C:Integer‬‬
‫‪Begin‬‬ ‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺗﻌﺪﺍﺩ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻣﺠﺎﺯﻱ ﺑﻴﺸﺘﺮ ﺍﺯ ﻳﻜﻲ ﺑﺎﺷﺪ‬
‫;‪A:=2; B:=8; C:=6‬‬ ‫ﺑﻴﻦ ﺁﻧﻬﺎ ; ﻗﺮﺍﺭ ﻣﻲ ﺩﻫﻴﻢ‪.‬‬
‫;)‪M(B,A,C‬‬
‫;)‪Write(A, B , C‬‬
‫‪End.‬‬
 55 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
‫ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬
Var
M:Integer; H:Byte;
Procedure AVG(Var A:Byte);
Begin
M:=M+3;
Write(H);
A:=A-2;
Write(H);
End;
Procedure FK(M:integer);
Begin
Write(’*’);
AVG(H);
M:=M+8;
End;
Begin
M:=2; H:=10;
FK(M);
Write(H,M);
AVG(H);
Write(H,M);
End.
‫ ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﻣﺠﻤﻮع و ﻣﯿﺎﻧﮕﯿﻦ دو ﻋﺪد را ﻣﺤﺎﺳﺒﻪ و ﻧﺘﯿﺠﻪ را در ﺑﺮﻧﺎﻣـﻪ اﺻـﻠﯽ‬ComputeSumAve ‫ﻣﺜﺎل ( ﭘﺮوﺳﯿﺠﺮي ﺑﻨﺎم‬
.‫ﭼﺎپ ﻧﻤﺎﯾﺪ‬
Var
Num1,Num2:integer;
Total,Average:Real;
Procedure ComputeSumAve(Num1,Num2:integer; Var sum,ave:Real);
Begin
Sum:=Num1+Num2;
Ave:=sum/2;
End;
Begin
Readln(Num1,Num2);
ComputeSumAve(Num1,Num2,Total,Average);
Writeln('The Sum is= ' , Total:8:2,'The Average is= ', Average:8:2);
Readln;
End.

‫ﭘﺲ ﺍﺯ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﺧﺮﻭﺟﻲ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬:‫ﺗﺴﺖ‬

Var A:integer; 10 (‫ﺝ‬ 25 (‫ﺏ‬ 25(‫ﺍﻟﻒ‬
Procedure PK(m,n:integer); 25 10 20
Begin writeln(m+n);
‫ﺩ( ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﺩﺍﺭﺩ‬
A:=10;
End;
Begin A:=20;
PK(A,5);
Writeln(A);
End.
 56 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
Const X:integer=2; ‫ ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬:‫ﺗﺴﺖ‬
Y:integer=3; 2 6(‫ﺏ‬ 2 3(‫ﺍﻟﻒ‬
Procedure K(X:Integer;Var Y:Integer); 6 3 (‫ﺩ‬ 6 2(‫ﺝ‬
Begin
X:=X+Y;
Y:=X-Y;
Y:=Y*3;
End;
Begin
K(X,Y);
Write( X,Y);
End.
Const X:Byte=2;
Procedure P(X:byte); ‫ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬:‫ﺗﺴﺖ‬
Begin
X:=X+7; 2(‫ﺏ‬ 9 (‫ﺍﻟﻒ‬
End; ‫ﺩ(ﭘﻴﻐﺎﻡ ﺧﻄﺎ‬ 7(‫ﺝ‬
Begin
Write(P(X)); End.

: ‫ رادرﯾﺎﻓﺖ ﮐﻨﺪ و ﺳﭙﺲ ﻣﯿﺎﻧﮕﯿﻦ ﻫﻤﺎﻫﻨﮓ آﻧﺮا ﺣﺴﺎب ﮐﻨﺪ‬y‫و‬x ‫ﻣﺜﺎل ( ﺑﺮﻧﺎﻣﻪ ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ اﺑﺘﺪا دو ﻋﺪد ﻣﺜﺒﺖ‬

procedure magh(n:integer ; var m:integer); ‫ را ﺑـﺎ‬x ‫ ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ﻣﯿﺎﻧﮕﯿﻦ ﻫﻤﺎﻫﻨـﮓ ﻣﻘﻠـﻮب‬: ‫ﺗﻮﺿﯿﺢ‬
begin
m:=0; ‫ ﺣﺎﺻـﻞ را‬، ‫ ﺟﻤﻊ ﻣﯽ ﮐﻨﯿﻢ و ﺗﻘﺴﯿﻢ ﺑﺮ دو ﻣﯽ ﮐﻨﯿﻢ‬y ‫ﻣﻘﻠﻮب‬
while n>0 do .‫ﻋﺪد ﺑﺪﺳﺖ آﻣﺪه ﻣﯿﺎﻧﮕﯿﻦ ﻫﻤﺎﻫﻨﮓ اﺳﺖ‬. ‫ﻣﻘﻠﻮب ﻣﯽ ﮐﻨﯿﻢ‬
begin
m:=m*10 + n mod 10;
n:=n div 10;
end;
end;
procedure avgH(x,y:integer; var z:integer);
var
a,b,c:integer;
begin
magh(x,a);
magh(y,b);
c:=(a+b) div 2;
magh(c,z);
end;
var
h,x,y:integer;
begin
readln(x,y);
avgH(x,y,h);
writeln(h);
end.
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪57‬‬
‫ﺗﺎﺑـﻊ ﯾﺎ ﻓﺎﻧﮑﺸﻦ)‪:(Function‬‬
‫ﺗﻮﺍﺑﻊ ﻧﻮﻋﻲ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺴﺘﻨﺪ ﻭ ﻣﺎﻧﻨﺪ ﭘﺮﻭﺳﻴﺠﺮﻫﺎ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻭﺭﻭﺩﻱ ) ﺍﺯ ﻧﻮﻉ ﻣﺮﺟﻊ ﻳﺎ ﻣﻘﺪﺍﺭ ﻳﺎ ﺛﺎﺑﺖ( ﺩﺍﺭﻧﺪ‪ .‬ﺍﻣﺎ ﺗﺎﺑﻊ ﺣﺪﺍﻗﻞ ﻳﻚ ﺧﺮﻭﺟـﻲ‬
‫ﺩﺍﺭﺩ‪ .‬ﺩﺭ ﻣﻮﺍﺭﺩﻱ ﻛﻪ ﺣﺪﺍﻗﻞ ﺑﻪ ﻳﻚ ﺧﺮﻭﺟﻲ ﻧﻴﺎﺯ ﺩﺍﺭﻳﻢ ﺍﺯ ﺗﺎﺑﻊ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﺗﺎﺑﻊ ﺍﺯ ﻛﻠﻤﺔ ﺭﺯﺭﻭ ﺷﺪﺓ ‪ Function‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﻫﺮﺁﻧﭽﻪ ﺭﺍ ﻛﻪ ﺑـﺮﺍﻱ ﭘﺮﻭﺳـﻴﺠﺮﻫﺎ ﺑﺤـﺚ ﻛـﺮﺩﻳﻢ ﺑـﺮﺍﻱ ﺗـﺎﺑﻊ ﻫـﺎ ﻫـﻢ‬
‫ﻫﻤﺎﻧﻄﻮﺭ ﺍﺳﺖ‪ .‬ﺗﻨﻬﺎ ﺗﻔﺎﻭﺕ ﺗﺎﺑﻊ ﺑﺎ ﭘﺮﺩﺍﺯﻩ ﺩﺭ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺗﺎﺑﻊ ﺩﺍﺭﺍﻱ ﻳﻚ ﺧﺮﻭﺟﻲ ﺍﺳﺖ‪ .‬ﺷﻜﻞ ﻛﻠﻲ ﺗﻌﺮﻳﻒ ﺗﺎﺑﻊ‪:‬‬

‫; ﻧﻮﻉ ﺧﺮﻭﺟﻲ ﺗﺎﺑﻊ ‪ ) :‬ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻣﺠﺎﺯﻱ ﻭ ﻧﻮﻉ ﺁﻧﻬﺎ ( ﻧﺎﻡ ﺗﺎﺑﻊ ‪Function‬‬
‫ﺗﻌﺎﺭﻳﻒ ﻣﺮﺑﻮﻁ ﺑﻪ ﺗﺎﺑﻊ‬
‫‪Begin‬‬
‫ﺩﺳﺘﻮﺭﺍﺕ ‪……..‬‬
‫; ‪End‬‬
‫ﻧﻤﻮﻧﻪ ﻫﺎﯾﯽ از ﻋﻨـﻮان ﭼﻨﺪ ﺗﺎﺑﻊ ‪:‬‬
‫; ‪1)FUNCTION Menu : Integer‬‬
‫; ‪2)FUNCTION Test (r : Real):Real‬‬
‫;‪3)FUNCTION Test1 (x,y : Integer):Integer‬‬
‫;‪4)FUNCTION Test2 (x:integer ; VAR i:Integer):Boolean‬‬
‫ﺩﺭ ﺗﺎﺑﻊ ﺍﻭﻝ ﻧﺎﻡ ﺗﺎﺑﻊ ‪ Menu‬ﻣﯽ ﺑﺎﺷﺪ ﻭ ﺧﺮﻭﺟﯽ ﺁﻥ ﺍﺯﻧﻮﻉ ‪ Integer‬ﺍﺳﺖ‪.‬ﻳﻌﻨﯽ ﻳﮏ ﻋﺪﺩ ﺻﺤﻴﺢ ﺭﺍ ﺑﺮ ﻣﯽ ﮔﺮﺩﺍﻧﺪ‪.‬ﺗﺎﺑﻊ ﺩﻭﻡ ﻳﮏ ﭘـﺎﺭﺍﻣﺘﺮ‬
‫ﻭﺭﻭﺩﯼ ﺍﻋﺸﺎﺭﯼ ﺑﻨﺎﻡ ‪ r‬ﺩﺍﺭﺩ ﻭ ﺧﺮﻭﺟﯽ ﺁﻥ ﺍﺯ ﻧﻮﻉ ‪ Real‬ﺍﺳﺖ‪.‬ﻳﻌﻨﯽ ﻳﮏ ﻋﺪﺩ ﺍﻋﺸﺎﺭﯼ ﻭﺍﺭﺩ ﺁﻥ ﻣﯽ ﺷﻮﺩ ﻭ ﻳـﮏ ﻋـﺪﺩ ﺍﻋـﺸﺎﺭﯼ ﺍﺯ ﺁﻥ ﺧـﺎﺭﺝ‬
‫ﻣﯽ ﮔﺮﺩﺩ‪.‬ﺗﺎﺑﻊ ﺳﻮﻡ ﺩﻭ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﯼ ﺻﺤﻴﺢ ﺑﻨﺎﻣﻬـﺎﯼ ‪x‬ﻭ‪ y‬ﺩﺍﺭﺩ‪،‬ﻳﻌﻨـﯽ ﺩﻭ ﻋـﺪﺩ ﺻـﺤﻴﺢ ﻭﺍﺭﺩ ﺁﻥ ﻣـﯽ ﺷـﻮﺩ ﻭ ﺧﺮﻭﺟـﯽ ﺁﻥ ﻧﻴـﺰ ﺍﺯ ﻧـﻮﻉ‬
‫‪ Integer‬ﺍﺳﺖ ﻭ ﻳﮏ ﻋﺪﺩ ﺻﺤﻴﺢ ﺭﺍ ﺑﺮ ﻣﯽ ﮔﺮﺩﺍﻧﺪ‪ .‬ﺗﺎﺑﻊ ﭼﻬﺎﺭﻡ ﻳﮏ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﯼ ﺻـﺤﻴﺢ )‪ (x‬ﻭ ﺩﻭ ﺧﺮﻭﺟـﯽ ﺩﺍﺭﺩ ﮐـﻪ ﻳﮑـﯽ ﺍﺯ ﻃﺮﻳـﻖ‬
‫ﭘﺎﺭﺍﻣﺘﺮ ‪ i‬ﺍﺳﺖ ﻭﺍﺯﻃﺮﻳﻖ ﺁﻥ ﻳﮏ ﻋﺪﺩ ﺻﺤﻴﺢ ﺧﺎﺭﺝ ﻣﯽ ﮔﺮﺩﺩ ﻭ ﺩﻳﮕﺮﯼ ﺍﺯ ﻧﻮﻉ ﺑﻮﻟﯽ ﺍﺳﺖ ﮐﻪ ﻳﮑـﯽ ﺍﺯ ﺩﻭ ﻣﻘـﺪﺍﺭ ‪ True‬ﻳـﺎ ‪ False‬ﺑـﺮ ﻣـﯽ‬
‫ﮔﺮﺩﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﻧﺎﻡ ﺗﺎﺑﻊ ﺍﺯ ﻗﻮﺍﻧﻴﻦ ﻧﺎﻡ ﮔﺬﺍﺭﻱ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻏﻴﺮﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﭘﻴﺮﻭﻱ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﻧﺎﻡ ﺗﺎﺑﻊ ﻣﺎﻧﻨﺪ ﻳﻚ ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ ﺩﺭ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮﺍﻧﺪ ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ‪ .‬ﻣﻌﻤﻮﻻ ﺩﺭ ﺩﺍﺧﻞ ﺑﻼﻙ ﺗﺎﺑﻊ‪ ،‬ﺣﺪﺍﻗﻞ ﻳﻚ ﺩﺳـﺘﻮﺭ‬
‫ﺍﻧﺘﺴﺎﺏ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺑﺎﻳـﺪ ﺑﺎﺷﺪ‪ .‬ﺯﻳﺮﺍ ﻣﻘﺪﺍﺭﻱ ﺭﺍ ﻛﻪ ﺗﺎﺑﻊ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ ﺩﺭ ﻧﺎﻡ ﺗﺎﺑﻊ ﺭﻳﺨﺘﻪ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫; ﻣﻘﺪار ﺧﺮوﺟﯽ =‪ :‬ﻧﺎم ﺗﺎﺑﻊ‬

‫ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ‪ OE‬ﻳﻚ ﺗﺎﺑﻊ ﺍﺳﺖ ﻛﻪ ﺩﺍﺭﺍﻱ ﻳـﻚ ﭘـﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺍﺯ ﻧـﻮﻉ ﻣﺠـﺎﺯﻱ‬
‫;‪Var A:Integer‬‬
‫;‪Function OE(F:integer):Boolean‬‬ ‫ﻣﻘﺪﺍﺭ)‪ (Value‬ﺍﺳﺖ ﻭ ﺧﺮﻭﺟﻲ ﺁﻥ ﺍﺯ ﻧﻮﻉ ‪ Boolean‬ﺍﺳﺖ‪ .‬ﻣﺘﻐﻴـﺮ ‪ Z‬ﻳـﻚ ﻣﺘﻐﻴـﺮ‬
‫‪Var‬‬ ‫ﻣﺤﻠﻲ ﺍﺳﺖ ﻭ ﻣﺘﻐﻴﺮ ‪ A‬ﻳﻚ ﻣﺘﻐﻴﺮ ﺳﺮﺍﺳﺮﻱ ﺍﺳﺖ ﻭ ﻫﻤﻪ ﺑﺤﺚ ﻫـﺎﻳﻲ ﻛـﻪ ﺩﺭ ﻣـﻮﺭﺩ‬
‫;‪Z:Real‬‬ ‫ﻣﺘﻐﻴﺮﻫﺎﻱ ﻣﺤﻠﻲ ﻭ ﺳﺮﺍﺳﺮﻱ ﺩﺍﺷﺘﻴﻢ ﺍﻳﻨﺠﺎ ﻧﻴﺰ ﻣﻄﺮﺡ ﺍﺳﺖ‪.‬‬
‫‪Begin‬‬
‫‪If (F Mod 2)=0 then‬‬ ‫ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﻧﺎﻡ ﺗـﺎﺑﻊ‪ OE‬ﺍﺳـﺖ ﻛـﻪ ﺩﺭ ﻃـﻮﻝ ﺍﺟـﺮﺍﻱ ﺗـﺎﺑﻊ ﻳـﻚ ﻣﺘﻐﻴـﺮ ﺍﺯﻧـﻮﻉ‬
‫‪OE:=False‬‬ ‫‪ Boolean‬ﺍﺳﺖ ﻭ ﺣﺪﺍﻗﻞ ﻳﻜﺒﺎﺭ ﺩﺭ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﺗـﺎﺑﻊ ﺑﺎﻳـﺪ ﻣﻘـﺪﺍﺭﺩﻫﻲ ﺷـﻮﺩ ﺯﻳـﺮﺍ‬
‫‪Else‬‬ ‫ﻣﻘﺪﺍﺭﻱ ﺭﺍ ﻛﻪ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮﺩﺍﻧﺪ ﺩﺭ ‪ OE‬ﺑﺎﻳﺪ ﺫﺧﻴﺮﻩ ﺷﻮﺩ‪.‬‬
‫;‪OE:=True‬‬
‫;‪Z:=14.6‬‬
‫;‪End‬‬ ‫ﻧﻜﺘﻪ( ﭼﻮﻥ ﺗﺎﺑﻊ ﻳﻚ ﻣﻘﺪﺍﺭﻱ ﺭﺍ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ ﻧﺤﻮﺓ ﺻﺪﺍ ﺯﺩﻥ )ﻓﺮﺍﺧﻮﺍﻧﻲ ﻛﺮﺩﻥ(‬
‫‪Begin‬‬
‫;‪A:=19‬‬ ‫ﺗﺎﺑﻊ ﺑﺎ ﭘﺮﻭﺳﻴﺠﺮ ﻣﺘﻔﺎﻭﺕ ﺍﺳﺖ‪ .‬ﺗﺎﺑﻊ ﻣﻲ ﺗﻮﺍﻧﺪ ﺩﺭ ﻳﻚ ﻋﺒﺎﺭﺕ ﻣﺎﻧﻨﺪ ﻳـﻚ ﻣﺘﻐﻴـﺮ‬
‫;))‪Writeln(OE(A‬‬ ‫ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ ﻳﺎ ﺩﺭ ﺩﺳﺘﻮﺭ ﺧﺮﻭﺟﻲ ﻗﺮﺍﺭ ﮔﻴﺮﺩ‪ .‬ﺑﻪ ﻃﻮﺭ ﻛﻠﻲ ﺑﻪ ﺗﻨﻬﺎﻳﻲ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻧﻤﻲ‬
‫;)’*’(‪Write‬‬ ‫ﺷﻮﺩ‪.‬‬
‫‪End.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪58‬‬
‫ﻣﺜﺎل( ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ ﻋﺪد از ورودي درﯾﺎﻓﺖ ﮐﺮده ﺳﭙﺲ ﺗﻮﺳﻂ ﺗﺎﺑﻌﯽ ﺑﻨﺎم ‪ Fact‬ﻓﺎﮐﺘﻮرﯾﻞ ﻋـﺪد را ﻣﺤﺎﺳـﺒﻪ و در‬
‫ﺑﺮﻧﺎﻣﻪ اﺻﻠﯽ ﭼﺎپ ﻧﻤﺎﯾﺪ‪.‬‬
‫‪Var‬‬
‫;‪N:integer‬‬
‫‪Function‬‬ ‫;‪Fact (M:integer) : longint‬‬
‫‪Var‬‬
‫;‪P,I:integer‬‬
‫‪Begin‬‬
‫;‪P:=1‬‬
‫‪For I:=1 to M do‬‬
‫;‪P:=P*I‬‬
‫;‪Fact:=P‬‬
‫;‪End‬‬
‫‪Begin‬‬
‫;)‪Readln(N‬‬
‫;) )‪Writeln('Factorial is = ' , Fact(N‬‬
‫‪Readln‬‬
‫‪End.‬‬
‫ﺗﻔـﺎوت ﻫﺎي ﭘﺮدازه و ﺗﺎﺑﻊ‪:‬‬
‫‪ -١‬ﺧﻂ ﻋﻨﻮﺍﻥ ﭘﺮﺩﺍﺯﻩ ﺑﺎ ‪ Procedure‬ﺷﺮﻭﻉ ﻣﻲ ﺷﻮﺩ ﺍﻣﺎ ﺗﺎﺑﻊ ﺑﺎ ‪ Function‬ﺷﺮﻭﻉ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪ -٢‬ﺩﺭ ﺍﻧﺘﻬﺎﻱ ﺧﻂ ﻋﻨﻮﺍﻥ ﺗﺎﺑﻊ‪ ،‬ﻧﻮﻉ ﺩﺍﺩﺓ ﺧﺮﻭﺟﻲ )ﺑﺮﮔﺸﺘﻲ( ﺗﺎﺑﻊ ﻣﺸﺨﺺ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪-٣‬ﻫﺮ ﺗﺎﺑﻊ ﺣﺪﺍﻗﻞ ﻳﻚ ﺧﺮﻭﺟﻲ ﺩﺍﺭﺩ ﺍﻣﺎ ﭘﺮﺩﺍﺯﻩ ﻣﻲ ﺗﻮﺍﻧﺪ ﺩﺍﺩﺓ ﺧﺮﻭﺟﻲ ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ ) .‬ﺩﺍﺩﺓ ﺧﺮﻭﺟﻲ ﺩﺭ ﭘﺮﺩﺍﺯﻩ ﻳﻌﻨﻲ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺠﺎﺯﻱ ﺍﺯ ﻧﻮﻉ‬
‫ﻣﺮﺟﻊ(‬
‫‪-٤‬ﺩﺭ ﺑﻼﻙ ﻫﺮ ﺗﺎﺑﻊ ﺣﺪﺍﻗﻞ ﻳﻚ ﺩﺳﺘﻮﺭ ﺑﺮﺍﻱ ﺭﻳﺨﺘﻦ ﻣﻘﺪﺍﺭ ﺧﺮﻭﺟﻲ ﺩﺭ ﻧﺎﻡ ﺗﺎﺑﻊ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪.‬‬
‫‪-٥‬ﻧﺤﻮﺓ ﻓﺮﺍﺧﻮﺍﻧﻲ ﺗﺎﺑﻊ ﺑﺎ ﭘﺮﺩﺍﺯﻩ ﻣﺘﻔﺎﻭﺕ ﺍﺳﺖ‪.‬‬
‫;‪Const K:Integer=5‬‬ ‫ﻣﺜﺎﻝ( ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫;‪Function S(Var A:Integer):Longint‬‬
‫‪Var‬‬ ‫;‪C:Char‬‬
‫‪Begin‬‬
‫;‪S:=A*A‬‬
‫;‪A:=A+3‬‬
‫;‪K:=K+2‬‬
‫;)‪Write(K,A‬‬
‫;‪End‬‬
‫‪Begin‬‬
‫;)‪Writeln(S(K)); Write(K‬‬
‫‪End.‬‬
‫ﻣﺜﺎﻝ( ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫;‪Const X:Byte=3; I=2‬‬
‫;‪Function F(Var X:byte ; I:Byte):Byte‬‬ ‫ﺝ(‪9‬‬ ‫ﺏ(‪19‬‬ ‫ﺍﻟﻒ( ‪24‬‬
‫‪Begin‬‬ ‫ﺩ(‪20‬‬
‫;‪X:=X*2+I‬‬ ‫ﻧﻜﺘﻪ( ﺩﺭ ﻋﺒﺎﺭﺕ ;‪ X:=X+F(X,I)+X‬ﻫﺮ ﻋﻤﻠﮕﺮﻱ ﻛﻪ ﺍﻭﻟﻮﻳﺖ ﺍﻭﻝ‬
‫;‪F:=X‬‬
‫;‪End‬‬ ‫ﺩﺍﺭﺩ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﻭ ﻫﺮ ﻋﻤﻠﮕﺮﻱ ﻛﻪ ﺍﻟﻮﻳﺖ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﺍﺑﺘﺪﺍ ﻋﻤﻠﻮﻧﺪ‬
‫‪Begin‬‬ ‫ﺳﻤﺖ ﭼﭗ ﺁﻥ ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﺷﻮﺩ ﺳﭙﺲ ﻋﻤﻠﻮﻧﺪ ﺳﻤﺖ ﺭﺍﺳﺖ ﺁﻥ‪.‬‬
‫;‪X:=X+F(X,I)+X‬‬ ‫ﺩﺭ ﻣﺜﺎﻝ ﺩﺍﺩﻩ ﺷﺪﻩ ﺍﺑﺘﺪﺍ )‪ X+F(X,I‬ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﺷﻮﺩ ﻛﻪ ‪ X‬ﺳﻤﺖ‬
‫;)‪Write(X‬‬
‫‪End.‬‬ ‫ﭼﭗ ﺑﺮﺍﺑﺮ ‪ 3‬ﺍﺳﺖ ﻭ ﺣﺎﻝ ﺑﺎﻳﺪ )‪ F(X,I‬ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻛﺮﺩ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪59‬‬
‫زﯾﺮﺑﺮﻧﺎﻣﻪ ﻫﺎي ﻣﺘﺪاﺧﻞ‪:‬‬
‫ﮔﺎﻫﻲ ﻫﻨﮕﺎﻡ ﺗﻌﺮﻳﻒ ﻳﻚ ﭘﺮﻭﺳﻴﺠﺮ ﻳﺎ ﻳﻚ ﺗﺎﺑﻊ ﺩﺭ ﻗﺴﻤﺖ ﺗﻌﺎﺭﻳﻒ ﺁﻥ ﻣﻤﻜﻦ ﺍﺳﺖ ﺗﺎﺑﻊ ﻳﺎ ﭘﺮﻭﺳﻴﺠﺮ ﺩﻳﮕﺮﻱ ﺗﻌﺮﻳﻒ ﺷﻮﺩ ﻛﻪ ﺩﺭ ﺍﻳﻦ ﺻـﻮﺭﺕ‬
‫ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎﻱ ﻣﺘﺪﺍﺧﻞ ﺗﺸﻜﻴﻞ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﻣﺜﺎﻝ‪:‬‬
‫;‪Var M:Integer‬‬
‫;)‪Procedure AZ(F:Integer‬‬ ‫ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺗﺎﺑﻊ ‪ HH‬ﺧﻮﺩ ﻗﺴﻤﺘﻲ ﺍﺯ ﭘﺮﻭﺳﻴﺠﺮ ‪ AZ‬ﺍﺳﺖ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﻓﻘـﻂ‬
‫;‪Var K:Char‬‬ ‫ﺩﺭ ﭘﺮﻭﺳﻴﺠﺮ ‪ AZ‬ﻣﻲ ﺗﻮﺍﻥ ﺍﺯﺁﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ )ﺁﻥ ﺭﺍ ﺻﺪﺍ ﺯﺩ(‪.‬‬
‫;‪Function HH():Char‬‬
‫;‪Var I:Integer‬‬ ‫ﻣﺘﻐﻴﺮ ‪ I‬ﻳﻚ ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ ﺑﺮﺍﻱ ﺗﺎﺑﻊ ‪ HH‬ﺍﺳﺖ ﻭ ﻣﺘﻐﻴﺮ ‪ K‬ﻳﻚ ﻣﺘﻐﻴﺮ ﻣﺤﻠـﻲ ﺍﺳـﺖ‬
‫‪Begin‬‬ ‫ﺑـﺮﺍﻱ ‪ AZ‬ﻭ ‪ . HH‬ﻳﻌﻨـﻲ ﺩﺭ ﻫـﺮ ﺩﻭ ﺯﻳﺮﺑﺮﻧﺎﻣـﻪ ‪ HH‬ﻭ ‪ AZ‬ﻣـﻲ ﺗﻮﺍﻧـﺪ ﺩﺳﺘﺮﺳــﻲ‬
‫;)‪I:=Random(26‬‬ ‫ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫;)‪HH:=CHR(I+65‬‬
‫ﻣﺘﻐﻴﺮ ‪ M‬ﻳﻚ ﻣﺘﻐﻴﺮ ﺳﺮﺍﺳﺮﻱ ﺍﺳﺖ‪.‬‬
‫;‪End‬‬
‫‪Begin‬‬ ‫ﺍﺻﻄﻼ ﺣﺎ ﺑﻪ ﻣﺤﺪﻭﺩﻳﺖ ﻫﺎﻱ ﺩﺳﺘﺮﺳﻲ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻭ ﻣﺘﻐﻴﺮ ﻫﺎ ‪ Scope‬ﻣﻲ ﮔﻮﻳﻨﺪ‪.‬‬
‫;)‪Write(F‬‬ ‫ﻛﻪ ﺍﻳﻦ ‪ Scope‬ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﻪ ﺭﺍﺑﻄﻪ ﭘﺪﺭ ﻭ ﻓﺮﺯﻧﺪﻱ ﺗﺸﺒﻴﻪ ﻛﺮﺩ‪.‬‬
‫;))(‪Write(HH‬‬ ‫ﭘﺮﻭﺳﻴﺠﺮ ‪ AZ‬ﻓﺮﺯﻧـﺪﻱ ﺍﺯ ﺑـﻼﻙ ﺍﺻـﻠﻲ ﺍﺳـﺖ ﻭ ﻣﺘﻐﻴـﺮ ‪ M‬ﭼـﻮﻥ ﺩﺭ ﺑـﺎﻻﻱ ﻫﻤـﻪ‬
‫;‪K:=#68‬‬
‫;‪End‬‬ ‫ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻭ ﺑﻼﻙ ﺍﺻﻠﻲ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺍﺳﺖ ﻣﺮﺑﻮﻁ ﺑﻪ ﻫﻤﻪ ﺍﺳﺖ ﻭ ﺗﺎﺑﻊ ‪ HH‬ﻓﺮﺯﻧﺪ‬
‫‪Begin‬‬ ‫ﭘﺮﻭﺳﻴﺠﺮ ‪ AZ‬ﺍﺳﺖ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ‪ AZ‬ﻣﻲ ﺗﻮﺍﻧﺪ ‪ HH‬ﺭﺍ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻛﻨﺪ ﻭ …‪.‬‬
‫;‪M:=14‬‬
‫;)‪AZ(M‬‬
‫;)’*’(‪Write‬‬
‫‪End.‬‬
‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﺳﺎﺧﺘﺎﺭ ﻳﻚ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﻳﻚ ﺩﺭﺧﺖ )ﭘﺪﺭ ﻭ ﻓﺮﺯﻧﺪﻱ( ﺩﺭﻧﻈﺮ‬
‫ﺑﮕﻴﺮﻳﻢ ﺁﻧﮕﺎﻩ ﻫﺮ ﭘﺪﺭﻱ ﻣﻲ ﺗﻮﺍﻧﺪ ﻓﺮﺯﻧﺪ ﺧﻮﺩ ﺭﺍ ﺻﺪﺍ ﺑﺰﻧﺪ ﻭ ﻫﺮ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺍﻳﻲ‬
‫)ﺑﻪ ﻏﻴﺮ ﺍﺯ ﺑﻼﻙ ﺍﺻﻠﻲ( ﻣﻲ ﺗﻮﺍﻧﺪ ﺧﻮﺩﺵ ﺭﺍ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻛﻨﺪ)ﺗﻮﺍﺑﻊ ﺑﺎﺯﮔﺸﺘﻲ(‬
‫ﻭ ﻫﺮ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻣﻲ ﺗﻮﺍﻧﺪ ﺯﻳﺮﺑﺮﻧﺎﻣﺔ ﺑﺮﺍﺩﺭ ﺑﺎﻻﻱ ﺧﻮﺩ ﺭﺍ ﺻﺪﺍ ﺑﺰﻧﺪ!‬
‫ﻣﺜﻼ ﺯﻳﺮﺑﺮﻧﺎﻣﺔ ‪ F‬ﻣﻲ ﺗﻮﺍﻧﺪ ﺧﻮﺩﺵ ﻭ ‪ R‬ﺭﺍ ﺻﺪﺍ ﺑﺰﻧﺪ‪.‬‬
‫ﻳﺎ ﺯﻳﺮﺑﺮﻧﺎﻣﺔ ‪ K‬ﻣﻲ ﺗﻮﺍﻧﺪ ﺯﻳﺮ ﺑﺮﻧﺎﻣﺔ ‪ Z‬ﻭ ‪ B‬ﻭ ﺧﻮﺩﺵ ﺭﺍ ﺻﺪﺍ ﺑﺰﻧﺪ‪.‬‬
‫ﺑﺮﺍﻱ ﺑﻘﻴﻪ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺧﻮﺩﺗﺎﻥ ﭘﻴﺪﺍ ﻛﻨﻴﺪ!‬

‫ﻧﮑﺘﻪ ( ﻫﻤﺎﻥ ﻃﻮﺭ ﮐﻪ ﮔﻔﺘﻴﻢ ﺩﺭ ﺻﻮﺭﺗﯽ ﻣﯽ ﺗﻮﺍﻥ ﺍﺯ ﻳﮏ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺍﯼ ﺩﻳﮕﺮ ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ ﮐﻪ ﻗﺒـﻼ ﺗﻌﺮﻳﻒ ﺷـﺪﻩ ﺑﺎﺷـﺪ ‪.‬ﺩﺭ‬
‫ﺗﻮﺭﺑﻮ ﭘﺎﺳﮑﺎﻝ ﻧﻘﺺ ﻓﻮﻕ ﺑﻪ ﮐﻤﮏ ﺍﻋﻼﻥ ‪ forward‬ﻗﺎﺑﻞ ﺣﻞ ﺍﺳﺖ‪ .‬ﺑﺪﻳﻦ ﺻﻮﺭﺕ ﮐﻪ ﺍﮔﺮ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺍﯼ ﻫﻨﮕﺎﻡ ﺗﻌﺮﻳﻒ ﺑﺎ ﺍﻋﻼﻥ ‪forward‬‬
‫ﻫﻤﺮﺍﻩ ﺑﺎﺷﺪ‪،‬ﺑﺪﻭﻥ ﺭﻋﺎﻳﺖ ﺍﺯ ﭘﻴﺶ ﺗﻌﺮﻳﻒ ﺷﺪﻥ ﻣﯽ ﺗﻮﺍﻧﺪ ‪ ،‬ﺩﺭ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎﯼ ﺩﻳﮕﺮ ﻇﺎﻫﺮ ﺷﻮﺩ‪.‬‬
‫ﺷﮑﻞ اﻋﻼن ﺑﻪ روش ‪ forward‬ﺑﺼﻮرت زﯾﺮ ﻣﯽ ﺑﺎﺷﺪ ‪:‬‬
‫‪Procedure‬‬ ‫‪Name‬‬ ‫; ‪) ; forward‬ﭘﺎراﻣﺘﺮﻫﺎ(‬
‫ﻧﮑﺘﻪ ( ‪ forward‬ﮐﻠﻤﻪ ذﺧﯿﺮه ﺷﺪه اﺳﺖ‪.‬‬
‫; ‪Procedure p2 ; forward‬‬
‫;‪Procedure p1‬‬
‫ﻣﺜﺎل ‪:‬‬
‫‪Begin‬‬ ‫ﻫﻤﺎﻥ ﻃﻮﺭ ﮐﻪ ﻣﺸﺎﻫﺪﻩ ﻣﯽ ﮐﻨﻴﺪ ﺩﺭ ﻣﺜﺎﻝ ﺭﻭﺑﺮﻭ ﺑﺎ ﺍﻋﻼﻥ ‪ forward‬ﺑـﺮﺍﯼ ﭘﺮﻭﺳـﻴﺠﺮ‪ p2‬ﻣـﯽ‬
‫;‪P2‬‬ ‫ﺗﻮﺍﻧﻴﻢ ﺩﺭ ﺩﺍﺧﻞ ﺑﻼﮎ ﭘﺮﻭﺳﻴﺠﺮ ‪ p1‬ﭘﺮﻭﺳﻴﺠﺮ ‪ p2‬ﺭﺍ ﻓﺮﺍﺧﻮﺍﻧﯽ ﮐﻨﻴﻢ‪.‬ﻳﻌﻨﯽ ﺩﺭ ﺣﺎﻟـﺖ ﻋـﺎﺩﯼ ﻭ‬
‫;‪End‬‬
‫ﺑﺪﻭﻥ ﺍﻋﻼﻥ ‪ forward‬ﻧﻤـﯽ ﺗﻮﺍﻧـﺴﺘیﻢ ﺍﺯ ﺩﺍﺧـﻞ ﭘﺮﻭﺳـﻴﺠﺮ ‪ p1‬ﭘﺮﻭﺳـﻴﺠﺮ ‪p2‬ﺭﺍ ﻓﺮﺍﺧـﻮﺍﻧﯽ‬
‫;‪Procedure p2‬‬
‫‪Begin‬‬ ‫ﮐﻨﻴﻢ‪.‬‬
‫;‪End‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪60‬‬
‫زﯾﺮﺑﺮﻧﺎﻣﻪ ﻫﺎي ﺑﺎزﮔﺸﺘﯽ‪(Recursive) :‬‬
‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﻳﻚ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺧﻮﺩﺵ ﺭﺍ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻣﻲ ﻛﻨﺪ ﻳﻚ ﺯﻳﺮﻧﺎﻣﻪ ﺑﺎﺯﮔﺸﺘﻲ ﺍﻳﺠﺎﺩ ﻣﻲ ﺷﻮﺩ‪ .‬ﻣﻌﻤﻮﻻ ﺑﻌﻀﻲ ﻣﺴﺎﺋﻞ ﻣﺎﻫﻴﺘﻲ ﺑﺎﺯﮔﺸﺘﻲ‬
‫ﺩﺍﺭﻧﺪ ﻳﻌﻨﻲ ﻳﻚ ﻋﻤﻞ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﺍﻣﺎ ﺑﺮ ﺭﻭﻱ ﺩﺍﺩﻩ ﻫﺎﻱ ﻣﺨﺘﻠﻔﻲ‪ .‬ﻣﺎﻧﻨﺪ ﻣﺤﺎﺳﺒﺔ ﻓﺎﻛﺘﻮﺭﻳﻞ ﻳﻚ ﻋﺪﺩ!‪7!=7*6‬‬
‫ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﺎﺯﮔﺸﺘﻲ ﺩﻭ ﻋﻴﺐ ﺩﺍﺭﻧﺪ‪:‬‬
‫‪ -١‬ﺣﺎﻓﻈﻪ ﺍﻱ ﻛﻪ ﺑﺮﺍﻱ ﻧﮕﻬﺪﺍﺭﻱ ﭘﺎﺭﺍﻣﺘﺮﻫﺎ ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﻓﺮﺍﺧﻮﺍﻧﻲ‪ ،‬ﻣﺼﺮﻑ ﻣﻲ ﻛﻨﻨﺪ)‪(Stack‬‬
‫‪ -٢‬ﺑﻪ ﺩﻟﻴﻞ ﻓﺮﺍﺧﻮﺍﻧﻴﻬﺎﻱ ﻣﻜﺮﺭ‪ ،‬ﺍﺟﺮﺍﻱ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎﻱ ﺑﺎﺯﮔﺸﺘﻲ ﻛﻨﺪ ﺍﺳﺖ‪.‬‬
‫ﭼﮕﻮﻧﻪ ﻣﺘﻮﺟﻪ ﺷﻮﻳﻢ ﻛﻪ ﻳﻚ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺑﺎﺯﮔﺸﺘﻲ ﻫﺴﺖ ﻳﺎ ﻧﻪ؟ ﺍﮔﺮ ﺩﺭ ﺑﺪﻧﺔ ﻳﻚ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺧﻮﺩ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺻﺪﺍ ﺯﺩﻩ ﺷﺪﻩ ﺑﺎﺷـﺪ ﺑﺎﺯﮔﺸﺘﻲ‬
‫ﺍﺳﺖ؛ ﻫﻤﭽﻨﻴﻦ ﺩﺭ ﺍﻛﺜﺮ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﻫﺎﻱ ﺑﺎﺯﮔﺸﺘﻲ ﺍﺯ ‪ If Then – Else‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﺑﺮﺍﻱ ﺍﻳﻨﻜﻪ ﻋﻤﻠﻜﺮﺩ ﻳﻚ ﺯﻳﺮﺑﺮﻧﺎﻣﺔ ﺑﺎﺯﮔﺸﺘﻲ ﺭﺍ ﻣﺘﻮﺟﻪ ﺷﻮﻳﻢ ﺭﺍﻫﻲ ﺑﻬﺘﺮ ﺍﺯ ﺭﺳﻢ ‪ Stack‬ﺁﻥ ﻧﻴﺴﺖ‪.‬‬
‫ﻛﻪ ﺭﻭﺵ ﺭﺳﻢ ‪ Stack‬ﺩﺭ ﻛﻼﺱ ﺑﺤﺚ ﺧﻮﺍﻫﺪ ﺷﺪ‪.‬‬
‫;‪Function K(n:integer):Integer‬‬
‫‪Begin‬‬ ‫ﺗﺴﺖ( ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﺔ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫‪If n=1 then‬‬ ‫ﺝ(‪ 24‬ﺩ(‪0‬‬ ‫ﺏ(‪120‬‬ ‫ﺍﻟﻒ( ‪720‬‬
‫‪K:=1‬‬
‫‪Else‬‬
‫;)‪K:= n * K(n-1‬‬
‫;‪End‬‬
‫‪Begin‬‬
‫;))‪Writeln(K(5‬‬
‫‪End.‬‬

‫;‪Function M(D:Integer):Integer‬‬ ‫ﻣﺜﺎﻝ( ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫‪Begin‬‬
‫‪If D=1 then‬‬
‫‪M:=1‬‬
‫‪Else‬‬
‫;)‪M:= 3+ M(D div 2‬‬
‫;‪End‬‬
‫‪Begin‬‬ ‫ﻧﻜﺘﻪ( ﺗﻮﺍﺑﻊ ﺑﺎﺯﮔﺸﺘﻲ ﺑﻪ ﻧﺤﻮﻱ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ ﻛﻪ ﺩﺭ ﻳﻚ ﻣﺮﺣﻠﻪ ‪،‬‬
‫;))‪Writeln(M(40‬‬
‫ﺩﻳﮕﺮﻛﺎﺭ ﺗﻜﺮﺍﺭ ﻧﺸﻮﺩ ﺩﺭﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ ﺑﺮﻧﺎﻣﻪ ﺗﺎ ﺑﻲ ﻧﻬﺎﻳﺖ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‬
‫‪End.‬‬
‫ﻭ ﺣﺎﻓﻈﻪ ﭘﺮ ﻣﻲ ﺷﻮﺩ ﻭ ﭘﻴﻐﺎﻡ ﻣﻲ ﺩﻫﺪ‪.‬‬
‫;‪Function Z(x:Word):Word‬‬
‫‪Begin‬‬ ‫ﺗﺴﺖ( ﺍﮔﺮ ﺩﺭ ﺍﺑﺘﺪﺍ ;‪ X:=12‬ﺑﺎﺷﺪ ﺧﺮﻭﺟﻲ ﺗﺎﺑﻊ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟‬
‫‪If X<=1 then‬‬
‫ﺩ(‪30‬‬ ‫ﺝ(‪22‬‬ ‫ﺏ(‪20‬‬ ‫ﺍﻟﻒ(‪10‬‬
‫‪Z:=1‬‬
‫‪Else‬‬
‫;)‪Z:=Z(x-2) + Z(x Div 2‬‬
‫;‪End‬‬

‫;‪Function OP(x,y:integer):integer‬‬
‫‪Begin‬‬
‫‪If X=Y then‬‬ ‫ﺗﺴﺖ( ﺗﺎﺑﻊ ﺭﻭﺑﺮﻭ ﭼﻪ ﻋﻤﻠﻲ ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﺪ؟ ‪x,y>=1‬‬
‫‪OP:=0‬‬ ‫ﺏ(‪X div Y‬‬ ‫ﺍﻟﻒ( ‪X/Y‬‬
‫‪Else‬‬
‫‪If X>y then‬‬ ‫ﺩ(‪X*Y‬‬ ‫ﺝ(‪X mod Y‬‬
‫)‪OP:=OP(X-Y,Y‬‬
‫‪Else‬‬
‫;‪OP:=X‬‬
‫;‪End‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪61‬‬
‫ﺑﺮاي درك ﺑﻬﺘﺮ زﯾﺮﺑﺮﻧﺎﻣﻪ ﻫﺎي ﺑﺎزﮔﺸﺘﯽ ﺑﻪ ﺗﻮﺿﯿﺤﺎﺗﯽ ﮐﻪ در زﯾﺮ ﺑﺮاي ﺗﺎﺑﻊ ﻓﺎﮐﺘﻮرﯾﻞ آورده ﺷﺪه اﺳﺖ ﺗﻮﺟﻪ ﮐﻨﯿﺪ ‪:‬‬
‫ﺗﺎﺑﻊ ﻓﺎﮐﺘﻮرﯾﻞ ﺑﺮ روي ﻣﺠﻤﻮﻋﻪ اﻋﺪاد ﺻﺤﯿﺢ ﻣﺜﺒﺖ ‪ ،‬ﺑﻪ دو ﺻﻮرت زﯾﺮ ﺗﻌﺮﯾﻒ ﻣﯽ ﺷﻮد ‪:‬‬
‫‪N ! = 1 × 2 × 3 ×…× (N-1) × N‬‬ ‫ﺗﻌﺮﯾﻒ اول ‪:‬‬

‫ﺩﺭ ﻣﺜﺎﻝ ﺻﻔﺤﻪ ‪ ۵۸‬ﺑﺮﺍﯼ ﺑﺪﺳﺖ ﺁﻭﺭﺩﻥ ﻓﺎﮐﺘﻮﺭﻳﻞ ﻳﮏ ﻋﺪﺩ ﺍﺯ ﻃﺮﻳﻖ ﺗﺎﺑﻊ ‪ Fact‬ﺍﺯ ﺗﻌﺮﻳﻒ ﺍﻭﻝ ﺗﺎﺑﻊ ﻓﺎﮐﺘﻮﺭﻳﻞ ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩﻩ ﺍﻳﻢ‪.‬‬
‫ﺗﻌـﺮﯾﻒ دوم ‪:‬‬
‫!)‪N × (N-1‬‬ ‫‪N≥2‬‬
‫=!‪N‬‬
‫‪1‬‬ ‫‪ N = 1‬ﯾﺎ ‪N = 0‬‬

‫ﻃﺮﯾﻘﻪ ﻣﺤﺎﺳﺒﻪ ! ‪ 3‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺗﻌﺮﯾﻒ دوم در ﺟﺪول زﯾﺮ ﻣﺮﺣﻠﻪ ﺑﻪ ﻣﺮﺣﻠﻪ ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪.‬‬

‫! ‪1) 3 ! = 3 × 2‬‬ ‫‪ = 6‬ﭘﺎﺳﺦ‬

‫! ‪2) 2 ! = 2 × 1‬‬ ‫‪ = 2‬ﭘﺎﺳﺦ‬
‫‪3) 1 ! = 1‬‬ ‫‪ = 1‬ﭘﺎﺳﺦ‬

‫ﻧﺘﯿﺠﻪ ﻣﺤﺎﺳﺒﻪ !‪ 3‬ﺑﺎ اﺳﺘﻔﺎده از ﻫﺮ ﯾﮏ از دو روش ﺑﺎﻻ ﯾﮑﺴﺎن و ﺑﺮاﺑﺮ ‪ 6‬اﺳﺖ ‪.‬در ﺗﻌﺮﯾﻒ دوم ﻓﺎﮐﺘﻮرﯾـﻞ ‪ ،‬از ﺧـﻮد ﺗـﺎﺑﻊ‬
‫ﻓﺎﮐﺘﻮرﯾﻞ ‪ ،‬ﺑﺮاي ﺗﻌﺮﯾﻒ آن اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ ﺑﻨﺎﺑﺮاﯾﻦ ﺗﻌﺮﯾﻒ دوم را ﺗﻌﺮﯾـﻒ ﺑﺎزﮔـﺸﺘﯽ ﻓﺎﮐﺘﻮرﯾـﻞ و ﺗﻌﺮﯾـﻒ اول را‬
‫ﺗﻌﺮﯾﻒ ﻏﯿﺮ ﺑﺎزﮔﺸﺘﯽ و ﯾﺎ ﺗﮑﺮاري ) ﺑﺪﻟﯿﻞ ﺗﮑﺮار دﺳﺘﻮر ﺿﺮب ( ﻓﺎﮐﺘﻮرﯾﻞ ﻣﯽ ﻧﺎﻣﻨﺪ‪.‬‬

‫ﻣﺜﺎل ( ﺗﺎﺑﻊ ﻓﺎﮐﺘـﻮرﯾﻞ ﺑﺎ اﺳﺘﻔﺎده از ﺗﻌﺮﯾﻒ ﺑﺎزﮔﺸــﺘﯽ‬

‫;‪FUNCTION RFactorial (n:Integer): LongInt‬‬

‫‪BEGIN‬‬
‫‪IF N ≥ 2 THEN‬‬
‫) ‪RFactorial := N * RFactorial ( N – 1‬‬
‫‪ELSE‬‬
‫‪RFactorial := 1‬‬
‫;‪END‬‬

‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﯿﺪ ﮐﻪ ‪:‬‬

‫ﻧﺤﻮه ﻓﺮاﺧﻮاﻧﯽ زﯾﺮ ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﺑﺎزﮔﺸﺘﯽ ‪ ،‬ﺗﻔﺎوﺗﯽ ﺑﺎ ﻧﺤﻮه ﻓﺮاﺧﻮاﻧﯽ زﯾﺮ ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﻏﯿﺮ ﺑﺎزﮔﺸﺘﯽ ﻧﺪارد‪ .‬ﺑﺮ ﻓـﺮﺽ ﺍﻳﻨﮑـﻪ‬
‫ﺗﺎﺑﻊ ‪ ، RFactorial‬ﺑﻪ ﺻﻮﺭﺕ ; )‪ I := RFactorial (3‬ﺩﺭ ﻳﮏ ﺑﺮﻧﺎﻣﻪ ﻓﺮﺍﺧﻮﺍﻧﯽ ﺷﺪﻩ ﺍﺳﺖ ﺩﺭ ﻫﻨﮕﺎﻡ ﺍﺟﺮﺍﯼ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺭﺍﻳﺎﻧﻪ ﻋﺪﺩ‬
‫‪ ۳‬ﺭﺍ ﺩﺭ ﭘﺎﺭﺍﻣﺘﺮ ‪ n‬ﮐﭙﯽ ﻣﯽ ﮐﻨﺪ ﻭ ﺳﭙﺲ ﺑﺎ ﺍﺟﺮﺍﯼ ﺩﺳﺘﻮﺭﻫﺎﯼ ﺩﺭﻭﻥ ﺗﺎﺑﻊ ﺣﺎﺻﻞ ﺭﺍ ﺩﺭﻭﻥ ﻣﺘﻐﻴﺮ ‪ I‬ﻣﯽ ﺭﻳﺰﺩ‪.‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪62‬‬
‫ﺗﺴﺖ‪:‬‬
‫‪-١‬ﺗﻔﺎﻭﺕ ﺗﺎﺑﻊ ﻭ ﭘﺮﻭﺳﻴﺠﺮ ﺩﺭ ﭼﻴﺴﺖ؟‬
‫ﺏ( ﭘﺮﻭﺳﻴﺠﺮ ﻣﻘﺪﺍﺭ ﺑﺎﺯﮔﺸﺘﻲ ﺩﺍﺭﺩ ﻭﻟﻲ ﺗﺎﺑﻊ ﻧﺪﺍﺭﺩ‬ ‫ﺍﻟﻒ( ﺗﺎﺑﻊ ﻣﻘﺪﺍﺭ ﺑﺎﺯﮔﺸﺘﻲ ﺩﺍﺭﺩ ﻭﻟﻲ ﭘﺮﻭﺳﻴﺠﺮ ﻧﺪﺍﺭﺩ‬
‫ﺝ(ﺗﺎﺑﻊ ﻭ ﭘﺮﻭﺳﻴﺠﺮ ﻫﺮ ﺩﻭ ﻣﻘﺪﺍﺭ ﺑﺎﺯﮔﺸﺘﻲ ﺩﺍﺭﻧﺪ ﺍﻣﺎ ﺗﺎﺑﻊ ﻫﻤﻴﺸﻪ ﻳﻚ ﺧﺮﻭﺟﻲ ﺭﺍ ﺩﺍﺭﺩ‬
‫ﺩ( ﻫﻴﭻ ﺗﻔﺎﻭﺗﻲ ﻧﺪﺍﺭﻧﺪ‪.‬‬
‫;‪Function test(n:byte):integer‬‬
‫‪Begin‬‬ ‫‪-٢‬ﺧﺮﻭﺟﻲ ﺗﺎﺑﻊ ﺭﻭﺑﺮﻭ ﺩﺭ ﺍﺯﺍﻱ ﻭﺭﻭﺩﻱ ‪ N=20‬ﭼﻨﺪ ﺍﺳﺖ؟‬
‫‪If n=1 then‬‬ ‫ﺩ(‪140‬‬ ‫ﺝ(‪100‬‬ ‫ﺏ(‪60‬‬ ‫ﺍﻟﻒ(‪120‬‬
‫‪Test:=6‬‬
‫‪Else‬‬
‫;)‪Test:=6+test(n-1‬‬
‫;‪End‬‬
‫‪-٣‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫ﺍﻟﻒ( ﺗﺎﺑﻊ ﻭ ﭘﺮﻭﺳﻴﺠﺮ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺩﺭ ﻋﺒﺎﺭﺍﺕ ﺭﻳﺎﺿﻲ‪ ،‬ﻣﻘﺎﻳﺴﻪ ﺍﻳﻲ ﻭ ﻏﻴﺮﻩ ﺑﻪ ﻛﺎﺭ ﺑﺮﺩ‬
‫ﺏ(ﺩﺭﻭﻥ ﺑﺪﻧﻪ ﺗﺎﺑﻊ ﻧﺎﻡ ﺗﺎﺑﻊ ﻳﻚ ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ ﺍﺳﺖ‪.‬‬
‫ﺝ( ﺩﺭ ﺧﺎﺭﺝ ﺍﺯ ﺑﺪﻧﺔ ﺗﺎﺑﻊ‪ ،‬ﻣﻲ ﺗﻮﺍﻥ ﻧﺎﻡ ﺗﺎﺑﻊ ﺭﺍ ﺩﺭ ﺳﻤﺖ ﭼﭗ ﻋﻤﻠﮕﺮ ﺍﻧﺘﺴﺎﺏ)=‪ (:‬ﺑﻪ ﻛﺎﺭ ﺑﺮﺩ‪.‬‬
‫;‪Function F(x,y:integer):integer‬‬ ‫ﺩ( ﭘﺮﺩﺍﺯﻩ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺧﻮﺩﺵ ﺭﺍ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻛﻨﺪ‪.‬‬
‫;‪Var P,I:integer‬‬ ‫‪-٤‬ﺗﺎﺑﻊ ﺭﻭﺑﺮﻭ ﭼﻪ ﻋﻤﻠﻲ ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﺪ؟‬
‫‪Begin‬‬ ‫ﺍﻟﻒ( ﻣﻘﺪﺍﺭ ‪ X‬ﺭﺍ ﺩﺭ ‪ Y‬ﺿﺮﺏ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫;‪P:=1‬‬
‫‪For I:=1 to Y Do‬‬ ‫ﺏ(‪ X‬ﺭﺍ ﺑﻪ ﺗﻮﺍﻥ ‪ Y‬ﻣﻲ ﺭﺳﺎﻧﺪ‬
‫;‪P:=P*X‬‬ ‫ﺝ( ‪ Y‬ﺭﺍ ﺑﻪ ﺗﻮﺍﻥ ‪ X‬ﻣﻲ ﺭﺳﺎﻧﺪ‬
‫;‪F:=P‬‬ ‫ﺩ(‪ X‬ﺭﺍ ﺑﻪ ﺗﻮﺍﻥ ‪ P‬ﻣﻲ ﺭﺳﺎﻧﺪ‪.‬‬
‫;‪End‬‬

‫;‪Const ADDB=20‬‬ ‫‪-٥‬ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﭼﻨﺪ ﺧﻄﺎ ﻭﺟﻮﺩ ﺩﺍﺭﺩ؟‬

‫;‪Var Z:integer‬‬ ‫ﺍﻟﻒ( ‪2‬‬
‫;)‪Function ZARB(a,b:Integer‬‬ ‫ﺏ(‪3‬‬
‫‪Begin‬‬
‫ﺝ(‪4‬‬
‫;‪H:=H+2‬‬
‫;‪Zarb:=a*b‬‬ ‫ﺩ(‪5‬‬
‫;‪End‬‬
‫;‪Var H:real‬‬
‫‪Begin‬‬
‫;‪Z:=15; H:=Z‬‬
‫;)‪ADDB:=ZARB(Z,H‬‬
‫‪End.‬‬
‫‪-٦‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺩﺭ ﻣﻮﺭﺩ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻭ ﺗﻮﺍﺑﻊ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫ﺏ( ﭘﺎﺭﺍﻣﺘﺮﻫﺎ ﺗﻮﺍﺑﻊ ﻭﺭﻭﺩﻱ ﻳﺎ ﺧﺮﻭﺟﻲ ﻫﺴﺘﻨﺪ‬ ‫ﺍﻟﻒ(ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻭ ﺗﻮﺍﺑﻊ ﻓﻘﻂ ﻭﺭﻭﺩﻱ ﻫﺴﺘﻨﺪ‬
‫ﺝ( ﺗﺎﺑﻊ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﻪ ﻋﻨﻮﺍﻥ ﭘﺎﺭﺍﻣﺘﺮ ﺑﺮﺍﻱ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻳﺎ ﺗﺎﺑﻊ ﺩﻳﮕﺮ ﺑﻜﺎﺭﺑﺮﺩ‬
‫ﺩ( ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﻪ ﻋﻨﻮﺍﻥ ﭘﺎﺭﺍﻣﺘﺮ ﺑﺮﺍﻱ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻳﺎ ﺗﺎﺑﻊ ﺩﻳﮕﺮ ﺑﻜﺎﺭﺑﺮﺩ‪.‬‬
‫;‪Function KK(n:integer):integer‬‬ ‫‪ -٧‬ﺧﺮﻭﺟﻲ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﺑﺮﺍﻱ ﻭﺭﻭﺩﻱ ‪ 5‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫‪Begin‬‬ ‫ﺩ(‪30‬‬ ‫ﺝ(‪29‬‬ ‫ﺏ(‪28‬‬ ‫ﺍﻟﻒ( ‪24‬‬
‫‪If n=1 then KK:=2‬‬
‫‪Else‬‬
‫;)‪KK:=2*n+KK(n-1‬‬
‫;‪End‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪63‬‬
‫‪-٨‬ﻛﺪﺍﻣﻴﻚ ﺍﺯ ﮔﺰﻳﻨﻪ ﻫﺎﻱ ﺯﻳﺮ ﻧﺎﺩﺭﺳﺖ ﺍﺳﺖ؟‬
‫ﺍﻟﻒ( ﺑﻪ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻭ ﺗﺎﺑﻊ ‪ Module‬ﻣﻲ ﮔﻮﻳﻨﺪ ﺏ( ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺑﻌﻀﻲ ﻭﺭﻭﺩﻱ ﻭ ﺑﻌﻀﻲ ﺧﺮﻭﺟﻲ ﻫﺴﺘﻨﺪ‪.‬‬
‫ﺩ( ﻓﺮﺍﺧﻮﺍﻧﻲ ﻳﻚ ﭘﺮﻭﺳﻴﺠﺮ ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﺩﺭ ﺑﻚ ﺩﺳﺘﻮﺭ ﺍﻧﺘﺴﺎﺏ ﻳﺎ ﺧﺮﻭﺟﻲ ﺻﻮﺭﺕ ﮔﻴﺮﺩ‬ ‫ﺝ(ﺗﺎﺑﻊ ﺣﺪﺍﻗﻞ ﺩﺍﺭﺍﻱ ﻳﻚ ﺧﺮﻭﺟﻲ ﺍﺳﺖ‬
‫‪-٩‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟ ﺍﺯ ﭼﭗ ﺑﻪ ﺭﺍﺳﺖ‬
‫;‪Var a:integer‬‬
‫;)‪Procedure P1(x:integer‬‬ ‫‪3‬‬ ‫ﺏ( ‪13‬‬ ‫ﺍﻟﻒ( ‪13 13‬‬
‫;‪Var a:integer‬‬ ‫ﺩ( ‪3 3‬‬ ‫‪13‬‬ ‫ﺝ( ‪3‬‬
‫‪Begin‬‬
‫;‪A:=10+X‬‬
‫;)‪Write(A‬‬
‫;‪End‬‬
‫‪Begin‬‬
‫;‪A:=3‬‬
‫;)‪P1(A‬‬
‫;)‪Write(A‬‬
‫‪End.‬‬
‫‪ -١٠‬ﺧﺮﻭﺟﻲ ﻗﻄﻌﻪ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺏ(‪22 22‬‬ ‫ﺍﻟﻒ( ‪22 18‬‬
‫;)‪Procedure T(Var X:byte ; I:byte‬‬
‫‪Begin‬‬ ‫ﺩ(‪14 14‬‬ ‫ﺝ(‪22 24‬‬
‫;‪I:=X+4‬‬
‫;‪X:=I+4‬‬
‫;‪End‬‬
‫;‪Const I:byte=14‬‬
‫‪Begin‬‬
‫;)‪T(I,I‬‬ ‫‪-١١‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺻﺤﻴﺢ ﻧﻴﺴﺖ؟‬
‫;)‪Writeln(I,I‬‬
‫‪End.‬‬

‫ﺍﻟﻒ( ﻣﺘﻐﻴﺮﻫﺎﻱ ﺳﺮﺍﺳﺮﻱ ﺩﺭ ﻫﻤﻪ ﺟﺎﻱ ﺑﺮﻧﺎﻣﻪ ﻗﺎﺑﻞ ﺩﺳﺘﺮﺳﻲ ﻫﺴﺘﻨﺪ‪ .‬ﺏ( ﻧﺎﻡ ﺗﺎﺑﻊ ﺣﺪﺍﻗﻞ ﻳﻚ ﺑﺎﺭ ﺑﺎﻳﺪ ﺩﺭ ﺑﺪﻧﻪ ﺗﺎﺑﻊ ﻣﻘﺪﺍﺭ ﺩﻫﻲ ﺷﻮﺩ‪.‬‬
‫ﺝ(ﺗﺎﺑﻊ ﺑﺎﺯﮔﺸﺘﻲ ﺩﺭﻭﻥ ﺑﻠﻮﻙ ﺧﻮﺩﺵ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻣﻲ ﺷﻮﺩ‪ .‬ﺩ(ﻣﺘﻐﻴﺮﻫﺎﻱ ﻣﺤﻠﻲ ﻣﺮﺑﻮﻁ ﺑﻪ ﻳﻚ ﺗﺎﺑﻊ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺍﺻﻠﻲ ﻗﺎﺑﻞ ﺩﺳﺘﺮﺳﻲ‬
‫ﻫﺴﺘﻨﺪ‪.‬‬
‫;‪Function S(A:integer;VAR X:integer):integer‬‬ ‫‪-١٢‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﺭﻭﺑﺮﻭ ﺑﻪ ﺗﺮﺗﻴﺐ ﺍﺯ ﭼﭗ ﺑﻪ ﺭﺍﺳﺖ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫‪Begin‬‬ ‫ﺍﻟﻒ(‪10,26,36,5,25‬‬
‫;‪A:=A+5‬‬
‫;‪X:=X+1‬‬ ‫ﺏ( ‪30,6,36,6,25‬‬
‫;)‪Write(A,X‬‬ ‫ﺝ(‪10,26,36,5,26‬‬
‫;‪S:=X+A‬‬
‫;‪End‬‬ ‫ﺩ(‪30,6,36,5,26‬‬
‫‪Begin‬‬
‫;‪A:=25; X:=5‬‬
‫;))‪Writeln(S(X,A),X,A‬‬
‫‪End.‬‬ ‫‪-١٣‬ﺗﻔﺎﻭﺕ ﭘﺎﺭﺍﻣﺘﺮ ‪) Value‬ﺍﺭﺯﺷﻲ( ﻭ ‪) variable‬ﻣﺮﺟﻊ( ﺩﺭ ﭼﻴﺴﺖ؟‬
‫ﺍﻟﻒ(ﭘﺎﺭﺍﻣﺘﺮ ‪ Value‬ﻣﻲ ﺗﻮﺍﻧﺪ ﺩﺭ ﻣﻮﺍﻗﻌﻲ ﻫﻢ ﻭﺭﻭﺩﻱ ﻭ ﻫﻢ ﺧﺮﻭﺟﻲ ﺑﺎﺷﺪ ﺩﺭﺻﻮﺭﺗﻴﻜﻪ ﭘﺎﺭﺍﻣﺘﺮ ‪ Variable‬ﻓﻘﻂ ﺧﺮﻭﺟﻲ ﺍﺳﺖ‪.‬‬
‫ﺏ(ﭘﺎﺭﺍﻣﺘﺮ ‪ Variable‬ﺗﻨﻬﺎ ﻣﻲ ﺗﻮﺍﻧﺪ ﺧﺮﻭﺟﻲ ﺑﺎﺷﺪ‪.‬‬
‫ﺝ(ﭘﺎﺭﺍﻣﺘﺮ ‪ Variable‬ﺩﺭ ﻣﻮﺍﻗﻌﻲ ﻫﻢ ﻭﺭﻭﺩﻱ ﻭ ﻫﻢ ﺧﺮﻭﺟﻲ ﻣﻲ ﺑﺎﺷﺪ ﻭﻟﻲ ‪ Value‬ﻫﻤﻴﺸﻪ ﻭﺭﻭﺩﻱ ﺍﺳﺖ‪.‬‬
‫ﺩ(ﭘﺎﺭﺍﻣﺘﺮ ‪ Value‬ﻭ ‪ variable‬ﻫﻢ ﻣﻲ ﺗﻮﺍﻧﺪ ﻭﺭﻭﺩﻱ ﻭ ﻫﻢ ﺧﺮﻭﺟﻲ ﺑﺎﺷﻨﺪ‪.‬‬
‫;‪Function F(M,N:integer):integer‬‬
‫‪Begin‬‬ ‫‪-١٤‬ﺗﺎﺑﻊ ﺯﻳﺮ ﭼﻪ ﻋﻤﻠﻲ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﺪ‪M,N>=1 .‬‬
‫‪If N=1 then F:=M‬‬ ‫ﺩ( ‪M-N‬‬ ‫ﺝ(‪MN‬‬ ‫ﺏ(‪M*N‬‬ ‫ﺍﻟﻒ(‪M+N‬‬
‫‪Else‬‬
‫;‪F:=F(M,N-1)+M‬‬
‫;‪End‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪64‬‬
‫ﯾﻮﻧﯿـﺖ ‪: CRT‬‬
‫ﺩﺭ ﺍﺩﺍﻣﻪ ﺗﻌﺪﺍﺩﻱ ﺍﺯ ﺗﻮﺍﺑﻌﻲ ﻛﻪ ﺩﺭ ﻳﻮﻧﻴﺖ ‪ crt‬ﻛﺎﺭﺑﺮﺩ ﺑﻴﺸﺘﺮﻱ ﺩﺍﺭﻧﺪ ﺑﺤﺚ ﻣﻲ ﺷﻮﺩ‪ .‬ﺑﺮﺍﻱ ﺍﻳﻨﻜﻪ ﺑﺘﻮﺍﻧﻴﻢ ﺍﺯ ﺍﻳـﻦ ﺗﻮﺍﺑـﻊ ﺍﺳـﺘﻔﺎﺩﻩ ﻛﻨـﻴﻢ ﺑﺎﻳـﺪ‬
‫ﻳﻮﻧﻴﺖ ‪ crt‬ﺭﺍ ﺩﺭ ﺍﺑﺘﺪﺍﻱ ﺑﺮﻧﺎﻣﻪ ‪ Uses‬ﻛﻨﻴﻢ‪.‬‬
‫ﭘﺮﻭﺳﻴﺠﺮ ‪ : GotoXY‬ﺍﺯ ﺍﻳﻦ ﺗﺎﺑﻊ ﺑﺮﺍﻱ ﺟﺎﺑﺠﺎ ﻛﺮﺩﻥ ﻣﻜﺎﻥ ﻧﻤﺎ ﺩﺭ ﺻﻔﺤﻪ ﺧﺮﻭﺟﻲ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪ .‬ﺻـﻔﺤﻪ ﻣـﺎﻧﻴﺘﻮﺭ ﺩﺍﺭﺍﻱ ‪ ٢٥‬ﺳـﻄﺮ ﻭ‬
‫‪ ٨٠‬ﺳﺘﻮﻥ ﺍﺳﺖ ) ﺩﺭ ﺣﺎﻟﺖ ﻣﺘﻨﻲ(‪ .‬ﻣﺜﻼ ﺩﺳﺘﻮﺭ ;)‪ GotoXy(74,15‬ﻣﻜﺎﻥ ﻧﻤﺎ ﺭﺍ ﺑﻪ ﺳﺘﻮﻥ ‪ ٧٤‬ﻭ ﺳﻄﺮ ‪ ١٥‬ﻣﻨﺘﻘﻞ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﺩﻗﺖ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﭘﺎﺭﺍﻣﺘﺮ ﺍﻭﻝ ﺳﺘﻮﻥ ﺍﺳﺖ ﻭ ﭘﺎﺭﺍﻣﺘﺮ ﺩﻭﻡ ﺳﻄﺮ ﺍﺳﺖ‪ .‬ﭘﺎﺭﺍﻣﺘﺮ ﺍﻭﻝ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺑﻴﺶ ﺍﺯ ‪ ٨٠‬ﻭ ﭘﺎﺭﺍﻣﺘﺮ ﺩﻭﻡ ﻧﻴﺰ ﻧﻤﻲ‬
‫ﺗﻮﺍﻧﺪ ﺑﻴﺶ ﺍﺯ ‪ ٢٥‬ﺑﺎﺷﺪ‪.‬‬
‫ﭘﺮﻭﺳﻴﺠﺮ ‪ : TEXTCOLOR‬ﺍﺯ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺑﺮﺍﻱ ﺗﻐﻴﻴﺮ ﺭﻧﮓ ﻗﻠﻢ ﺩﺭ ﺧﺮﻭﺟﻲ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷـﻮﺩ‪ .‬ﺩﺍﺭﺍﻱ ﻳـﻚ ﭘـﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺍﺯ ﻧـﻮﻉ‬
‫ﺻﺤﻴﺢ ﺍﺳﺖ ﻛﻪ ﺷﻤﺎﺭﻩ ﺭﻧﮓ ﺭﺍ ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ‪ .‬ﻣﺜﻼ ;)‪ TextColor(2‬ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﺍﺯ ﺍﻳﻦ ﺩﺳـﺘﻮﺭ ﺑـﻪ ﺑﻌـﺪ ﻧﻮﺷـﺘﻪ ﻫـﺎﻳﻲ ﻛـﻪ ﺩﺭ‬
‫ﻣﺎﻧﻴﺘﻮﺭ ﭼﺎﭖ ﻣﻲ ﺷﻮﻧﺪ ﺭﻧﮓ ﺳﺒﺰ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ‪ .‬ﺷﻤﺎﺭﻩ ﺭﻧﮓ ﻋﺪﺩﻱ ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 15‬ﺍﺳﺖ‪ .‬ﻫﺮ ﺭﻧﮕﻲ ﺩﺍﺭﺍﻱ ﻳﻚ ﺷﻤﺎﺭﻩ ﺍﺳﺖ ﻛﻪ ﺟﺪﻭﻝ ﺁﻥ ﺩﺭ‬
‫ﻛﺘﺎﺏ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪ .‬ﺑﺮﺍﻱ ﺑﺎﻻ ﺑﺮﺩﻥ ﺧﻮﺍﻧﺎﻳﻲ ﺑﺮﻧﺎﻣﻪ ﺑﺮﺍﻱ ﻫﺮ ﺷﻤﺎﺭﻩ ﺛﺎﺑﺖ ﺁﻥ ﻧﻴﺰ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﻣﺜﻼ )‪ Textcolor(Green‬ﻫﻤﺎﻥ ﻛﺎﺭ‬
‫ﻗﺒﻠﻲ ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﺪ‪ .‬ﻣﺜﻼ ﻋﺪﺩ ‪ ١٤‬ﺑﺮﺍﻱ ﺭﻧﮓ ﺯﺭﺩ ﺍﺳﺖ ﻛﻪ ﻣﻲ ﺗﻮﺍﻧﻴﺪ ﺍﺯ ﺛﺎﺑﺖ ‪ Yellow‬ﻧﻴﺰ ﺑﺠﺎﻱ ‪ ١٤‬ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﺪ‪.‬‬
‫ﭘﺮﻭﺳﻴﺠﺮ ‪ : ClrScr‬ﺍﻳﻦ ﭘﺮﻭﺳﻴﺠﺮ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﻧﺪﺍﺭﺩ ﻭ ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﺻﻔﺤﻪ ﻣﺎﻧﻴﺘﻮﺭ ﭘﺎﻙ ﺷﻮﺩ )ﻣﺎﻧﻨﺪ ﺩﺳﺘﻮﺭ ‪ Cls‬ﺩﺭ ‪(Dos‬‬
‫ﭘﺮﻭﺳﻴﺠﺮ ‪: TextBackGround‬‬
‫ﺍﻳﻦ ﭘﺮﻭﺳﻴﺠﺮ ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﻋﺪﺩﻱ ﺻﺤﻴﺢ ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 7‬ﺩﺍﺭﺩ ﻛﻪ ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﺭﻧﮓ ﭘﺲ ﺯﻣﻴﻨﺔ ﺧﺮﻭﺟﻲ ﺗﻐﻴﻴﺮ ﻛﻨﺪ‪ .‬ﺷﻤﺎﺭﻩ ﺭﻧﮓ ﻋﺪﺩﻱ ﺑﻴﻦ‬
‫ﺻﻔﺮ ﺗﺎ ﻫﻔﺖ ﺍﺳﺖ‪ .‬ﻣﺜﺎﻝ;)‪ TextBackGround(Blue‬ﻳﺎ ;)‪ TextBackGround(1‬ﭘﺲ ﺯﻣﻴﻨﻪ ﺭﺍ ﺁﺑﻲ ﻣﻲ ﻛﻨﻨﺪ‪.‬‬
‫ﭘﺮﻭﺳﻴﺠﺮ ‪ :Window‬ﺍﺯ ﺍﻳﻦ ﭘﺮﻭﺳﻴﺠﺮ ﺑﺮﺍﻱ ﺗﻌﻴﻴﻦ ﻗﺴﻤﺘﻲ ﺍﺯ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﺑﻪ ﻋﻨﻮﺍﻥ ﭘﻨﺠﺮﺓ ﻓﻌﺎﻝ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻣﺜﺎﻝ‪ Window(10,12,40,20); :‬ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﭘﻨﺠﺮﺓ ﻓﻌﺎﻝ ﺷﻤﺎ ﺩﺭ ﻳﻚ ﻣﺴﺘﻄﻴﻞ ﻗﺮﺍﺭ ﮔﻴﺮﺩ‪.‬‬

‫ﺗﺎﺑﻊ ‪ ReadKey‬ﻧﻴﺰ ﻣﺮﺑﻮﻁ ﺑﻪ ﻳﻮﻧﻴﺖ ‪ Crt‬ﺍﺳﺖ ﻛﻪ ﻗﺒﻼ ﺑﺮﺭﺳﻲ ﺷﺪ‪.‬‬

‫ﺗﻌﺪﺍﺩ ﭘﺮﻭﺳﻴﺠﺮﻫﺎ ﻭﺗﻮﺍﺑﻊ ﻣﻮﺟﻮﺩ ﺩﺭ ﻳﻮﻧﻴﺖ ‪ Crt‬ﺯﻳﺎﺩ ﺍﺳﺖ ﻛﻪ ﺗﻌﺪﺍﺩﻱ ﺩﻳﮕﺮ ﺁﻥ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ‪ ٢‬ﺑﺤﺚ ﺧﻮﺍﻫﺪ ﺷﺪ‪.‬‬

‫ﺗﺴﺖ‪ :‬ﺍﺯ ﭘﺮﻭﺳﻴﺠﺮ ………‪ .‬ﺑﺮﺍﻱ ﺗﻌﻴﻴﻦ ﺭﻧﮓ ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﺩ(‪CharColor‬‬ ‫ﺝ(‪TextColor‬‬ ‫ﺏ(‪TextBackGround‬‬ ‫ﺍﻟﻒ( ‪Color‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪65‬‬
‫ﺗﺴﺖ ‪:‬‬
‫‪ -١‬ﺩﺭ ﻣﺤﻴﻂ ﺗﻮﺭﺑﻮ ﭘﺎﺳﻜﺎﻝ ﺑﺮﺍﻱ ﺁﻧﻜﻪ ﭘﻨﺠﺮﻩ ﻱ ﺩﻳﮕﺮﻱ ﺭﺍ ﺑﻪ ﻋﻨﻮﺍﻥ ﭘﻨﺠﺮﻩ ﻱ ﺟﺎﺭﻱ ﺍﻧﺘﺨﺎﺏ ﻛﻨﻴﻢ ﺍﺯ ﻛﺪﺍﻡ ﻛﻠﻴﺪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ؟‬
‫ﺩ(‪F7‬‬ ‫ﺝ(‪F5‬‬ ‫ﺏ(‪F6‬‬ ‫ﺍﻟﻒ( ‪F4‬‬
‫‪ -٢‬ﺟﻬﺖ ﺍﺟﺮﺍﻱ ﺧﻂ ﺑﻪ ﺧﻂ ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﻣﺤﻴﻂ ﭘﺎﺳﻜﺎﻝ ﺍﺯ ﻛﺪﺍﻡ ﻛﻠﻴﺪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ؟‬
‫ﺩ(‪F9‬‬ ‫ﺝ(‪F5‬‬ ‫ﺏ(‪F6‬‬ ‫ﺍﻟﻒ(‪F7‬‬
‫‪ -٣‬ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺩﺭ ﻣﻮﺭﺩ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ‪ Upcase‬ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫ﺍﻟﻒ( ﻳﻚ ﺭﺷﺘﻪ ﺭﺍ ﺑﻪ ﻋﻨﻮﺍﻥ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺩﺭﻳﺎﻓﺖ ﻭ ﺣﺮﻭﻑ ﺁﻥ ﺭﺍ ﺑﻪ ﺑﺰﺭﮒ ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﺪ‬
‫ﺏ( ﻳﻚ ﻛﺎﺭﺍﻛﺘﺮ ﺭﺍ ﺑﻪ ﻋﻨﻮﺍﻥ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺩﺭﻳﺎﻓﺖ ﻭ ﺣﺮﻑ ﺑﺰﺭﮒ ﺁﻥ ﺭﺍ ﺑﺮﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬
‫ﺝ( ﺍﮔﺮ ﺩﺭ ﺭﺷﺘﻪ ﻱ ﻭﺭﻭﺩﻱ ﻛﺎﺭﺍﻛﺘﺮﻱ ﻏﻴﺮ ﺍﺯ ﺣﺮﻭﻑ ﺍﻟﻔﺒﺎﻱ ﻛﻮﭼﻚ ﺑﺎﺷﺪ ﺁﻧﺮﺍ ﺑﻪ ﺭﺷﺘﻪ ﺗﻬﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﺩ( ﻳﻚ ﻛﺎﺭﺍﻛﺘﺮ ﻳﺎ ﺭﺷﺘﻪ ﺭﺍ ﺑﻪ ﻋﻨﻮﺍﻥ ﭘﺎﺭﺍﻣﺘﺮ ﻭﺭﻭﺩﻱ ﺩﺭﻳﺎﻓﺖ ﻛﺮﺩﻩ ﻭ ﺁﻥ ﺭﺍ ﺑﻪ ﺣﺮﻑ ﻳﺎ ﺣﺮﻭﻑ ﺑﺰﺭﮒ ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫‪-٤‬ﺑﺮﺍﻱ ﺩﺭﺝ ﺗﻮﺿﻴﺤﺎﺕ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺍﺯ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ؟‬
‫<‬ ‫ﺩ( >‬ ‫{‬ ‫ﺝ( }‬ ‫(‬ ‫ﺏ( )‬ ‫ﺍﻟﻒ( ] [‬
‫‪-٥‬ﻣﺘﻐﻴﺮ ﻧﻮﻉ ‪ word‬ﭼﻪ ﻣﺤﺪﻭﺩﻩ ﺍﻱ ﺍﺯ ﺍﻋﺪﺍﺩ ﺭﺍ ﺩﺭ ﺧﻮﺩ ﺫﺧﻴﺮﻩ ﻣﻲ ﻛﻨﺪ ﻭ ﭼﻨﺪ ﺑﺎﻳﺖ ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨﺪ؟‬
‫ﺝ(‪ 65535‬ﺗﺎ ‪ 0‬ﻭ ‪ ٢‬ﺑﺎﻳﺖ ﺩ(‪ -128‬ﺗﺎ‪ +127‬ﻭ‪ ٢‬ﺑﺎﻳﺖ‬ ‫ﺏ(‪ 65535‬ﺗﺎ ‪ 0‬ﻭ ‪ ٤‬ﺑﺎﻳﺖ‬ ‫ﺍﻟﻒ(‪ +32767‬ﺗﺎ ‪ –32768‬ﻭ ‪ ٢‬ﺑﺎﻳﺖ‬
‫‪-٦‬ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭ ) )‪ Write( ODD($D) > ODD(16‬ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪False‬‬ ‫ﺝ( ‪0‬‬ ‫ﺏ( ‪1‬‬ ‫ﺍﻟﻒ( ‪TRUE‬‬
‫)‪(X-Y<10) and ( X+3*Y/4=5‬‬ ‫‪ -٧‬ﺍﺭﺯﺵ ﺑﻮﻟﻲ ﻋﺒﺎﺭﺕ ﺯﻳﺮ ﺑﻪ ﺍﺯﺍﻱ ‪ X=3‬ﻭ ‪ Y=4‬ﭼﻴﺴﺖ؟‬
‫ﺩ(‪0‬‬ ‫ﺝ(‪1‬‬ ‫ﺏ(‪True‬‬ ‫ﺍﻟﻒ( ‪False‬‬
‫‪-٨‬ﻛﺪﺍﻡ ﻳﻮﻧﻴﺖ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺑﺼﻮﺭﺕ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﺩ؟‬
‫ﺩ(‪Graph‬‬ ‫ﺝ(‪Crt‬‬ ‫ﺏ( ‪System‬‬ ‫ﺍﻟﻒ(‪Dos‬‬
‫‪Var‬‬ ‫‪-٩‬ﺍﺯ ﮔﺰﻳﻨﻪ ﻫﺎﻱ ﺯﻳﺮ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺗﻌﺎﺭﻳﻒ ﺭﻭﺑﺮﻭﻛﺪﺍﻡ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫;‪I,J:integer‬‬
‫;‪A,B,C : Char‬‬ ‫ﺝ(‪For M:=F To E Do‬‬ ‫ﺍﻟﻒ( ‪For I:=A To B Do‬‬
‫;‪M,F,E:Real‬‬ ‫ﺩ(‪For I:=10 To F Do‬‬ ‫ﺏ(‪For A:=B To C Do‬‬
‫‪ -١٠‬ﺣﺎﺻﻞ ﻋﺒﺎﺭﺕ ﺭﻭﺑﺮﻭ ﭼﻴﺴﺖ؟ ‪6+4 Mod 2*6-17‬‬
‫ﺩ(‪13‬‬ ‫ﺝ(‪1‬‬ ‫ﺏ(‪-17‬‬ ‫ﺍﻟﻒ(‪-11‬‬
‫‪-١١‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺩﺳﺘﻮﺭ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫‪For Y:=Trunc(X) To Round(X) Do‬‬
‫;)’*’(‪Write‬‬ ‫ﺝ( ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﺻﺎﺩﺭ ﻣﻲ ﺷﻮﺩ‬ ‫ﺍﻟﻒ(ﺣﻠﻘﻪ ﺣﺪﺍﻗﻞ ﻳﻚ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‬
‫ﺩ( ﺣﻠﻘﻪ ﺍﺻﻼ ﺗﻜﺮﺍﺭ ﻧﻤﻲ ﺷﻮﺩ‬ ‫ﺏ(ﺣﻠﻘﻪ ﺩﻭ ﺑﺎﺭ ﺗﻜﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‬
‫;‪IF A>5 Then Else A:=A*2‬‬ ‫‪-١٢‬ﺍﮔﺮ ‪ A=5‬ﺑﺎﺷﺪ ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭﺍﺕ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬
‫;‪IF A>=5 Then A:=A*2 Else‬‬ ‫ﺩ(‪40‬‬ ‫ﺝ(‪20‬‬ ‫ﺏ(‪10‬‬ ‫ﺍﻟﻒ(‪5‬‬
‫;)‪Write(A‬‬
‫‪-١٣‬ﺍﮔﺮ ﻛﺎﺭﺍﻛﺘﺮ ﻫﺎﻱ ‪ 1‬ﻭ ‪ 2‬ﻭ ‪ 3‬ﺭﺍ ﺩﺭ ﻭﺭﻭﺩﻱ ﺑﺎ ‪ Enter‬ﺍﺯ ﻫﻢ ﺟﺪﺍ ﻛﻨﻴﻢ ﺧﺮﻭﺟﻲ ﻛﺪﺍﻡ ﺍﺳﺖ؟)ﻋﻼﻣﺖ ـ ﻧﺸﺎﻥ ﺩﻫﻨﺪﻩ ﻣﺤﻞ ﻛﺮﺳﻮﺭ‬
‫ﺩﺭﺧﺮﻭﺟﻲ ﺍﺳﺖ(‬
‫;‪Var A,B,C,D:Char‬‬
‫ﺩ(‪123‬‬ ‫ﺝ(_‪123‬‬ ‫ﺏ(_‪2‬‬ ‫ﺍﻟﻒ(‪1‬‬
‫‪Begin‬‬
‫;)‪Readln(A,B,C,D‬‬ ‫ـ‬ ‫ـ‬
‫;)‪Write(A,B,D‬‬
‫‪End.‬‬
‫‪-١٤‬ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ‪ IDE‬ﻳﻌﻨﻲ ………‬
‫ﺩ(ﻫﺮ ﺳﻪ ﻣﻮﺭﺩ‬ ‫ﺝ(ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ‬ ‫ﺏ( ﻭﻳﺮﺍﻳﺶ ﻛﺮﺩﻥ ﺑﺮﻧﺎﻣﻪ‬ ‫ﺍﻟﻒ( ﻗﺴﻤﺘﻲ ﺍﺯ ﺑﺮﻧﺎﻣﻪ‬
‫‪-١٥‬ﺑﺮﺍﻱ ﺍﺟﺮﺍﻱ ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺩﺭ ﺧﻂ ﻓﺮﻣﺎﻥ ‪ Dos‬ﻛﻠﻤﻪ ……… ﺭﺍ ﻣﻲ ﻧﻮﻳﺴﻴﻢ‪.‬‬
‫ﺩ(‪Tp‬‬ ‫ﺝ(‪Tpascal‬‬ ‫ﺏ(‪Pascal‬‬ ‫ﺍﻟﻒ(‪Turbo‬‬
‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪66‬‬
‫‪-١٦‬ﺑﺮﻧﺎﻣﻪ ﻫﺎﻱ ﭘﺎﺳﻜﺎﻝ ﺑﺎ ﭘﺴﻮﻧﺪ ……… ﺫﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﺩ(‪TBO‬‬ ‫ﺝ(‪TPU‬‬ ‫ﺏ(‪PAS‬‬ ‫ﺍﻟﻒ(‪TPS‬‬
‫‪-١٧‬ﻛﻤﻴﺖ ﺑﻮﻟﻲ ﭼﻪ ﻣﻘﺎﺩﻳﺮﻱ ﺭﺍ ﻣﻲ ﺗﻮﺍﻧﺪ ﺑﻪ ﺧﻮﺩ ﺍﺧﺘﺼﺎﺹ ﺩﻫﺪ؟‬
‫ﺩ(‪0 – 1‬‬ ‫ﺝ(ﻣﻘﺎﺩﻳﺮ ﻋﺪﺩﻱ‬ ‫ﺏ(‪No-Yes‬‬ ‫ﺍﻟﻒ(‪False-True‬‬
‫‪-١٨‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎﺑﻞ ﭼﻴﺴﺖ؟‬
‫;‪Var A:Real‬‬
‫‪Begin‬‬ ‫ﺏ(‪105‬‬ ‫ﺍﻟﻒ(‪1.05‬‬
‫;‪A:=10.5‬‬ ‫ﺩ( ‪1.0500000000E+1‬‬ ‫ﺝ(‪10.5‬‬
‫;)‪Writeln(A‬‬ ‫‪-١٩‬ﺗﻌﺎﺭﻳﻒ ……‪ .‬ﺑﺎﻳﺪ ﻗﺒﻞ ﺍﺯ ﺷﺮﻭﻉ ﺑﻠﻮﻙ ﻛﺪ ﭘﺮﻭﺳﻴﺠﺮ ﻳﺎ ﺗﻮﺍﺑﻊ ﻗﺮﺍﺭ ﺩﺍﺩﻩ ﺷﻮﻧﺪ‪.‬‬
‫‪End.‬‬
‫ﺩ(ﺳﺮﺍﺳﺮﻱ‬ ‫ﺝ(ﻣﺤﻠﻲ‬ ‫ﺏ(ﻓﺮﻋﻲ‬ ‫ﺍﻟﻒ(ﺍﺻﻠﻲ‬
‫‪-٢٠‬ﺑﺮﺍﻱ ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﭘﺮﻭﺳﻴﺠﺮﻫﺎ ﻭ ﺗﻮﺍﺑﻊ ﻛﻪ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﻭ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﺭﺍ ﻛﻨﺘﺮﻝ ﻣﻲ ﻛﻨﻨﺪ ﺑﺎﻳﺪ ﺍﺯ ﻛﺪﺍﻡ ﻳﻮﻧﻴﺖ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﭘﺎﺳﻜﺎﻝ‬
‫ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻮﺩ‪.‬‬
‫ﺩ(‪Printer‬‬ ‫ﺝ(‪System‬‬ ‫ﺏ(‪Dos‬‬ ‫ﺍﻟﻒ(‪Crt‬‬
‫‪-٢١‬ﺩﺭﭘﺎﺳﻜﺎﻝ ﺑﺮﻧﺎﻣﻪ ﻫﺎﻱ ﺑﺰﺭﮒ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﻪ ﺗﻜﻪ ﻫﺎﻱ ﻛﻮﭼﻜﺘﺮﻱ ﺗﻘﺴﻴﻢ ﻛﺮﺩ‪ .‬ﺑﻪ ﺍﻳﻦ ﺗﻜﻪ ﺑﺮﻧﺎﻣﻪ ﻫﺎ ……… ﻣﻲ ﮔﻮﻳﻨﺪ‪.‬‬
‫ﺩ( ﭘﺮﻭﺳﻴﺠﺮﻫﺎ ﻳﺎ ﺭﻭﺗﻴﻦ ﻫﺎ‬ ‫ﺝ( ﺗﻮﺍﺑﻊ ﻳﺎ ﺭﻭﺗﻴﻦ ﻫﺎ‬ ‫ﺏ( ﭘﺮﻭﺳﻴﺠﺮﻫﺎﻳﺎ ﺗﻮﺍﺑﻊ‬ ‫ﺍﻟﻒ(ﺭﻭﺗﻴﻦ ﻫﺎ ﻳﺎ ﺳﺎﺑﺮﻭﺗﻴﻦ ﻫﺎ‬

‫;]‪Var A,B,C:String[3‬‬ ‫‪-٢٢‬ﺍﺯ ﺍﻳﻦ ﺗﺎﺑﻊ ﺑﺮﺍﻱ ﺩﺭﻳﺎﻓﺖ ﻟﮕﺎﺭﻳﺘﻢ ﻃﺒﻴﻌﻲ ﻋﺪﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ؟‬
‫‪Begin‬‬ ‫ﺩ(‪INT‬‬ ‫ﺝ(‪Ln‬‬ ‫ﺏ(‪Lo‬‬ ‫ﺍﻟﻒ(‪Length‬‬
‫;’‪A:=’20’; B:=’30‬‬ ‫‪-٢٣‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎﺑﻞ ﭼﻴﺴﺖ؟‬
‫;‪C:=A+B‬‬
‫ﺩ(‪2030‬‬ ‫ﺝ(‪50‬‬ ‫ﺏ(‪20+30‬‬ ‫ﺍﻟﻒ(‪203‬‬
‫;)‪Writeln(c‬‬
‫‪End.‬‬

‫‪-٢٤‬ﺍﮔﺮ ‪ A=5‬ﺑﺎﺷﺪ ﺧﺮﻭﺟﻲ ﺩﺳﺘﻮﺭ ﺭﻭﺑﺮﻭ ﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫;‪IF A<5 Then Else A:=A*2‬‬ ‫ﺩ(‪40‬‬ ‫ﺝ(‪30‬‬ ‫ﺏ(‪10‬‬ ‫ﺍﻟﻒ( ‪5‬‬
‫; ‪IF A>=5 Then A:=A*2 Else‬‬
‫;)‪Write(A‬‬
‫‪-٢٥‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺳﺎﺧﺘﺎﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺍﺟﺮﺍﻱ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺑﺎﻋﺚ ﺧﻄﺎ ﻣﻲ ﺷﻮﺩ؟‬
‫ﺩ(‬ ‫ﺝ(‬ ‫ﺏ(‬ ‫ﺍﻟﻒ(‬
‫; ‪Begin‬‬ ‫‪Begin‬‬ ‫; ‪Begin‬‬ ‫‪Begin‬‬
‫‪End.‬‬
‫;‪Begin ; End‬‬ ‫‪End.‬‬ ‫‪Var‬‬
‫‪End.‬‬ ‫;‪X:integer‬‬ ‫;‪End‬‬
‫;)‪Readln(x‬‬

‫‪-٢٦‬ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﻱ ﺭﻭﺑﺮﻭﻛﺪﺍﻡ ﺍﺳﺖ؟‬

‫;‪A:=1; B:=2‬‬
‫ﺝ(‪211212‬‬ ‫ﺍﻟﻒ( ‪111222‬‬
‫‪For C:=A To B Do‬‬
‫;)‪Write(B,A,C‬‬ ‫ﺩ(‪211222‬‬ ‫ﺏ( ‪112212‬‬

‫‪-٢٧‬ﺍﮔﺮ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻫﺎﻱ ﺯﻳﺮ ﺑﺮﺍﻱ ‪ A‬ﻣﻘﺪﺍﺭ ‪ 12‬ﻭﺍﺭﺩ ﺷﻮﺩ ﻛﺪﺍﻡ ﺧﻂ ﺩﺭ ‪ Loop‬ﻣﻲ ﺍﻓﺘﺪ؟‬
‫ﺏ( ‪1‬‬ ‫ﺍﻟﻒ( ‪ 1‬ﻭ ‪ 2‬ﻭ ‪3‬‬
‫;)‪Readln(A‬‬
‫;‪Repeat ; Until A>10‬‬ ‫}‪{1‬‬ ‫ﺩ(‪3‬‬ ‫ﺝ(‪2‬‬
‫; ‪For B:=1 To A Do‬‬ ‫}‪{2‬‬
‫}‪While A>0 Do ; A:=A-1; {3‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪67‬‬
‫ﺍﻧـﻮﺍﻉ ﺩﺍﺩﻩ ﻫﺎ ﺩﺭ ﭘﺎﺳﮑﺎﻝ ‪:‬‬
‫ﺻﺤﻴﺢ ﺑﻪ ﻏﻴﺮ ﺍﺯ ‪comp‬‬
‫ﮐﺎﺭﺍﮐﺘﺮﻱ)‪(Char‬‬
‫ﺑﻮﻟﻴﻦ)‪(Boolean‬‬ ‫‪ -۱‬ﺍﺳﮑﺎﻟﺮ‬
‫ﺯﻳﺮﻗﻠﻤﺮﻭ)‪(Sub Range‬‬
‫ﺷﻤﺎﺭﺷﻲ)‪(Enument‬‬ ‫‪ -۱‬ﺳﺎﺩﻩ‬

‫‪ -۲‬ﺍﻋﺸﺎﺭﻱ ﻭ ‪Comp‬‬

‫‪ - 1‬رﺷﺘﻪ ا ي‬
‫‪ - 2‬آراﯾﻪ اي‬
‫‪ -3‬رﮐﻮرد‬ ‫‪ - 2‬ﺳﺎﺧﺘﺎري‬
‫‪ - 4‬اﺷﺎره ﮔﺮ )ﻓﺎﯾﻠﻬﺎ(‬
‫‪ - 5‬ﭘﺮدازه اي‬

‫ﻧﮑﺘﻪ‪ :‬ﻧﻮﻉ ﺩﺍﺩﻩ ﺳﺎﺩﻩ ﻧﻮﻋﻲ ﺍﺳﺖ ﮐﻪ ﻗﺎﺑﻞ ﺗﻘﺴﻴﻢ ﺑﻪ ﻧﻮﻉ ﺩﺍﺩﻩ ﺩﻳﮕﺮﻱ ﻧﻴﺴﺖ ﻭ ﺧﻮﺩ ﺑﻪ ﺩﻭ ﮔﺮﻭﻩ ﺍﺳﮑﺎﻟﺮ ﻭ ﺍﻋﺸﺎﺭﯼ ﺗﻘﺴﯿﻢ ﻣﯽ ﺷﻮﺩ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻧﻮﻉ ﺍﺳﮑﺎﻟﺮ ﻧﻮﻉ ﺩﺍﺩﻩ ﺳﺎﺩﻩ ﺍﻱ ﺍﺳﺖ ﮐﻪ ﺩﺍﺭﺍﻱ ﺗﺮﺗﻴﺐ ﻭﺷﻤﺎﺭﺵ ﭘﺬﻳﺮ ﺑﺎﺷﺪ ﻭﻫﺮ ﻋﻀﻮ ﺁﻥ ﺩﺍﺭﺍﻱ ﻣﻘﺪﺍﺭ ﻗﺒﻠﻲ ﻭﺑﻌﺪﻱ ﺍﺳـﺖ‪.‬ﺍﻟﺒﺘـﻪ‬
‫ﺑﻪ ﺟﺰ ﺍﻭﻟﻴﻦ ﻣﻘﺪﺍﺭ ﮐﻪ ﻗﺒﻠﻲ ﻧﺪﺍﺭﺩ ﻭﺁﺧﺮﻳﻦ ﻣﻘﺪﺍﺭ ﮐﻪ ﺑﻌﺪﻱ ﻧﺪﺍﺭﺩ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺍﻭﻟﻴﻦ ﻋﻀﻮ ﻫﺮ ﻣﺠﻤﻮﻋﻪ ﺑﻪ ﺟﺰ ﻣﺠﻤﻮﻋﻪ ﺍﻋﺪﺍﺩ ﻋﻼﻣﺖ ﺩﺍﺭ ﺩﺍﺭﺍﻱ ﺷﻤﺎﺭﻩ ﺗﺮﺗﻴﺐ ﺻﻔﺮ ﺍﺳﺖ‪).‬ﻣﺮﺑﻮﻁ ﺑﻪ ﺗﺎﺑﻊ ‪(ORD‬‬
‫ﻧﻮﻉ ﺩﺍﺩﻩ ﺯﻳﺮ ﻗﻠﻤﺮﻭ)ﺯﻳﺮﺑﺎﺯﻩ(‪:‬‬
‫ﺯﻳﺮ ﻗﻠﻤﺮﻭ ﻣﺤﺪﻭﺩﻩ ﺍﻱ ﺍﺯ ﻣﻘﺎﺩﻳﺮ ﻳﮏ ﻧﻮﻉ ﺩﺍﺩﻩ ﺍﺳﮑﺎﻟﺮ ﺑﻪ ﻧﺎﻡ ﻣﻴﺰﺑﺎﻥ ﻣﻲ ﺑﺎﺷﺪ‪.‬ﻣﺘﻐﻴﺮﻫﺎﻳﯽ ﺍﺯ ﻧﻮﻉ ﺯﻳﺮﻗﻠﻤﺮﻭ ‪،‬ﺗﻤﺎﻡ ﺧﺼﻮﺻﻴﺎﺕ ﻣﺘﻐﻴﺮﯼ‬
‫ﺍﺯ ﻧﻮﻉ ﻣﻴﺰﺑﺎﻥ ﺭﺍ ﺩﺍﺭﻧﺪ ﻭ ﺑﻪ ﺍﻧﺪﺍﺯﻩ ﻧﻮﻉ ﻣﻴﺰﺑﺎﻥ ﻧﻴﺰ ‪ ،‬ﺣﺎﻓﻈﻪ ﺍﺷﻐﺎﻝ ﻣﯽ ﮐﻨﻨﺪ‪.‬‬
‫ﺩﺭ ﺗﻌﺮﻳﻒ ﻧﻮﻉ ﺯﻳﺮ ﻗﻠﻤﺮﻭ ﮐﺎﻓﯽ ﺍﺳﺖ ﺍﻭﻟﻴﻦ)ﮐﻮﭼﮑﺘﺮﻳﻦ( ﻭ ﺁﺧﺮﻳﻦ)ﺑﺰﺭﮔﺘﺮﻳﻦ( ﻣﻘـﺪﺍﺭ ﻣﺠﻤﻮﻋـﻪ ﺭﺍ ﻣﻌـﻴﻦ ﮐﻨﻴـﺪ ﺗـﺎ ﺑـﻪ ﺍﻳـﻦ ﻃﺮﻳـﻖ ‪،‬‬
‫ﻣﺤﺪﻭﺩﻩ ﺑﻴﻦ ﺁﻥ ﺩﻭ ﺑﻪ ﻋﻨﻮﺍﻥ ﻧﻮﻉ ﺯﻳﺮ ﻗﻠﻤﺮﻭ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﺷﻮﺩ‪.‬‬
‫ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﻳﮏ ﻣﺘﻐﻴﺮ ﺯﻳﺮ ﻗﻠﻤﺮﻭ ‪ ۲‬ﺭﻭﺵ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪:‬‬
‫ﺍﻟﻒ(ﺩﺭ ﺭﻭﺵ ﺍﻭﻝ ﺩﺭ ﻗﺴﻤﺖ ‪ VAR‬ﺑﻪ ﺭﻭﺵ ﺯﻳﺮ ﻋﻤﻞ ﻣﻲ ﮐﻨﻴﻢ‪:‬‬
‫‪VAR‬‬
‫; ﺛﺎﺑﺖ ﺩﻭﻡ ‪ ..‬ﺛﺎﺑﺖ ﺍﻭﻝ ‪ :‬ﻧﺎﻡ ﻣﺘﻐﻴﺮ‬
‫‪ -‬ﺛﺎﺑﺖ ﺍﻭﻝ ﻫﻤﻮﺍﺭﻩ ﺑﺎﻳﺪ ﮐﻮﭼﮑﺘﺮ ﻳﺎ ﻣﺴﺎﻭﻱ ﺛﺎﺑﺖ ﺩﻭﻡ ﺑﺎﺷﺪ‪.‬‬
‫‪ -‬ﺛﺎﺑﺖ ﺍﻭﻝ ﻭ ﺛﺎﺑﺖ ﺩﻭﻡ ﺑﺎﻳﺪ ﺍﺳﮑﺎﻟﺮ ﺑﺎﺷﺪ‪.‬‬
‫‪ -‬ﺛﺎﺑﺖ ﺍﻭﻝ ﺛﺎﺑﺖ ﺩﻭﻡ ﻣﻲ ﺗﻮﺍﻧﻨﺪ ﺛﺎﺑﺖ ﺑﺪﻭﻥ ﻧﻮﻉ ﺑﺎﺷﻨﺪ‪.‬‬
‫ﺏ( ﺩﺭ ﺭﻭﺵ ﺩﻭﻡ ﺗﻌﺮﻳﻒ ﺯﻳﺮ ﻗﻠﻤﺮﻭ ﺍﺑﺘﺪﺍ ﺩﺭ ﻗﺴﻤﺖ ‪ Type‬ﻧﻮﻉ ﺯﻳﺮ ﻗﻠﻤﺮﻭ ﺭﺍ ﺗﻌﺮﻳﻒ ﻣﻲ ﮐﻨﻴﻢ ﺳﭙﺲ ﺩﺭ ﻗﺴﻤﺖ ‪ VAR‬ﻣﺘﻐﻴﺮ ﺭﺍ ﺍﺯ‬
‫ﻫﻤﺎﻥ ﻧﻮﻉ ﺗﻌﺮﻳﻒ ﻣﻲ ﮐﻨﻴﻢ‪ .‬ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ‪:‬‬
‫‪Type‬‬
‫; ﺛﺎﺑﺖ ﺩﻭﻡ ‪ ..‬ﺛﺎﺑﺖ ﺍﻭﻝ = ﻧﺎﻡ ﻧﻮﻉ‬
‫‪Var‬‬
‫; ﻧﺎﻡ ﻧﻮﻉ ‪ :‬ﻧﺎﻡ ﻣﺘﻐﻴﺮ‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪68‬‬
‫ﺩﺭ ﭘﺎﺳﮑﺎﻝ ﻣﻲ ﺗﻮﺍﻥ ﺩﺭ ﻗﺴﻤﺖ ﺗﻌﺎﺭﻳﻒ ﺩﺭ ‪ Type‬ﻧﻮﻉ ﺧﺎﺻﻲ ﺭﺍ ﺗﻌﺮﻳﻒ ﮐﺮﺩ ﻣﺜﻼ ﻣﻲ ﺗﻮﺍﻥ ﻧﻮﻉ ﺩﺍﺩﻩ ﻫﺎﻱ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺭﺍ ﺗﻐﻴﻴﺮ ﻧﺎﻡ ﺩﺍﺩ‪.‬‬
‫ﻣﺜﺎﻝ(‬
‫‪Type‬‬
‫;‪Myint=integer‬‬
‫‪Var‬‬
‫; ‪A: myint‬‬
‫ﺩﺭ ﻗﺴﻤﺖ ‪ Type‬ﻣﻲ ﺗﻮﺍﻥ ﻧﻮﻉ ﺯﻳﺮ ﻗﻠﻤﺮﻭ‪ ،‬ﺷﻤﺎﺭﺷﻲ‪ ،‬ﺁﺭﺍﻳﻪ ﺭﮐﻮﺭﺩ ﻧﻴﺰ ﺗﻌﺮﻳﻒ ﮐﺮﺩ‪.‬‬

‫ﻣﻴـﺰﺑﺎﻥ‪:‬‬
‫ﻫﺮ ﻧﻮﻉ ﺯﻳﺮﻗﻠﻤﺮﻭﻳﻲ ﺩﺍﺭﺍﻱ ﻳﮏ ﻣﻴﺰﺑﺎﻥ ﺍﺳﺖ ﺍﻳﻦ ﻣﻴﺰﺑﺎﻥ ﺗﻮﺳﻂ ﻣﺘﺮﺟﻢ ﭘﺎﺳﮑﺎﻝ ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮﺩ ﺑﻪ ﻃﻮﺭﻱ ﮐﻪ ﻣﺤﺪﻭﺩﻩ ﺭﺍ ﺷـﺎﻣﻞ ﺷـﻮﺩ‬
‫ﻭﮐﻤﺘﺮﻳﻦ ﻓﻀﺎ ﺭﺍ ﺍﺷﻐﺎﻝ ﮐﻨﺪ ﻭ ﻧﯿﺰ ﺍﺳﮑﺎﻟﺮ ﺑﺎﺷﺪ‪).‬ﺍﮔﺮ ﺩﻭ ﻧﻮﻉ ﻓﻀﺎﻱ ﻳﮑﺴﺎﻧﻲ ﺩﺍﺭﻧﺪ ﻭ ﻣﺤـﺪﻭﺩﻩ ﺭﺍ ﻧﻴـﺰ ﺷـﺎﻣﻞ ﻣـﻲ ﺷـﻮﻧﺪ ﭘﺎﺳـﮑﺎﻝ ﻧـﻮﻋﻲ ﺭﺍ‬
‫ﺍﻧﺘﺨﺎﺏ ﻣﻲ ﮐﻨﺪ ﮐﻪ ﻣﻨﻔﻲ ﻫﺎ ﺭﺍ ﻧﻴﺰ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪(.‬‬
‫ﻣﺜﺎﻝ(‬
‫‪Const‬‬
‫;‪H=20‬‬
‫‪Type‬‬
‫;‪Sub=0 .. H‬‬
‫‪Var‬‬
‫; ‪A: sub‬‬
‫;‪Z:integer‬‬
‫‪Begin‬‬
‫;‪A:=25‬‬ ‫ﺧﻄﺎﻱ ﺯﻣﺎﻥ ﺗﺮﺟﻤﻪ )‪(constant out of range‬‬
‫;‪Z:=40‬‬
‫;‪A:=Z‬‬
‫;‪A:=A+25‬‬
‫;)‪Readln(A‬‬
‫;)‪Writeln(A‬‬
‫‪End.‬‬
‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺭﺍﺩﺭ ﺩﻭﺣﺎﻟﺖ ﺑﺮﺭﺳﻲ ﻣﻲ ﮐﻨﻴﻢ ﺍﺑﺘﺪﺍ ﺩﺭ ﺣﺎﻟﺘﻲ ﮐﻪ ﺑﺮﻧﺎﻣﻪ‪,‬ﺩﺭ ﺣﺎﻝ ﺗﺮﺟﻤﻪ ﺍﺳﺖ ﻳﻌﻨﻲ ﺩﺳﺘﻮﺭﺍﺕ ﺍﺟﺮﺍ ﻧﻤـﻲ ﺷـﻮﻧﺪ‬
‫ﺑﻠﮑﻪ ﺗﺮﺟﻤﻪ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﺧﻂ ;‪ A:=25‬ﻏﻠﻂ ﺍﺳﺖ ﺯﻳﺮﺍ ﺩﺭ ﺣﺎﻟﺖ ﺗﺮﺟﻤﻪ ﻧﻤﻲ ﺗﻮﺍﻥ ﻳﮏ ﺛﺎﺑﺖ ﺭﺍ ﮐﻪ ﺍﺯ ﻣﺤﺪﻭﺩﺓ ﺯﻳـﺮ ﻗﻠﻤـﺮﻭ ﺧـﺎﺭﺝ ﺍﺳـﺖ ﺭﺍ‬
‫ﺩﺍﺧﻞ ﻣﺘﻐﻴﺮ ‪ A‬ﺭﻳﺨﺖ‪ .‬ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﭘﻴﻐﺎﻡ ﺧﻄﺎﻱ ‪ constant out of range‬ﻇﺎﻫﺮ ﻣﻲ ﺷﻮﺩ‪ .‬ﺍﻣﺎ ﺩﺭ ﻟﺤﻈـﻪ ﺗﺮﺟﻤـﻪ ﺩﺳـﺘﻮﺭ;‪A:=Z‬‬
‫ﺧﻄﺎ ﻧﻴﺴﺖ ﺯﻳﺮﺍ ﺩﺭ ﻟﺤﻈﻪ ﺗﺮﺟﻤﻪ ﻣﻘﺪﺍﺭ ﺩﻫﻲ ﺍﻧﺠﺎﻡ ﻧﻤﻲ ﺷﻮﺩ‪ .‬ﺣﺎﻝ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺩﺭ ﺣﺎﻟﺖ ﺍﺟﺮﺍ ﺑﺮﺭﺳﻲ ﻣﻲ ﮐﻨﻴﻢ‪ :‬ﻫﻨﮕﺎﻣﻲ ﮐﻪ ﺑﺮﻧﺎﻣﻪ ﺍﺟﺮﺍ ﻣﻲ‬
‫ﺷﻮﺩ ﻣﺘﻐﻴﺮ ﻫﺎﻱ ﺍﺯ ﻧﻮﻉ ﺯﻳﺮ ﻗﻠﻤﺮﻭ ﺧﺼﻮﺻﻴﺎﺕ ﻣﻴﺰﺑﺎﻧﺸﺎﻥ ﺭﺍ ﭘﻴﺪﺍ ﻣﻲ ﮐﻨﻨﺪ ﻣﺜﻼ ﻣﺘﻐﻴﺮ ‪ A‬ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺫﮐﺮ ﺷـﺪﻩ ﺩﺭ ﺣﺎﻟـﺖ ﺍﺟـﺮﺍ ﻣﺎﻧﻨـﺪ ﻳـﮏ‬
‫ﻣﺘﻐﻴﺮ ‪ shortint‬ﻋﻤﻞ ﻣﻲ ﮐﻨﺪ ﺑﻨﺎﺑﺮﺍﻳﻦ ﺩﺳﺘﻮﺭ ;‪ A:=Z‬ﺧﻄﺎ ﻧﻴﺴﺖ ﻭ ﺩﺍﺧﻞ ﻣﺘﻐﻴﺮ ‪ A‬ﻋـﺪﺩ ‪ ۴۰‬ﺭﻳﺨﺘـﻪ ﻣـﻲ ﺷـﻮﺩ ﻭ ﺍﮔـﺮ ﺑـﺮﺍﻱ ﺩﺳـﺘﻮﺭ‬
‫)‪ readln(A‬ﻋﺪﺩﻱ ﺧﺎﺭﺝ ﺍﺯ ﻣﺤﺪﻭﺩﻩ ﻭﺍﺭﺩ ﮐﻨﻴﻢ ﺑﺎﺯﻫﻢ ﺧﻄﺎ ﺻﻮﺭﺕ ﻧﻤﻲ ﮔﻴﺮﺩ ﺑﻠﮑﻪ ﺳﺮﺭﻳﺰﻱ ﺭﺥ ﻣﻲ ﺩﻫﺪ‪).‬ﺳﺮﺭﻳﺰﻱ ﺧﻄﺎ ﻧﻴﺴﺖ(‬
‫ﺑﺎ ﺍﻳﻦ ﺗﻮﺿﻴﺤﺎﺕ ﻫﻴﭻ ﻣﺤﺪﻭﺩﻩ ﺍﻱ ﺑﺮﺍﻱ ﻣﺘﻐﻴﺮﻫﺎﻱ ﺯﻳﺮﻗﻠﻤﺮﻭ ﮐﻨﺘﺮﻝ ﻧﻤﻲ ﺷﻮﺩ ﺑﺮﺍﻱ ﺭﻓﻊ ﺍﻳﻦ ﻣﺸﮑﻞ ﺍﺯ ﺭﻫﻨﻤﻮﺩ }‪ {$R+‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ‬
‫ﮐﻨﻴﻢ ﺍﻳﻦ ﺭﻫﻨﻤﻮﺩ ﺑﺎﻋﺚ ﻣﻲ ﺷﻮﺩ ﻣﺤﺪﻭﺩﺓ ﻣﺘﻐﻴﺮﻫﺎ ﮐﻨﺘﺮﻝ ﺷﻮﺩ‪.‬ﻳﻌﻨﻲ ﺍﮔﺮ ﺍﺯ ﻣﺤﺪﻭﺩﺓ ﺯﻳﺮ ﻗﻠﻤﺮﻭ ﺧﺎﺭﺝ ﺷـﺪﻳﻢ ﭘﻴﻐـﺎﻡ ﺧﻄـﺎ ﺻـﺎﺩﺭ ﻣـﻲ‬
‫ﺷﻮﺩ‪).‬ﺩﺭ ﺯﻣﺎﻥ ﺍﺟﺮﺍ( ﺣﺘﻲ ﺍﮔﺮ ﺳﺮﺭﻳﺰﻱ ﻧﻴﺰ ﺭﺥ ﺩﻫﺪ ﺑﺎﺯ ﻫﻢ ﺧﻄﺎ ﺧﻮﺍﻫﺪ ﮔﺮﻓﺖ‪.‬‬
‫ﻧﮑﺘﻪ( ﺩﻭﺗﺎﺑﻊ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ‪ low‬ﻭ ‪ high‬ﮐﻤﺘﺮﻳﻦ ﻭﺑﻴﺸﺘﺮﻳﻦ ﻣﻘﺪﺍﺭ ﻳﮏ ﻧﻮﻉ ﺩﺍﺩﻩ ﺍﺳﮑﺎﻟﺮ ﺭﺍ ﺑﺮﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬
‫ﮐﺎﺭﺑﺮﺩ ﺯﻳﺮﻗﻠﻤـﺮﻭ ‪:‬‬
‫ﺯﻳﺮﻗﻠﻤﺮﻭﻫﺎ ﺭﺍ ﺑﻴﺸﺘﺮ ﺑﺮﺍﻱ ﮐﻨﺘﺮﻝ ﻣﺤﺪﻭﺩﻩ ﻣﺘﻐﻴﺮﻫﺎ ﺑﻪ ﮐﺎﺭ ﻣﻲ ﺑﺮﻧﺪ ﻭ ﺩﺍﺭﺍﻱ ﻣﺰﺍﻳﺎﻱ ﺯﻳﺮ ﺍﺳﺖ‪:‬‬
‫‪-۱‬ﮐﻨﺘﺮﻝ ﻣﺤﺪﻭﺩﺓ ﻣﺘﻐﻴﺮ ﻫﺎ ﻭﺻﺪﻭﺭ ﭘﻴﻐﺎﻡ ﺧﻄﺎ ﺗﻮﺳﻂ ﻣﺘﺮﺟﻢ‬
‫‪ -۲‬ﭼﻮﻥ ﻧﻮﻉ ﻣﻴﺰﺑﺎﻥ ﺭﺍ ﭘﺎﺳﮑﺎﻝ ﺍﻧﺘﺨﺎﺏ ﻣﻲ ﮐﻨﺪ ﮐﻤﺘﺮﻳﻦ ﻓﻀﺎ ﺭﺍ ﺍﺷﻐﺎﻝ ﻣﻲ ﮐﻨﺪ ﻭﺩﺭ ﻣﺼﺮﻑ ﺣﺎﻓﻈﻪ ﺻﺮﻑ ﺟﻮﻳﻲ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪ -۳‬ﺯﻳﺮﻗﻠﻤﺮﻭﻫﺎ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﺑﺎ ﻣﻌﻨﻲ ﻫﺴﺘﻨﺪ ﻭﺧﻮﺍﻧﺎﻳﻲ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺑﺎﻻ ﻣﻲ ﺑﺮﻧﺪ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪69‬‬
‫ﻧـﻮﻉ ﺩﺍﺩﻩ ﺷﻤﺎﺭﺷﻲ‪:‬‬
‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ ﺗﻮﺍﻧﺪ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻣﻮﺿﻮﻉ ﺑﺮﻧﺎﻣﻪ ﺗﻌﺪﺍﺩﻱ ﺷﻨﺎﺳﻪ)ﻧﻪ ﺭﺷﺘﻪ ‪ ،‬ﻧﻪ ﻋﺪﺩﻭ ﻧﻪ ﺛﺎﺑﺖ( ﺭﺍ ﺩﺭ ﻳﮏ ﻧﻮﻉ ﺷﻤﺎﺭﺷﻲ ﻗﺮﺍﺭ ﺩﻫﺪ‪.‬‬
‫ﻣﺜﺎﻝ(‬
‫‪Type‬‬
‫;)‪EnuA=(sat , sun , mon , tue‬‬
‫‪Var‬‬
‫;‪A:EnuA‬‬
‫‪Begin‬‬
‫;‪A:=sun‬‬
‫‪End.‬‬
‫‪ ü‬ﻧﮑﺘﻪ‪ :‬ﺷﻨﺎﺳﻪ ﻫﺎﻳﻲ ﮐﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺗﻌﻴﻦ ﻣﻲ ﮐﻨﺪ ﺑﺎﻳﺪ ﺗﺎﺑﻊ ﻧﺎﻡ ﮔﺬﺍﺭﻱ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻏﻴﺮ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺑﺎﺷﺪ‪.‬‬
‫‪ ü‬ﻧﮑﺘﻪ‪ :‬ﻣﺘﻐﻴﺮ ﻫﺎﻱ ﻧﻮﻉ ﺷﻤﺎﺭﺷﻲ ﻫﻤﻴﺸﻪ ﻳﮏ ﺑﺎﻳﺖ ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﻣﻲ ﮐﻨﻨﺪ‪.‬‬
‫‪ ü‬ﻧﮑﺘﻪ‪ :‬ﺗﻌﺪﺍﺩ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻧﻮﻉ ﺩﺍﺩﻩ ﺷﻤﺎﺭﺷﻲ ﺣﺪﺍﮐﺜﺮ ‪ ۲۵۶‬ﺗﺎ ﺍﺳﺖ‪.‬‬
‫‪ ü‬ﻧﮑﺘﻪ‪ :‬ﺑﺮﺍﻱ ﻧﺎﻣﮕﺬﺍﺭﻱ ﻣﺘﻐﻴﺮﻫﺎﻱ ﺷﻤﺎﺭﺷﻲ ﻣﻌﻤﻮﻻ ﭘﻴﺸﻮﻧﺪ ‪ Enu‬ﺑﻪ ﮐﺎﺭ ﻣﻲ ﺭﻭﺩ‪.‬‬
‫‪ ü‬ﻧﮑﺘﻪ‪ :‬ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻣﻮﺟﻮﺩ ﺩﺭ ﻧﻮﻉ ﺩﺍﺩﻩ ﺷﻤﺎﺭﺷﻲ ﻧﺒﺎﻳﺪ ﺗﮑﺮﺍﺭﻱ ﺑﺎﺷﻨﺪ‬
‫‪type‬‬
‫ﺧﻄﺎﺳﺖ ;)‪enuDAY=(sat,sun,sat,mon‬‬
‫‪ ü‬ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻣﻮﺟﻮﺩ ﺩﺭ ﻧﻮﻉ ﺷﻤﺎﺭﺷﻲ ﺑﻪ ﺗﺮﺗﻴﺐ ﺩﺍﺭﺍﻱ ﺭﺗﺒﻪ ﻫﺎﻱ ‪ ۰‬ﻭ ‪ ۱‬ﻭ‪...‬ﻭ ‪ ۲۵۵‬ﺍﺳﺖ‪.‬‬
‫ﻣﺜﺎﻝ(‬

‫‪Type‬‬
‫;)‪EnuB=(red,green,blue,black‬‬
‫‪Var‬‬
‫;‪X,Z:EnuB‬‬
‫;‪A:integer‬‬
‫‪Begin‬‬
‫ﺻﺤﻴﺢ ‪-‬ﺯﻳﺮﺍ ﺩﺭ ﻣﺘﻐﻴﺮ ﻧﻮﻉ ﺷﻤﺎﺭﺷﻲ ﻓﻘﻂ ﻣﻲ ﺗﻮﺍﻥ ﺷﻨﺎﺳﻪ ﻫﺎﻱ ﻣﺮﺑﻮﻁ ﺑﻪ ﺧﻮﺩﺵ ﺭﺍ ﻗﺮﺍﺭ ﺩﺍﺩ ‪z:=blue; ž‬‬
‫‪z:='black'; ž‬‬ ‫ﻏﻠﻂ ‪ -‬ﺯﻳﺮﺍ ﺭﺷﺘﻪ ﺍﺳﺖ‬
‫ﻏﻠﻂ ‪z:=1; ž‬‬
‫ﺻﺤﻴﺢ ‪a:=0; ž‬‬
‫ﻏﻠﻂ ‪ -‬ﻋﻤﻞ ﺍﻧﺘﺴﺎﺏ ﺩﺭ ﺻﻮﺭﺗﻲ ﺻﺤﻴﺢ ﺍﺳﺖ ﮐﻪ ﻫﺮ ﺩﻭ ﻣﺘﻐﻴﺮ ﻫﻢ ﻧﻮﻉ ﺑﺎﺷﻨﺪ ‪z:=a; ž‬‬
‫‪a:=z; ž‬‬ ‫ﻏﻠﻂ‬
‫‪z:=x; ž‬‬ ‫ﺻﺤﻴﺢ‬
‫ﺻﺤﻴﺢ ‪z:=pred(blue); ž‬‬
‫ﺻﺤﻴﺢ ‪a:=ord(z); ž‬‬
‫ﻏﻠﻂ ‪ -‬ﻣﺘﻐﻴﺮﻫﺎﻱ ﺷﻤﺎﺭﺷﻲ ﻭﺷﻨﺎﺳﻪ ﻫﺎﻱ ﺁﻧﻬﺎ ﺭﺍ ﻧﻪ ﻣﻲ ﺗﻮﺍﻥ ﭼﺎﭖ ﮐﺮﺩ ﻭﻧﻪ ﻣﻴﺘﻮﺍﻥ ﺩﺭﻳﺎﻓﺖ ﮐﺮﺩ ‪writeln(z); ž‬‬
‫ﻏﻠﻂ ‪writeln(blue); ž‬‬
‫‪readln(z); ž‬‬ ‫ﻏﻠﻂ‬
‫ﺻﺤﻴﺢ ‪ -‬ﺭﺗﺒﻪ ﻣﺘﻐﻴﺮ ﻫﺎﻱ ﺷﻤﺎﺭﺷﻲ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﭼﺎﭖ ﮐﺮﺩ ‪write(ord(z)); ž‬‬
‫ﻏﻠﻂ ‪writeln(succ(green)); ž‬‬
‫‪end.‬‬

‫ﮐﺎﺭﺑـﺮﺩ ! ﻧﻮﻉ ﺩﺍﺩﻩ ﺷﻤﺎﺭﺷﻲ ‪:‬‬

‫ﺩﺍﺩﻩ ﻫﺎﻱ ﻧﻮﻉ ﺷﻤﺎﺭﺷﻲ ﻓﻘـﻂ ﺑﺮﺍﻱ ﺍﻓﺰﺍﻳﺶ ﺧﻮﺍﻧﺎﻳﻲ ﺑﺮﻧﺎﻣﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪70‬‬
‫ﻣﺠﻤﻮﻋـﻪ ﻫﺎ )‪: (Sets‬‬
‫ﺗﻌﺪﺍﺩ ﻣﺤﺪﻭﺩﻱ ﺍﺯ ﺩﺍﺩﻩ ﻫﺎ ﻛﻪ ﺍﺯ ﻧﻈﺮ ﻧﻮﻉ ﻳﻜﺴﺎﻥ ﻫﺴﺘﻨﺪ ‪ ،‬ﺩﺭ ﻗﺎﻟﺐ ﻣﺠﻤﻮﻋﻪ ﻧﮕﻬـﺪﺍﺭﻱ ﻣـﻲ ﺷـﻮﻧﺪ ﻛـﻪ ﻣﻔﻬـﻮﻣﻲ ﺷـﺒﻴﻪ ﻣﺠﻤﻮﻋـﻪ ﻫـﺎ ﺩﺭ‬
‫ﺭﻳﺎﺿﻴﺎﺕ ﺩﺍﺭﻧﺪ‪.‬‬
‫ﻣﺠﻤﻮﻋﻪ ﻣﺘﻐﻴﺮﻱ ﺍﺳﺖ ﻛﻪ ﺷﺎﻣﻞ ﻟﻴﺴﺘﻲ ﺍﺯ ﺍﻋﺪﺍﺩ ﺻﺤﻴﺢ ‪ ،‬ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﻭ ﺑﻮﻟﻴﻦ ﻭ ﺑﻬﺘﺮ ﺍﺳﺖ ﺑﮕﻮﻳﻴﻢ ﻛـﻼ ﺩﺍﺩﻩ ﻫـﺎﻱ ﺍﺳـﻜﺎﻟﺮ ﻣـﻲ ﺑﺎﺷـﺪ ﻛـﻪ‬
‫ﺩﺍﺭﺍﻱ ﺗﻌﺪﺍﺩ ﻋﻨﺎﺻﺮ ﻣﺤﺪﻭﺩ ﺑﻪ ﺣﺪﺍﻛﺜﺮ ‪ ۲۵۶‬ﺗﺎ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫ﻣﺠﻤﻮﻋﻪ ﺍﺯ ﺍﻳﻦ ﺟﻬﺖ ﻛﻪ ﺷﺎﻣﻞ ﺩﺍﺩﻩ ﻫﺎﻳﻲ ﺍﺯ ﻳﻚ ﻧﻮﻉ ﻣﻲ ﺑﺎﺷﺪ ﺷﺒﻴﻪ ﺑﻪ ﻳﻚ ﺁﺭﺍﻳﻪ ﻣﻲ ﺑﺎﺷﺪ ﻭﻟﻲ ﺁﺭﺍﻳﻪ ﺩﺍﺭﺍﻱ ﻋﻨﺎﺻﺮ ﻣﺤﺪﻭﺩﻱ ﻧﻴﺴﺖ ﻭ ﺩﺭ‬
‫ﺿﻤﻦ ﻣﺎﻧﻨﺪ ﺁﺭﺍﻳﻪ ﺗﻌﺮﻳﻒ ﻧﻤﻲ ﺷﻮﺩ‪.‬‬

‫ﺗﻌـﺮﯾﻒ ﻣﺠﻤﻮﻋﻪ ‪:‬‬

‫ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﻳﻚ ﻣﺠﻤﻮﻋﻪ ﺍﺯ ﻛﻠﻤﺎﺕ ﻛﻠﻴﺪﻱ ‪ Set of‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ ﺩﺭ ﺯﻳﺮ ﻧﻤﻮﻧﻪ ﻫﺎﻳﻲ ﺍﺯ ﺗﻌـﺎﺭﻳﻒ ﻣﺠﻤﻮﻋـﻪ ﻫـﺎﻱ ﻣﺨﺘﻠـﻒ ﺁﻣـﺪﻩ‬
‫ﺍﺳﺖ ‪:‬‬
‫‪Var‬‬
‫; ‪S:= set of 0..10‬‬
‫; ‪C:= set of char‬‬
‫; ‪B := set of boolean‬‬
‫; ‪G:= array [1..5] of set of 1..10‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬
‫ﻣﺠﻤﻮﻋﻪ‬ ‫ﻣﺠﻤﻮﻋﻪ‬ ‫ﻣﺠﻤﻮﻋﻪ‬ ‫ﻣﺠﻤﻮﻋﻪ‬ ‫ﻣﺠﻤﻮﻋﻪ‬

‫ﺣﺎﻝ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺗﻌﺎﺭﻳﻒ ﺑﺎﻻ ﺩﺭ ﺩﺍﺧﻞ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﻣﻘﺪﺍﺭ ﺩﻫﻲ ﻫﺎﻱ ﺯﻳﺮ ﺭﺍ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ‪:‬‬
‫; ]‪S := [2‬‬
‫; ]‪S := [2,1,4,5,2‬‬
‫; ]‪S := [1..4 , 8‬‬
‫; ]'‪C := ['a' , 'b' , 'c' , 'd‬‬
‫; ]‪G[1] := [1,2,3‬‬
‫ﻣﺠﻤﻮﻋﻪ ﺗﻬﻲ ; ][ =‪G[2] :‬‬
‫ﻧﻜﺘﻪ ( ﻣﺠﻤﻮﻋﻪ ﺗﻬﻲ ﻣﺠﻤﻮﻋﻪ ﺍﻱ ﺍﺳﺖ ﻛﻪ ﻫﻴﭻ ﻋﻀﻮﻱ ﻧﺪﺍﺭﺩ ﻭ ﺑﺎ ][ ﻧﺸﺎﻥ ﺩﺍﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ ( ﺗﻜﺮﺍﺭ ﻋﻀﻮ ﺩﺭ ﻣﺠﻤﻮﻋﻪ ﻫﺎ ﺗﺎﺛﻴﺮﻱ ﻧﺪﺍﺭﺩ ﻭ ﻋﻀﻮﻫﺎﻱ ﺗﻜﺮﺍﺭﻱ ﻓﻘﻂ ﻳﻚ ﻋﻀﻮ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﻧﻜﺘﻪ ( ﺟﺎﺑﺠﺎﻳﻲ ﻋﻀﻮﻫﺎ ﺩﺭ ﻳﻚ ﻣﺠﻤﻮﻋﻪ ﺗﺎﺛﻴﺮﻱ ﻧﺪﺍﺭﺩ‪.‬ﻳﻌﻨﻲ ﺩﻭ ﻣﺠﻤﻮﻋﻪ ﺍﻱ ﻛﻪ ﺍﻋﻀﺎﻳﺸﺎﻥ ﻳﻜـﺴﺎﻥ ﺍﺳـﺖ ﻭﻟـﻲ ﺟﺎﺑﺠـﺎ ﻫـﺴﺘﻨﺪ ﻣـﺴﺎﻭﻱ‬
‫ﻫﺴﺘﻨﺪ ﺑﺎ ﻫﻢ ‪.‬‬
‫ﺗﻌﺎﺭﻳﻒ ﺯﻳﺮ ﺑﺮﺍﻱ ﻣﺠﻤﻮﻋﻪ ﻫﺎ ﺩﺭﺳﺖ ﻫﺴﺘﻨﺪ ‪:‬‬
‫‪Var‬‬
‫; ‪Ch : set of char‬‬
‫; ‪Bool : set of boolean‬‬
‫; ‪Num : set of byte‬‬
‫; ‪X : set of 100..200‬‬
‫; '‪Y : set of 'a'..'z‬‬
‫; '‪Z : set of '0'..'9‬‬
‫ﺗﻌﺎﺭﻳﻒ ﺯﻳﺮ ﺑﺮﺍﻱ ﻣﺠﻤﻮﻋﻪ ﻫﺎ ﻧﺎﺩﺭﺳﺖ ﻫﺴﺘﻨﺪ ‪:‬‬
‫‪Var‬‬
‫; ‪R : set of real‬‬
‫; ‪I : set of integer‬‬
‫; ‪S : set of string‬‬
‫; ‪X : set of 6..0‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪71‬‬
‫ﻋﻤﻠﯿﺎت روي ﻣﺠﻤﻮﻋـﻪ ﻫﺎ ‪:‬‬
‫ﻋﻤﻞ ﻋﻀﻮﻳﺖ ﻣﺘﻐﻴﺮ ﺩﺭ ﻣﺠﻤﻮﻋﻪ ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺑﺎ ﻛﻠﻤﻪ ﻱ ﻛﻠﻴﺪﻱ ‪ In‬ﺻﻮﺭﺕ ﻣﻲ ﮔﻴﺮﺩ‪ .‬ﺍﮔﺮ ﻋﻀﻮﻳﺖ ﺻﺤﻴﺢ ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﺁﻥ ﻣﺘﻐﻴﺮ ﺩﺭ‬
‫ﻣﺠﻤﻮﻋﻪ ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﺟﻮﺍﺏ ‪ True‬ﻭ ﺩﺭ ﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ ‪ False‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫ﻫﻤﭽﻨﻴﻦ ﺩﻭ ﻣﺠﻤﻮﻋﻪ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﺎ ﻋﻼﻣﺖ ﻫﺎﻱ ﺷﺮﻃﻲ = و >< و =< و => ﻣﻘﺎﻳﺴﻪ ﻛﺮﺩ ﻛﻪ ﻫﻤﮕﻲ ﺩﺍﺭﺍﻱ ﺧﺮﻭﺟـﻲ ﺩﺭﺳـﺖ ﻳـﺎ ﻏﻠـﻂ‬
‫ﻣﻲ ﺑﺎﺷﻨﺪ ‪ .‬ﻭﻟﻲ ﻋﻼﻣﺖ ﻫﺎﻱ > ‪ < ,‬ﺩﺭ ﻣﺠﻤﻮﻋﻪ ﻫﺎ ﻛﺎﺭﺑﺮﺩﻱ ﻧﺪﺍﺭﻧﺪ‪.‬‬
‫‪Var‬‬
‫; ‪A: set of byte‬‬
‫‪Begin‬‬
‫; ]‪A := [1..3,4‬‬
‫‪If 3 in a then‬‬
‫)'*'(‪Write‬‬
‫‪Else‬‬
‫;)'**'( ‪Write‬‬
‫; ) ‪Write ( 3 in a‬‬ ‫‪: True‬ﺟﻮﺍﺏ‬
‫; ) ‪Write ( 8 in a‬‬ ‫‪: False‬ﺟﻮﺍﺏ‬
‫; ) ‪Write ( [1,2,3,4] = a‬‬ ‫‪: True‬ﺟﻮﺍﺏ‬
‫; ) ]‪Write ( [1,2] <= [1,2,3‬‬ ‫‪: True‬ﺟﻮﺍﺏ‬
‫; ) ]‪Write ( [] >= [1‬‬ ‫‪: False‬ﺟﻮﺍﺏ‬
‫‪End.‬‬

‫ﺩﺭ ﺭﻳﺎﺿﻴﺎﺕ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﻣﺠﻤﻮﻋﻪ ﻫﺎ ﺭﺍ ﺑﺎ ﻫﻢ ﺍﺟﺘﻤﺎﻉ ‪ ،‬ﺍﺷﺘﺮﺍﻙ ﻭ ﺗﻔﺎﺿﻞ ﻛﻨﻴﻢ ﻛﻪ ﺍﻳﻦ ﻋﻤﻠﻴﺎﺕ ﺩﺭ ﭘﺎﺳﻜﺎﻝ ﺑﻪ ﺗﺮﺗﻴﺐ ﺑﺎ ‪:‬‬
‫ﻋﻤﻠﮕﺮﻫﺎﻱ ‪ +‬و * و – ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﺍﺟﺘﻤﺎﻉ ﺩﻭ ﻣﺠﻤﻮﻋﻪ ‪ :‬ﺗﺮﻛﻴﺒﻲ ﺍﺯ ﻫﻤﻪ ﻋﻀﻮﻫﺎﻱ ﺩﻭ ﻣﺠﻤﻮﻋﻪ‬

‫ﺍﺷﺘﺮﺍﻙ ﺩﻭ ﻣﺠﻤﻮﻋﻪ ‪ :‬ﻋﻀﻮﻫﺎﻳﻲ ﻛﻪ ﺩﺭ ﻫﺮ ﺩﻭ ﻣﺠﻤﻮﻋﻪ ﻣﺸﺘﺮﻙ ﺍﺳﺖ‪.‬‬
‫ﺗﻔﺎﺿﻞ ﺩﻭ ﻣﺠﻤﻮﻋﻪ ‪ :‬ﺍﻋﻀﺎﻳﻲ ﻛﻪ ﺩﺭ ﻣﺠﻤﻮﻋﻪ ﺍﻭﻝ ﻫﺴﺖ ﻭ ﺩﺭ ﻣﺠﻤﻮﻋﻪ ﺩﻭﻡ ﻧﻴﺴﺖ‪.‬‬
‫‪Var‬‬
‫; ‪a , c , d ,e : set of byte‬‬
‫; ‪b : set of 0..10‬‬
‫‪begin‬‬
‫; ]‪a:= [0,1,2,3‬‬
‫; ]‪b:= [2,3,4,5‬‬
‫; ‪c:= a+b‬‬ ‫]‪c = [0,1,2,3,4,5‬‬
‫; ‪d:= a*b‬‬ ‫]‪d = [2,3‬‬
‫; ‪e := a – b‬‬ ‫]‪e = [0,1‬‬
‫‪end .‬‬

‫ﻧﻜﺘﻪ ( ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﻭﺭﻭﺩﻱ ﭘﺮﻭﺳﻴﺠﺮ ﻣﻲ ﺗﻮﺍﻧﺪ ﻣﺠﻤﻮﻋﻪ ﺑﺎﺷﺪ ﺑﺸﺮﻃﻲ ﻛﻪ ﻗﺒﻼ ﺩﺭ ‪ Type‬ﺗﻌﺮﻳـﻒ ﺷـﺪﻩ ﺑﺎﺷـﻨﺪ ‪ ،‬ﻧـﻪ ﺍﻳﻨﻜـﻪ ﻣـﺴﺘﻘﻴﻤﺎ ﺩﺭ‬
‫ﭘﺮﻭﺳﻴﺠﺮ ﺑﻌﻨﻮﺍﻥ ﭘﺎﺭﺍﻣﺘﺮ ﺑﻴﺎﻳﺪ‪.‬‬
‫ﻧﻜﺘﻪ ( ﺧﺮﻭﺟﻲ ﻳﻚ ﺗﺎﺑﻊ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺍﺯ ﻧﻮﻉ ﻣﺠﻤﻮﻋﻪ ﺑﺎﺷﺪ‪.‬‬

‫ﺑﺮاي ﻧﻮﺷﺘﻦ ﯾﺎ ﺧﻮاﻧﺪن ﻣﺠﻤﻮﻋﻪ ﻫﺎ ‪:‬‬

‫ﺑﺎﻳﺪ ﻋﻀﻮ ﺑﻪ ﻋﻀﻮ ﻋﻤﻠﻴﺎﺕ ﺻﻮﺭﺕ ﺑﮕﻴﺮﺩ ﻭ ﻣﺴﺘﻘﻴﻤﺎ ‪ Read‬ﻭ ‪ Write‬ﺭﻭﻱ ﺁﻧﻬﺎ ﻛﺎﺭ ﻧﻤﻲ ﻛﻨﺪ‪.‬‬
 72 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
: ‫ﺣﺎﻝ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻧﻜﺎﺗﻲ ﻛﻪ ﮔﻔﺘﻴﻢ ﺗﻌﺎﺭﻳﻒ ﺯﻳﺮ ﺑﺮﺍﻱ ﻣﺠﻤﻮﻋﻪ ﻫﺎ ﻏﻠﻂ ﻣﻲ ﺑﺎﺷﺪ‬

Function f1 ( var ch1 : set of char ) : integer ;

Procedure p1 ( ch2 : set of 0...9 ) ;

Type
Ch = set of char ;
Function f2 ( x : integer ) : ch ;

: ‫ﺗﻌﺎﺭﻳﻒ ﺯﻳﺮ ﺑﺮﺍﻱ ﻣﺠﻤﻮﻋﻪ ﻫﺎ ﺩﺭﺳﺖ ﻣﻲ ﺑﺎﺷﻨﺪ‬

Type
Ch = set of char ;
Function f3 ( ch3 : ch) : char ;
Procedure p2 ( var ch4 : ch ; ch5 : ch ) ;
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪73‬‬

‫ﺁﺭﺍﻳـﻪ ﻫﺎ ‪:‬‬
‫ﺁﺭﺍﻳﻪ ﺗﻌﺪﺍﺩﻱ ﻣﺘﻐﻴﺮ ﻫﻢ ﻧﻮﻉ ﺍﺳﺖ ﮐﻪ ﺗﺤﺖ ﻳﮏ ﻧﺎﻡ ﺫﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ‪.‬ﻫﺮﺳﻠﻮﻝ ﺁﺭﺍﻳﻪ ﻳﮏ ﻣﺘﻐﻴﺮﺍﻧﺪﻳﺲ ﺩﺍﺭﺍﺳﺖ‪ .‬ﺗﻌﺪﺍﺩ ﻋﻨﺎﺻﺮﺁﺭﺍﻳﻪ‬
‫ﻣﺤﺪﻭﺩﻭﺛﺎﺑﺖ ﺍﺳﺖ‪.‬ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ ﺍﺯ ﻧﻈﺮ ﻓﻴﺰﻳﮑﻲ ﻣﮑﺎﻥ ﻫﺎﻱ ﻣﺘﻮﺍﻟﻲ ﺩﺭﺣﺎﻓﻈﻪ ﮐﺎﻣﭙﻴﻮﺗﺮﺍﺷﻐﺎﻝ ﻣﻲ ﮐﻨﻨﺪ‪.‬‬

‫ﺑﺮاي ﺗﻌﺮﯾﻒ آراﯾﻪ اﺑﺘﺪا ﻃﻮل )ﻧﻮع اﻧﺪﯾﺲ( آراﯾﻪ ﮐﻪ در ﺣﻘﯿﻘﺖ ﺗﻌﺪاد ﺧﺎﻧﻪ ﻫﺎي آﻧﺮا ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ‪ ،‬ﻣﻌﯿﻦ ﻣﯽ ﮔﺮدد‪.‬‬
‫ﺳﭙﺲ ﻧﻮع ﺧﺎﻧﻪ ﻫﺎﯾﯽ ﮐﻪ داده ﻫﺎ در آن ﻗﺮار ﺧﻮاﻫﻨﺪ ﮔﺮﻓﺖ را ﺗﻌﯿﯿﻦ ﻣﯽ ﮐﻨﻨﺪ و در ﻧﻬﺎﯾﺖ ‪ ،‬ﻋﻨﺎﺻـﺮ داﺧـﻞ ﺧﺎﻧـﻪ ﻫـﺎي آراﯾـﻪ‬
‫ﺗﻮﺳﻂ اﻧﺪﯾﺲ آراﯾﻪ ﮐﻪ ﻣﺤﻞ ﻗﺮار ﮔﺮﻓﺘﻦ ﻋﻨﺼﺮ در آراﯾﻪ را ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ‪ ،‬ﻗﺮار ﻣﯽ ﮔﯿﺮﻧﺪ‪.‬‬
‫ﻣﯽ ﺗﻮاﻧﯿﻢ آراﯾﻪ را ﺑﺼﻮرت زﯾﺮ در ﻧﻈﺮ ﮔﺮﻓﺖ ‪:‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫…‬ ‫‪10‬‬
‫]‪A[1‬‬ ‫]‪A[2‬‬ ‫]‪A[3‬‬ ‫…‬ ‫]‪A[10‬‬

‫ﻫﻤﺎن ﻃﻮر ﮐﻪ ﻣﻼﺣﻈﻪ ﻣﯽ ﮐﻨﯿﺪ داﺧﻞ ﻫﺮ ﮐﺪام از ﺧﺎﻧﻪ ﻫﺎي آراﯾﻪ ﯾﮏ ﻋﻨﺼﺮ ﻗﺮار ﻣﯽ ﮔﯿﺮد ﮐﻪ ﻧﻮع اﯾﻦ ﻋﻨﺎﺻﺮ ﺑﺎﯾﺪ ﺑﺎ ﻧﻮع‬
‫آراﯾﻪ ﯾﮑﺴﺎن ﺑﺎﺷﺪ‪.‬‬

‫ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﺁﺭﺍﻳﻪ ﺩﺭ ﭘﺎﺳﮑﺎﻝ ﺩﻭ ﺭﻭﺵ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪:‬‬

‫ﺭﻭﺵ ﺍﻭﻝ (‬
‫‪Var‬‬
‫; ﻧﻮع ﻣﺤﺘﻮاي آراﯾﻪ ‪] OF‬ﻧﻮع اﻧﺪﯾﺲ[‪ : array‬ﻧﺎم آراﯾﻪ‬

‫ﺭﻭﺵ ﺩﻭﻡ (‬
‫‪Type‬‬
‫; ﻧﻮع ﻣﺤﺘﻮاي آراﯾﻪ ‪] OF‬ﻧﻮع اﻧﺪﯾﺲ[‪ = array‬ﻧﺎم ﻧﻮع‬
‫‪Var‬‬
‫; ﻧﺎم ﻧﻮع ‪ :‬ﻧﺎم آراﯾﻪ‬

‫ﺩﺭ ﺭﻭﺵ ﺩﻭﻡ ﺍﺑﺘﺪﺍ ﺩﺭ ﻗﺴﻤﺖ ‪ Type‬ﻧﻮﻉ ﺁﺭﺍﻳﻪ ﺭﺍ ﺗﻌﺮﻳﻒ ﻣﻲ ﮐﻨﻴﻢ ﺳﭙﺲ ﺩﺭ ﻗﺴﻤﺖ ‪ Var‬ﺧﻮﺩ ﺁﺭﺍﻳﻪ ﺭﺍ ﺗﻌﺮﻳﻒ ﻣﻲ ﮐﻨﻴﻢ ﺭﻭﺵ‬
‫ﺩﻭﻡ ﺑﻬﺘـﺮ ﺍﺯ ﺭﻭﺵ ﺍﻭﻝ ﺍﺳﺖ ﺯﻳﺮﺍ ‪:‬‬
‫‪ - ۱‬ﺧﻮﺍﻧﺎﻳﻲ ﺑﺮﻧﺎﻣﻪ ﺑﺎﻻ ﻣﻲ ﺭﻭﺩ‪.‬‬
‫‪ - ۲‬ﺍﮔﺮ ﺩﺭ ﺟﺎﻱ ﺩﻳﮕﺮﻱ ﺍﺯ ﺑﺮﻧﺎﻣﻪ ﻧﻴﺎﺯ ﺑﻪ ﺁﺭﺍﻳﻪ ﺍﻱ ﺍﺯ ﻫﻤﻴﻦ ﻧﻮﻉ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﺑﻪ ﺳﺎﺩﮔﻲ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﺗﻌﺮﻳﻒ ﮐﻴﻢ‪.‬‬
‫ﻧﮑﺘﻪ ( اﻧﺪﯾﺴﻬﺎ ﺣﺪﺍﮐﺜﺮ ﻣﯽ ﺗﻮﺍﻧﻨﺪ ﯾﮏ اﺳﮑﺎﻟﺮ ‪ 2‬ﺑﺎﯾﺘﯽ ﺑﺎﺷﻨﺪ‪.‬‬
74 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
: ‫ ﺑﺮاي ﻣﺜﺎﻟﻬﺎي زﯾﺮ آراﯾـﻪ را رﺳﻢ ﮐﻨﯿﺪ‬، ‫ﺑﺮاي درك ﺑﻬﺘﺮ آراﯾﻪ ﻫﺎ‬

A:array[1..20] of integer;

B:array[-4..10] of real;
B[-4]:=200; B[2]:=8+B[10];

c:array[byte] of longint ;
. Longint ‫ ﻧﻮﻉ ﺍﻧﺪﻳﺲ ﺁﺭﺍﻳﻪ ﺑﺎﻳﺪ ﺍﺳﮑﺎﻟﺮ ﺑﺎﺷﺪ ﺍﻟﺒﺘﻪ ﺑﻪ ﻏﻴﺮ ﺍﺯ‬:‫ ﻧﮑﺘﻪ‬ü

D:array [ shortint ] of boolean;

E:array [ boolean ] of integer;

E[false]:=100; False True
E[E[5>8]<150]:=200; 100 200
E

H:array['A'..'Z'] of char;
H['B']:='c'; H[#65]:='M'; H['C']:=#65;

m:array[char] of 5..20;
m['!']:=12; m[#35]:=14; m[#2]:=3; • ‫ﺧﻄﺎ‬

Type
EnuS=(red,blue,green,yellow,black);
M=5..20;
Var
n:array[m] of EnuS;
n[7]:=green; n[7]:='green' ;•‫ﺧﻄﺎ‬
n[ord(yellow)+3]:=yellow ; writeln( n[7] ) ;•‫ﺧﻄﺎ‬

TYPE
COLOR=(RED,BLUE,YELLOW,GREEN);
M=ARRAY[COLOR] OF INTEGER;
VAR
A:M;
I:COLOR;
BEGIN
FOR I:=RED TO GREEN DO
READLN(A[I]);
end.
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪75‬‬
‫ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ‪:‬‬
‫ﺑﺮﺍﻱ ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ ﻧﺎﻡ ﺁﺭﺍﻳﻪ ﺭﺍ ﻧﻮﺷﺘﻪ ﺳﭙﺲ ﺩﺍﺧﻞ ﮐﺮﻭﺷﻪ ﺍﻧﺪﻳﺲ ﺭﺍ ﻗﺮﺍﺭ ﻣﻲ ﺩﻫﻴﻢ‪ .‬ﺍﻧﺪﻳﺲ ﻣﻲ ﺗﻮﺍﻧﺪ ﻳﮏ ﻋﺒﺎﺭﺕ ﻳﺎ ﻳﮏ‬
‫ﻣﺘﻐﻴﺮ ﺑﺎﺷﺪ ﺑﻪ ﻃﻮﺭﻱ ﮐﻪ ﻧﻮﻋﺶ ﺑﺎ ﻧﻮﻉ ﺍﻧﺪﻳﺲ ﻫﻤﺨﻮﺍﻧﻲ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫‪type‬‬
‫;‪myary=array[1..100] of real‬‬
‫‪var‬‬
‫;‪a:myary‬‬
‫;‪b:integer‬‬
‫‪begin‬‬
‫;‪b:=105‬‬
‫;‪a[-1]:=50‬‬
‫;‪a[b]:=180‬‬
‫;) ]‪writeln( a[b‬‬
‫‪end.‬‬
‫ﺍﮔﺮ ﺍﺯ ﻣﺤﺪﻭﺩﻩ ﺍﻧﺪﻳﺲ ﻳﮏ ﺁﺭﺍﻳﻪ ﺧﺎﺭﺝ ﺷﻮﻳﻢ ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻧﻤﻲ ﮔﻴﺮﺩ ﺑﻠﮑﻪ ﺣﺎﻟﺖ ﻋﺎﺩﻱ ﻧﺪﺍﺭﺩ‪ .‬ﺩﺭﺍﻳﻦ ﺣﺎﻟﺖ ﻣﻤﮑﻦ ﺍﺳﺖ ﺩﺳﺘﮕﺎﻩ ﺭﺍﻩ‬
‫ﺍﻧﺪﺍﺯﻱ ﻣﺠﺪﺩ ﺷﻮﺩ ﻳﺎ ﻗﻔﻞ ﮐﻨﺪ ﺑﺮﺍﻱ ﺟﻠﻮﮔﻴﺮﻱ ﺍﺯ ﭼﻨﻴﻦ ﻣﺸﮑﻠﻲ ﺑﺎﻳﺪ ﺍﺯ ﺭﻫﻨﻤﻮﺩ }‪ {$R+‬ﺑﺮﺍﻱ ﮐﻨﺘﺮﻝ ﻣﺤﺪﻭﺩﻩ ﺍﻧﺪﻳﺲ ﺁﺭﺍﻳﻪ ﻫﺎ ﺍﺳﺘﻔﺎﺩﻩ‬
‫ﮐﺮﺩ‪.‬‬
‫ﻧﻮﺷﺘﻦ ﺭﻫﻨﻤﻮﺩ }‪ {$R+‬ﺑﺎﻋﺚ ﮐﻨﺪﻱ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﻣﻲ ﺷﻮﺩ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﻓﻘـﻂ ﻳﮏ ﺑﺎﺭ ﺍﺯ ﺁﻥ ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩﻩ ﻭﺩﺭ ﺻﻮﺭﺗﻲ ﮐـﻪ‬
‫ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻧﺪﺍﺷﺖ ﺑﺮﺍﻱ ﺑﺎﺭ ﺩﻭﻡ ﺁﻥ ﺭﺍ ﺑﺮﺩﺍﺭﻳﺪ‪.‬‬
‫ﻣﺜﺎل ‪ ( 1‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ اﺑﺘﺪا ﯾﮏ آراﯾﻪ ‪ 10‬ﻋﻨﺼﺮي را ﺑﺎ اﻋﺪاد ﺗﺼﺎدﻓﯽ ﺑﯿﻦ ﺻﻔﺮ ﺗﺎ ﻫﺰار ﺗﻮﻟﯿﺪ ﮐﻨﺪ و آﻧـﺮا ﻧﻤـﺎﯾﺶ دﻫـﺪ ‪ ،‬ﺳـﭙﺲ‬
‫ﻣﺎﮐﺰﯾﻤﻢ و ﻣﻮﻗﻌﯿﺖ )اﻧﺪﯾﺲ ﺳﻠﻮل(آﻧﺮا ﻧﻤﺎﯾﺶ دﻫﺪ ‪:‬‬
‫‪USES‬‬
‫;‪NEWDELAY,CRT‬‬
‫‪TYPE‬‬
‫;‪VECTOR=ARRAY[1..10] OF INTEGER‬‬
‫‪VAR‬‬
‫;‪B:VECTOR‬‬
‫;‪I,MAX,POS:INTEGER‬‬
‫‪BEGIN‬‬
‫;‪RANDOMIZE‬‬
‫;‪CLRSCR‬‬
‫)‪FOR I:=LOW(B‬‬ ‫‪TO‬‬ ‫ﺗﻮﻟﯿﺪ ﯾﮏ آراﯾﻪ ‪ 10‬ﺳﻠﻮﻟﯽ)ﻋﻨﺼﺮي( ﺑﺎ اﻋﺪاد ﺗﺼﺎدﻓﯽ ﺑﯿﻦ ﺻﻔﺮ ﺗﺎ ﻫﺰار ‪HIGH(B) DO‬‬
‫‪BEGIN‬‬
‫;)‪B[I]:=RANDOM(1000‬‬
‫;)‪WRITE(B[I]:5‬‬
‫;‪END‬‬
‫;]‪MAX:=B[1‬‬
‫;‪POS:=1‬‬
‫‪FOR I:=2 TO 10 DO‬‬
‫‪IF‬‬ ‫‪B[I] > MAX THEN‬‬ ‫ﭘﯿﺪا ﮐﺮدن ﻣﺎﮐﺰﯾﻤﻢ و ﻣﻮﻗﻌﯿﺖ آن‬
‫‪BEGIN‬‬
‫;]‪MAX:=B[I‬‬
‫;‪POS:=I‬‬
‫;‪END‬‬
‫;‪WRITELN‬‬
‫;)‪WRITELN(MAX:4 , POS:4‬‬
‫‪END.‬‬
 76 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
‫ ﺳﭙﺲ ﻓﺮاواﻧﯽ اﻋﺪاد‬، ‫ ﻋﺪد از ﮐﺎرﺑﺮ درﯾﺎﻓﺖ ﮐﻨﺪ و ذﺧﯿﺮه ﮐﻨﺪ‬10 ‫ ( ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﺑﺎ اﺳﺘﻔﺎده از آراﯾﻪ اﺑﺘﺪا‬2 ‫ﻣﺜﺎل‬
: ‫را ﺑﺎ اﺳﺘﻔﺎده از آراﯾﻪ اي دﯾﮕﺮ ﭼﺎپ ﮐﻨﺪ‬
USES
NEWDELAY,CRT;
TYPE
VECTOR=ARRAY[1..10] OF INTEGER;
VAR
F,A:VECTOR;
J,I:INTEGER;
BEGIN
CLRSCR;
FOR I:=1 TO 10 DO ‫ ﻋﺪد از ﮐﺎرﺑﺮ و ذﺧﯿﺮه ﺑﺼﻮرت ﯾﮏ آراﯾﻪ‬10 ‫درﯾﺎﻓﺖ‬
READLN(A[I]);
CLRSCR;
FOR I:=1 TO 10 DO
BEGIN
F[I]:=0;
FOR J:=1 TO 10 DO ‫ ﻋﻨﺼﺮي دﯾﮕﺮ‬10 ‫ﺑﺪﺳﺖ آوردن ﻓﺮاواﻧﯽ ﻫﺮ ﻋﺪد و ذﺧﯿﺮه آن در ﯾﮏ آراﯾﻪ‬
IF A[I]=A[J] THEN
F[I]:=F[I]+1;
END;
FOR I:=1 TO 10 DO
WRITELN(A[I], ' ',F[I]);
END.

: ‫ آن ﻋﺪد را درﺳﺖ ﭼﺎپ ﮐﻨﺪ‬16 ‫ ( ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ ﻋﺪد درﯾﺎﻓﺖ ﮐﻨﺪ و ﻣﺒﻨﺎي‬3 ‫ﻣﺜﺎل‬
TYPE
VECTOR=ARRAY[1..10] OF CHAR;
VAR
I,R,J,N:INTEGER;
HEX:VECTOR;
BEGIN
READLN(N);
I:=1;
WHILE N>0 DO
BEGIN
R:=N MOD 16;
IF R<10 THEN
HEX[I]:=CHR(48+R)
ELSE
HEX[I]:=CHR(55+R);
I:=I+1;
N:=N DIV 16;
END;
FOR J:=I-1 DOWNTO 1 DO
WRITE(HEX[J]);
END.
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪77‬‬
‫ﻣﺜﺎل ‪ ( 4‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ دو ﻋﺪد ‪ 10‬رﻗﻤﯽ را رﻗﻢ ﺑﻪ رﻗﻢ درﯾﺎﻓﺖ ﮐﻨﺪ؛ﺳﭙﺲ اﯾﻦ دو ﻋﺪد را ﮐﻪ در آراﯾـﻪ اي ‪ 10‬ﺗـﺎﯾﯽ‬
‫ذﺧﯿﺮه ﺷﺪه اﻧﺪ‪ ،‬ﺑﺎ ﻫﻢ ﺟﻤﻊ ﮐﻨﺪ ‪:‬‬
‫}‪{$R+‬‬
‫‪uses‬‬
‫;‪newdelay,crt‬‬
‫‪var‬‬
‫;‪A,B:array[1..10] of 0..9‬‬
‫;‪C:array[0..10] of 0..9‬‬
‫;‪r,i,D:integer‬‬
‫‪begin‬‬
‫;‪clrscr‬‬
‫;)'‪writeln('Enter A‬‬
‫‪for i:=1 to 10 do‬‬
‫;)]‪readln(A[i‬‬
‫;)'‪writeln('Enter B‬‬
‫‪for i:=1 to 10 do‬‬
‫;)]‪Readln(B[i‬‬
‫;‪D:=0‬‬
‫‪for i:=10 downto 1 do‬‬
‫‪begin‬‬
‫;‪r:=A[i]+B[i]+D‬‬
‫;‪C[i]:=r mod 10‬‬
‫;‪D:=r div 10‬‬
‫;‪end‬‬
‫;‪C[0]:=D‬‬
‫‪for I:=0 to 10 do‬‬
‫;)]‪Write(C[i‬‬
‫‪end.‬‬

‫ﻣﺜﺎل ‪ ( 5‬ﯾﮏ آراﯾﻪ ﻣﺮﺗﺐ ﺣﺪاﮐﺜﺮ ‪ 10‬ﻋﻨﺼﺮي را در ﻧﻈﺮ ﺑﮕﯿﺮﯾﺪ؛ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ اﯾﻦ آراﯾﻪ را درﯾﺎﻓﺖ ﮐﻨﺪ و ﺳـﭙﺲ ﺑـﺎ‬
‫درﯾﺎﻓﺖ ﯾﮏ ﻋﻨﺼﺮ ﺟﺪﯾﺪ ‪ Q‬از ورودي‪،‬اﮔﺮ ﻋﻨﺼﺮ ﻣﻮرد ﻧﻈﺮ در آراﯾﻪ ﻣﻮﺟﻮد ﺑﻮد آﻧـﺮا ﺣـﺬف ﮐﻨـﺪ در ﻏﯿـﺮ اﯾﻨـﺼﻮرت ﻋﻨـﺼﺮ‬
‫ﺟﺪﯾﺪ را در ﻣﺤﻞ ﻣﺨﺼﻮص ﺑﻪ ﺧﻮد در آراﯾﻪ در ج ﮐﻨﺪ ‪:‬‬
‫ﺗﻮﺿﯿﺢ ‪:‬‬
‫ﺑﺮﻧﺎﻣﻪ ﺑﺎﻻ را ﺑﺎ اﯾﻦ ﺗﺤﻠﯿﻞ ﻣﯽ ﻧﻮﯾﺴﯿﻢ ﮐﻪ ‪:‬‬
 78 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
uses
newdelay,crt;
var
A:array[1..10] of integer;
tedad:byte; i,z,m:integer; c:char;
function search(m:integer):byte;
var
i:integer;
begin
search:=0;
for i:=1 to tedad do
if A[i]=m then
search:=i;
end;
procedure hazf(z:integer);
var
i:integer;
begin
for i:=z to tedad do
A[i]:=A[i+1];
tedad:=tedad-1;
end;
procedure add(m:integer);
var
i,j:integer;
begin
i:=1;
if tedad=10 then exit;
for i:=1 to tedad+1 do
if A[i]>m then
break;
for j:=tedad+1 downto i do
A[j]:=A[j-1];
A[i]:=m;
tedad:=tedad+1;
end;
Begin
tedad:=0;
clrscr;
repeat
writeln('Enter a number');
readln(m);
z:=search(m);
if z<>0 then
hazf(z)
else
add(m);
for i:=1 to tedad do
write(A[i]:4);
readln(c);
until c='q';
end.
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪79‬‬
‫ﺁﺭﺍﻳﻪ ﻫﺎﻱ ﺩﻭﺑﻌـﺪﻱ‪:‬‬
‫ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﻣﺎﺗﺮﻳﺲ )ﺁﺭﺍﻳﻪ ﺩﻭﺑﻌﺪﻱ( ﻣﺎﻧﻨﺪ ﺗﻌﺮﻳﻒ ﺁﺭﺍﻳﻪ ﻫﺎﻱ ﻳﮏ ﺑﻌﺪﻱ ﻋﻤﻞ ﻣﻲ ﮐﻨﻴﻢ ﺑﺎ ﺍﻳﻦ ﺗﻔﺎﻭﺕ ﮐﻪ ﺩﻭﺑﻌﺪ ﺑﻪ ﻋﻨﻮﺍﻥ ﺳﻄﺮ)ﺑﻌﺪ‬
‫ﺍﻭﻝ( ﻭﺳﺘﻮﻥ)ﺑﻌﺪ ﺩﻭﻡ( ﺗﻌﺮﻳﻒ ﻣﻲ ﮐﻨﻴﻢ‪.‬ﻧﻮﻉ ﺍﻧﺪﻳﺲ ﻫﺎ ﺑﺎﻳﺪ ﺍﺳﮑﺎﻟﺮ ﺑﺎﺷﺪ‪.‬‬
‫‪Type‬‬
‫;‪Mat = Array [1..5,boolean] of real‬‬
‫‪Var‬‬
‫; ‪a : mat‬‬
‫‪Begin‬‬
‫ﺭﻭﺵ ﺍﻭﻝ ;‪a[3,true]:=100‬‬ ‫ﺑـﺮﺍﻱ ﺩﺳﺘﺮﺳـﻲ ﺑـﻪ ﻋﻨﺎﺻـﺮ ﺁﺭﺍﻳـﻪ ﺑـﻪ ﺩﻭ ﺭﻭﺵ ﻣـﻲ ﺗـﻮﺍﻧﻴﻢ ﻋﻤـﻞ ﮐﻨـﻴﻢ‪:‬‬
‫ﺭﻭﺵ ﺩﻭﻡ ;‪a[3][true]:=100‬‬
‫;‪a[3,5>4]:=100‬‬
‫;‪a[6,false]:=200‬‬ ‫ﺩﺭ ﺍﻳﻦ ﺳﻄﺮ ﭼﻮﻥ ﺍﺯ ﻣﺤﺪﻭﺩﻩ ﺍﻧﺪﻳﺲ ﻫﺎ ﺧﺎﺭﺝ ﺷﺪ ﺍﻳﻢ ﺑﺮﻧﺎﻣﻪ ﺣﺎﻟﺖ ﻋﺎﺩﻱ ﻧﺪﺍﺭﺩ‪.‬‬
‫‪end.‬‬
‫ﻣﺜﺎل ‪ ( 6‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ دو ﻣﺎﺗﺮﯾﺲ ‪ 3×4‬را درﯾﺎﻓﺖ ﮐﻨﺪ و ﺣﺎﺻﻞ ﺟﻤﻊ دو ﻣﺎﺗﺮﯾﺲ را ﭼﺎپ ﮐﻨﺪ ‪:‬‬
‫‪uses‬‬
‫;‪newdelay,crt‬‬
‫‪var‬‬
‫;‪A,B,C:array[1..3 , 1..4]of integer‬‬
‫;‪i,j:integer‬‬
‫‪Begin‬‬
‫;)'‪Writeln('Enter A‬‬
‫‪for i:=1 to 3 do‬‬
‫‪for j:=1 to 4 do‬‬
‫;)]‪Readln(A[i][j‬‬
‫;)'‪Writeln('Enter B‬‬
‫‪for i:=1 to 3 do‬‬
‫‪for j:=1 to 4 do‬‬
‫;)]‪Readln(B[i][j‬‬
‫‪for i:=1 to 3 do‬‬
‫‪for j:=1 to 4 do‬‬
‫;]‪C[i,j]:=A[i,j]+B[i,j‬‬
‫‪for i:=1 to 3 do‬‬
‫‪begin‬‬
‫;‪writeln‬‬
‫‪for j:=1 to 4 do‬‬
‫;)‪write(C[i,j]:5‬‬
‫;‪end‬‬
‫‪End.‬‬

‫ﻣﺜﺎل ‪ ( 7‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ ﻣﺎﺗﺮﯾﺲ ‪ 4×4‬را درﯾﺎﻓﺖ ﮐﻨﺪ و ﺗﺮاﻧﻬﺎده آﻧﺮا ﭼﺎپ ﮐﻨﺪ ‪:‬‬
‫‪uses‬‬
‫;‪newdelay,crt‬‬
‫‪var‬‬
‫;‪A,B:array[1..4 , 1..4]of integer‬‬
‫;‪i,j:integer‬‬
‫اداﻣﻪ ﺑﺮﻧﺎﻣﻪ در ﺻﻔﺤﻪ ﺑﻌﺪ‬
 80 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
Begin
CLRSCR;
Writeln('Enter A');
for i:=1 to 4 do
for j:=1 to 4 do
Readln(A[i][j]);
for i:=1 to 4 do
for j:=1 to 4 do
B[J,I]:=A[i,j];
for i:=1 to 4 do
begin
writeln;
for j:=1 to 4 do
write(B[i,j]:5);
end;
End.

: ‫ را درﯾﺎﻓﺖ ﮐﻨﺪ؛ﺳﭙﺲ ﺣﺎﺻﻠﻀﺮب اﯾﻦ دو ﻣﺎﺗﺮﯾﺲ را ﭼﺎپ ﮐﻨﺪ‬4×4 ‫ ( ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ دو ﻣﺎﺗﺮﯾﺲ‬8 ‫ﻣﺜﺎل‬
uses
newdelay,crt;
var
A,B,C:array[1..4 , 1..4]of integer;
i,j,s,k:integer;
BEGIN
clrscr;
Writeln('Enter A');
For i:=1 to 4 do
for j:=1 to 4 do
read(A[i][j]);
Writeln('Enter B');
For i:=1 to 4 do
for j:=1 to 4 do
read(B[i,j]);
for i:=1 to 4 do
for j:=1 to 4 do
begin
s:=0;
‫ ﻣﺤﺎﺳﺒﻪ ﺿﺮب دو ﻣﺎﺗﺮﯾﺲ‬: ‫ﻣﻬﻤﺘﺮﯾﻦ ﻗﺴﻤﺖ ﺑﺮﻧﺎﻣﻪ‬
for k:=1 to 4 do
S := S + A[i,k] * B[k,j] ;
C[i,j]:=S ;
end;
for i:=1 to 4 do
begin
writeln;
for j:=1 to 4 do
write(C[i,j]:4);
end;
END.
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪81‬‬
‫آراﯾﻪ ﻫﺎي ﭼﻨﺪ ﺑﻌـﺪي ‪:‬‬
‫ﻣﯽ ﺗﻮان آراﯾﻪ ﻫﺎﯾﯽ ﺑﺎ اﺑﻌﺎد ﺑﯿﺸﺘﺮ از دو ﻧﯿﺰ ﺗﻌﺮﯾﻒ ﮐﺮد‪.‬ﺑﻄﻮر ﮐﻠﯽ ﺑﺮاي ﻣﻌﺮﻓﯽ ﯾﮏ آراﯾﻪ ﭼﻨـﺪ ﺑﻌـﺪي ﻣـﯽ ﺗـﻮان ﺑـﻪ دو‬
‫روش زﯾﺮ ﻋﻤﻞ ﮐﺮد ‪:‬‬
‫; ‪) NAME : ARRAY [1..L] OF ARRAY [1..L2]… OF ARRAY [1..LN] OF TYPE‬روش اول‬

‫] ‪) NAME : ARRAY [ 1.. L1 , 1..L2 , … , 1.. LN‬روش دوم‬ ‫; ‪OF TYPE‬‬

‫ﻣﺜﺎل ( آراﯾﻪ ﺳﻪ ﺑﻌﺪي ﺑﻪ روش دوم ﺑﺼﻮرت زﯾﺮ ﺗﻌﺮﯾﻒ ﻣﯽ ﮐﻨﯿﻢ ‪:‬‬
‫‪VAR‬‬
‫; ‪A : ARRAY [ 1..2 , 1..4 , 1..3 ] OF REAL‬‬
‫ﺑﺮاي دﺳﺘﺮﺳﯽ ﺑﻪ اﻋﻀﺎي اﯾﻦ آراﯾﻪ در ﺣﺎﻟﺖ ﮐﻠﯽ ﺑﺼﻮرت ] ‪ A [ I , J , K‬ﻋﻤﻞ ﻣﯽ ﮐﻨﻨﺪ ﮐﻪ در آن ‪ I,J,K‬اﺑﻌﺎد آراﯾﻪ ﻣﯽ‬
‫ﺑﺎﺷﻨﺪ و در ﻣﺤﺪوده ﺗﻌﺮﯾﻒ ﺷﺪه ﺑﺮاي آراﯾﻪ ﺻﺪق ﻣﯽ ﮐﻨﻨﺪ‪.‬‬
‫ﻧﮑﺘﻪ ( آراﯾـﻪ ﻫﺎي ﻓﺸﺮده ) ‪( Packed Array‬‬
‫در ﭘﺎﺳﮑﺎل اﺳﺘﺎﻧﺪارد ﻫﺮ ﮐﺎراﮐﺘﺮ داﺧﻞ ﯾﮏ ﻋﻨﺼﺮ از آراﯾﻪ ﻗﺮار ﻣﯽ ﮔﯿﺮد ‪ .‬ﺣﺎل آﻧﮑﻪ ﻫﺮ ﻋﻨﺼﺮ آراﯾﻪ ﻇﺮﻓﯿﺖ ﭘـﺬﯾﺮش‬
‫ﺣﺪاﻗﻞ ‪ 4‬ﮐﺎراﮐﺘﺮ و ﺣﺪاﮐﺜﺮ ‪ 10‬ﮐﺎراﮐﺘﺮ را دارا ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﮐﻪ اﯾﻦ ﻣﻤﮑﻦ اﺳﺖ ﻣﺸﮑﻞ ﮐﻤﺒﻮد ﻓﻀﺎي ﺣﺎﻓﻈﻪ را اﯾﺠﺎد ﮐﻨﺪ ﻟـﺬا‬
‫ﺑﺮاي ﺟﻠﻮﮔﯿﺮي از اﺷﻐﺎل ﺣﺠﻢ ﺑﺰرﮔﯽ از ﺣﺎﻓﻈﻪ ‪ ،‬آراﯾﻪ ﻫﺎي ﮐﺎراﮐﺘﺮي ﻓﺸﺮده را ﺗﻌﺮﯾﻒ ﻣﯽ ﮐﻨﯿﻢ‪ .‬در اﯾﻦ ﺣﺎﻟـﺖ ﻇﺮﻓﯿـﺖ‬
‫ﭘﺬﯾﺮش ﻫﺮﻋﻨﺼﺮ از ﯾﮏ ﮐﺎراﮐﺘﺮ ﺑﯿﺸﺘﺮ ﻧﯿﺴﺖ و ﺑﻨﺎﺑﺮاﯾﻦ ﺑﺪﯾﻦ ﺻﻮرت ﻣﯽ ﺗﻮاﻧﯿﻢ از ﺣﺎﻓﻈﻪ اﺳﺘﻔﺎده ﻣﻮﺛﺮﺗﺮي داﺷﺘﻪ ﺑﺎﺷﯿﻢ‪.‬‬
‫آراﯾﻪ ﻫﺎي ﻓﺸﺮده ﺑﺼﻮرت زﯾﺮ ﺗﻌﺮﯾﻒ ﻣﯽ ﺷﻮﻧﺪ ‪:‬‬
‫‪Name :‬‬ ‫‪packed‬‬ ‫] اﻧﺪﯾﺲ[ ‪Array‬‬ ‫‪of‬‬ ‫; ‪type‬‬
‫ﺣﺴﻦ آراﯾﻪ ﻫﺎي ﻓﺸﺮده اﺳﺘﻔﺎده از ﺣﺎﻓﻈﻪ ﮐﻤﺘﺮ اﺳﺖ‪.‬‬
‫ﺗﻮﺟﻪ ‪ :‬در ﺗﻮرﺑﻮ ﭘﺎﺳﮑﺎل ﺑﻄﻮر اﺗﻮﻣﺎﺗﯿﮏ آراﯾـﻪ ﻫﺎ ﺑﺼﻮرت ﻓﺸﺮده در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﯽ ﺷﻮﻧﺪ و ﻧﯿﺎز ﺑﻪ ﺗﻌﺮﯾﻒ ﻣﺠﺪد آﻧﻬﺎ‬
‫آراﯾﻪ ﻣﻌﻤﻮﻟﯽ‬ ‫ﺑﺼﻮرت ﻓﺸﺮده ﻧﯿﺴﺖ‪.‬‬
‫‪A‬‬ ‫‪A‬‬
‫‪L‬‬ ‫‪L‬‬
‫‪I‬‬ ‫‪I‬‬
‫آراﯾﻪ ﻓﺸﺮده‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪82‬‬
‫ﺍﺭﺳﺎﻝ ﺁﺭﺍﻳﻪ ﺑﻪ ﺯﻳﺮ ﺑﺮﻧﺎﻣـﻪ‪:‬‬
‫‪Type‬‬
‫;‪Ar=array [1..10] of integer‬‬
‫‪Var‬‬
‫;‪h:Ar‬‬
‫;‪function test (m:ar) :integer‬‬
‫‪var‬‬
‫;‪I,f:integer‬‬
‫‪Begin‬‬
‫‪for i:=1 to 10 do‬‬
‫;]‪f:=f+m[i‬‬
‫;‪m[1]:=50‬‬
‫;‪test:=f div 10‬‬
‫;‪end‬‬

‫;‪var i:integer‬‬
‫‪begin‬‬
‫‪for i:=1 to 10 do‬‬
‫‪readln( H[I] ):‬‬
‫;))‪write(test(h‬‬
‫;)]‪write(h[1‬‬
‫‪end.‬‬
‫ﺍﻟﻒ ( ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺩﺭ ﺣﺎﻟﺘﻲ ﮐﻪ ‪ M‬ﺍﺭﺯﺵ )ﻣﻘﺪﺍﺭ( ﺑﺎﺷﺪ ﺑﺮﺭﺳﻲ ﻣﻲ ﮐﻨﻴﻢ ‪:‬‬

‫ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ﺁﺭﺍﻳﻪ ‪ H‬ﻫﻨﮕﺎﻡ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻓﺎﻧﮑﺸﻦ ‪ test‬ﺗﺤﻮﻳﻞ ‪ M‬ﺩﺍﺩﻩ ﻣﻲ ﺷﻮﺩ ﻭ ﭼﻮﻥ ‪ M‬ﻳﮏ ﭘﺎﺭﺍﻣﺘﺮ ﺍﺭﺯﺵ)ﻣﻘﺪﺍﺭ( ﺍﺳﺖ ﺍﺯ ﺁﺭﺍﻳﻪ ‪ H‬ﻳﮏ‬
‫ﮐﭙﻲ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮﺩ ﻭﮐﭙﻲ ﺁﻥ ﺑﻪ ﺍﺳﻢ ‪ M‬ﺷﻨﺎﺧﺘﻪ ﻣﻲ ﺷﻮﺩ‪ .‬ﺩﺭﺍﻳﻦ ﺣﺎﻟﺖ ﺣﺎﻓﻈﻪ ﺩﻭ ﺑﺮﺍﺑﺮ ﺍﺷﻐﺎﻝ ﻣﻲ ﺷﻮﺩ ﻫﻤﭽﻨﻴﻦ ﺍﺟﺮﺍﻱ ﺯﻳـﺮ ﺑﺮﻧﺎﻣـﻪ‬
‫ﮐﻨﺪ ﻣﻲ ﺷﻮﺩ ﺯﻳﺮﺍ ﺑﺎﻳﺪ ﺗﻤﺎﻡ ﻣﺤﺘﻮﺍﻱ ﺳﻠﻮﻝ ﻫﺎﻱ ‪ H‬ﺩﺭ ﺳﻠﻮﻝ ﻫﺎﻱ ‪ M‬ﮐﭙﻲ ﺷﻮﺩ‪ .‬ﺩﺭ ﻋﻮﺽ ﺗﻐﻴﻴﺮ ﺩﺍﺩﻥ ﺁﺭﺍﻳﻪ ‪ M‬ﺑﺎﻋﺚ ﺗﻐﻴﻴﺮ ﺁﺭﺍﻳـﻪ ‪H‬‬
‫ﻧﻤﻲ ﺷﻮﺩ‪.‬ﺁﺭﺍﻳﻪ ‪ M‬ﻳﮏ ﺁﺭﺍﻳﻪ ﻣﺤﻠﻲ ﺍﺳﺖ ﮐﻪ ﻓﻘﻂ ﺩﺭ ﻓﺎﻧﮑﺸﻦ ‪ test‬ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻭﺑﻌﺪ ﺍﺯ ﺍﺗﻤﺎﻡ ﻓﺎﻧﮑﺸﻦ ‪ test‬ﺍﺯ ﺑﻴﻦ ﻣﻲ ﺭﻭﺩ‪.‬‬

‫ﺏ ( ﺣﺎﻝ ﺑﺮﻧﺎﻣﻪ ﻗﺒﻞ ﺭﺍ ﺩﺭ ﺣﺎﻟﺘﻲ ﮐﻪ ‪ M‬ﻣﺮﺟﻊ )ﻣﺘﻐﻴﺮ( ﺑﺎﺷﺪ ﺑﺮﺭﺳﻲ ﻣﻲ ﮐﻨﻴﻢ ‪:‬‬

‫ﺩﺭ ﺍﻳﻦ ﺣﺎﻟﺖ ﺁﺩﺭﺱ ﺁﺭﺍﻳﻪ ‪ H‬ﺑﻪ ‪ M‬ﺗﺤﻮﻳﻞ ﺩﺍﺩﻩ ﻣﻲ ﺷﻮﺩ ﺩﺭ ﻭﺍﻗﻊ ﺁﺭﺍﻳﻪ ‪ H‬ﻭ ﺁﺭﺍﻳﻪ ‪ M‬ﻳﮑﻲ ﻫﺴﺘﻨﺪ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺣﺎﻓﻈﻪ ﺍﺿﺎﻓﻪ ﺍﺷـﻐﺎﻝ‬
‫ﻧﺸﺪﻩ ﺍﺳﺖ ﻭ ﺳﺮﻋﺖ ﻧﻴﺰ ﭘﺎﻳﻴﻦ ﻧﻴﺎﻣﺪﻩ ﺍﺳﺖ ﺍﻣﺎ ﺍﮔﺮ ﺁﺭﺍﻳﻪ ‪ M‬ﺭﺍ ﺗﻐﻴﻴﺮ ﺩﻫﻴﺪ ﺁﺭﺍﻳﻪ ‪ H‬ﻧﻴﺰ ﺗﻐﻴﻴﺮ ﻣﻲ ﮐﻨﺪ‪).‬ﺍﻣﻨﻴﺖ ﻧﺪﺍﺭﺩ(‬

‫ﺝ ( ﻣﺴﺎﻟﻪ ﻗﺒﻞ ﺭﺍ ﺩﺭ ﺣﺎﻟﺘﻲ ﺑﺮﺭﺳﻲ ﻣﻲ ﮐﻨﻴﻢ ﮐﻪ ﭘﺎﺭﺍﻣﺘﺮ ‪ M‬ﺛﺎﺑﺖ)‪ (const‬ﺑﺎﺷﺪ ‪:‬‬

‫ﺩﺭ ﺍﻳﻦ ﺣﺎﻟﺖ ﻣﺎﻧﻨﺪ ﺣﺎﻟﺖ ﻣﺮﺟﻊ ﻋﻤﻞ ﻣﻲ ﮐﻨﻴﻢ ﻳﻌﻨﻲ ﺁﺩﺭﺱ ﺁﺭﺍﻳﻪ ‪ H‬ﺗﺤﻮﻳﻞ ‪ M‬ﺩﺍﺩﻩ ﻣﻲ ﺷﻮﺩ ﻳﻌﻨﻲ ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﻧﻤﻲ ﺷﻮﺩ ﺯﻳـﺮ ﺑﺮﻧﺎﻣـﻪ‬
‫ﮐﻨﺪ ﻧﻤﻲ ﺷﻮﺩ ﺍﻣﺎ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺁﺭﺍﻳﻪ ‪ M‬ﺭﺍ ﺗﻐﻴﻴﺮ ﺩﻫﺪ ﮐﻪ ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ﺧﻂ ‪ M[1]:=50‬ﺧﻄﺎ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪ .‬ﮐﻪ ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ‬
‫ﺍﻣﻨﻴﺖ ﻧﻴﺰ ﺑﻪ ﻭﺟﻮﺩ ﻣﻲ ﺁﻳﺪ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪83‬‬
‫ﻧﮑﺘﻪ ‪ :‬ﻫﻨﮕﺎﻡ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻳﮏ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﺑﺎﻳﺪ ﻧﻮﻉ ﭘﺎﺭﺍﻣﺘﺮ ﻫﺎ)ﺩﺭﻳﺎﻓﺘﻲ ﻭﺍﺭﺳﺎﻟﻲ ( ﻳﮑﻲ ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﺍﮔﺮ ﻳﮏ ﺁﺭﺍﻳﻪ ﺭﺍ ﺑﻪ ﺯﻳﺮ ﺑﺮﻧﺎﻣـﻪ ﺍﺭﺳـﺎﻝ ﻣـﻲ‬
‫ﮐﻨﻴﻢ ﺑﺎﻳﺪ ﺑﺎ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺠﺎﺯﻱ ﺁﻥ ﻫﻢ ﻧﻮﻉ ﺑﺎﺷﺪ ﺩﺭ ﻏﻴﺮ ﺍﻳﻦ ﺻﻮﺭﺕ ﺧﻄﺎﺳﺖ‪.‬‬

‫ﻧﮑﺘﻪ ‪ :‬ﺍﮔﺮ ﺁﺭﺍﻳﻪ ﺭﺍ ﺑﻪ ﺭﻭﺵ ﺩﻭﻡ )‪ (Type‬ﺗﻌﺮﻳﻒ ﮐﻨﻴﻢ ﻫﻨﮕﺎﻡ ﺍﺭﺳﺎﻝ ﺁﺭﺍﻳﻪ ﺑﻪ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ‪ ،‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺳﺎﺩﻩ ﺗﺮ ﻣﻲ ﺗﻮﺍﻧﺪ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺠـﺎﺯﻱ‬
‫ﺭﺍ ﺗﻌﺮﻳﻒ ﮐﻨﺪ‪.‬‬

‫ﺗﻮﺍﻧﺪ ﺑﺎ ﻧﺎﻡ ﺧﻮﺩ ﻳﮏ ﺁﺭﺍﻳﻪ ﺭﺍ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﺍﺻﻠﻲ ﺑﺮﮔﺮﺩﺍﻧﺪ ﺑﻪ ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ ﺧﺮﻭﺟﻲ ﺗﺎﺑﻊ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺁﺭﺍﻳﻪ ﺑﺎﺷﺪ‪ .‬ﺑﺮﺍﻱ ﺍﻳﻨﮑﻪ‬ ‫ﻧﮑﺘﻪ ‪ :‬ﺗﺎﺑﻊ ﻧﻤﻲ‬
‫ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺧﺮﻭﺟﻲ ﺍﺵ ﺁﺭﺍﻳﻪ ﺑﺎﺷﺪ ﺑﺎﻳﺪ ﻳﮏ ﭘﺎﺭﺍﻣﺘﺮ ﻣﺮﺟﻊ ﺑﻪ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﺍﺭﺳﺎﻝ ﮐﻨﻴﻢ ﺗﺎ ﺩﺭ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﮐﻨﺪ ﻭﻫﻨﮕﺎﻣﻲ ﮐﻪ ﺑﻪ ﺑﺮﻧﺎﻣﻪ‬
‫ﺍﺻﻠﻲ ﺑﺮﮔﺸﺘﻴﻢ ﺗﻐﻴﻴﺮﺍﺕ ﺍﺻﻠﻲ ﺭﺍ ﻣﺸﺎﻫﺪﻩ ﮐﻨﻴﻢ‪.‬‬
‫ﭘﺎﺭﺍﻣﺘـﺮ ﺑﺎﺯ ‪:‬‬
‫ﭘﺎﺭﺍﻣﺘﺮ ﺑﺎﺯ ﭘﺎﺭﺍﻣﺘﺮﻱ ﺍﺳﺖ ﮐﻪ ﻫﻨﮕﺎﻡ ﻓﺮﺍﺧﻮﺍﻧﻲ ﺗﺎﺑﻊ ﻳﺎ ﭘﺮﻭﺳﻴﺠﺮ‪ ،‬ﻳﮏ ﺁﺭﺍﻳﻪ ﺑﺎ ﻫﺮ ﺗﻌﺪﺍﺩ ﺳﻠﻮﻝ ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﮐﻨﺪ‪ .‬ﻧﺤﻮﻩ ﺗﻌﺮﻳﻒ ﭘـﺎﺭﺍﻣﺘﺮ‬
‫ﺑﺎﺯ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ‪:‬‬
‫;‪Function add(z : array of integer) : longint‬‬
‫ﺩﺭ ﭘﺎﺭﺍﻣﺘﺮ ﺑﺎﺯ ﻣﺤﺪﻭﺩﻩ ﺍﻧﺪﻳﺲ ﺍﻋﻼﻡ ﻧﻤﻲ ﺷﻮﺩ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﻫﺮ ﺁﺭﺍﻳﻪ ﺍﻱ ﺑﺎ ﺗﻌﺪﺍﺩ ﻋﻨﺎﺻﺮﻣﺨﺘﻠﻒ ﺭﺍ ﺑﻪ ﺁﻥ ﺗﺤﻮﻳﻞ ﺩﻫﻴﻢ‪.‬‬
‫ﺑﺮﺍﻱ ﻣﺸﺨﺺ ﮐﺮﺩﻥ ﮐﻤﺘﺮﻳﻦ ﻭﺑﻴﺸﺘﺮﻳﻦ ﺍﻧﺪﻳﺲ ﺍﺯ ﺗﻮﺍﺑﻊ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ‪ low‬ﻭ ‪ high‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﮐﻨﻴﻢ‪.‬‬
‫ﻣﺜﺎﻝ(‬
‫‪Var‬‬
‫;‪A:array [1..10] of integer‬‬
‫;‪B:array[20..40] of integer‬‬
‫;‪i:integer‬‬
‫;‪function add(z : array of integer) : longint‬‬
‫‪var‬‬
‫;‪s:longint‬‬
‫;‪i,l,h : integer‬‬
‫‪begin‬‬
‫;)‪L:=low(z‬‬
‫;)‪H:=high(z‬‬
‫;‪s:=0‬‬
‫‪for i:=L to H do‬‬
‫;]‪s:=s+z[i‬‬
‫;‪add:=s‬‬
‫;‪end‬‬
‫‪begin‬‬
‫‪for i:=1 to 10 do‬‬
‫; ) ]‪readln( a[i‬‬
‫‪for i:=20 to 40 do‬‬
‫;) ]‪readln( b[i‬‬
‫;))‪writeln(add(a‬‬
‫;)‪writeln(add(b‬‬
‫‪end.‬‬

‫ﺩﺭ ﻣﺜﺎﻝ ﺫﮐﺮ ﺷﺪﻩ ﺩﻭ ﺁﺭﺍﻳﻪ ‪ A‬ﻭ ‪ B‬ﺍﺯ ﻧﻮﻉ ‪ integer‬ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺍﻧﺪ ﺍﻣﺎ ﺑﺎ ﻣﺤﺪﻭﺩﻩ ﺍﻧﺪﻳﺲ ﻫﺎﻱ ﻣﺘﻔﺎﻭﺕ‪ .‬ﻓﺎﻧﮑﺸﻦ ‪ add‬ﻫﺮ ﺩﻭ ﺁﺭﺍﻳﻪ‬
‫ﺭﺍ ﻣﻲ ﺗﻮﺍﻧﺪ ﺗﺤﻮﻳﻞ ﺑﮕﻴﺮﺩ‪ .‬ﺍﻳﻦ ﻓﺎﻧﮑﺸﻦ ﻣﺠﻤﻮﻉ ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ ﺭﺍ ﺑﺮﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪84‬‬
‫ﺭﺷﺘـﻪ ﻫﺎ ‪:‬‬
‫ﺭﺷﺘﻪ ﺷﺒﻴﻪ ﺁﺭﺍﻳﻪ ﺍﻱ ﺍﺯ ﻧﻮﻉ ‪ char‬ﺍﺳﺖ ؛ ﻳﻌﻨﻲ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﺧﻂ ﻋﻨﻮﺍﻥ ‪ string‬ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺗﺼﻮﺭ ﮐﻨﻴﻢ‪:‬‬
‫‪Type‬‬
‫; ‪String = array [0..255] of char‬‬
‫ﻣﺜﺎﻝ (‬
‫;'‪S:='ALIREZA‬‬
‫‪Writeln(s[4]);ž R‬‬
‫;'‪S[3]:='M‬‬
‫‪Writeln(s); ž ALMREZA‬‬
‫;'‪S[8]:='B‬‬
‫‪Writeln(s); ž ALMREZA‬‬
‫;‪S[0]:=#8‬‬
‫‪Writeln(s) ž ALMREZAB‬‬
‫;‪S[0]:=#0‬‬
‫ﭼﻴﺰﻱ ﭼﺎﭖ ﻧﻤﻲ ﺷﻮﺩ ‪writeln(s); ž‬‬
‫;‪s[0]:=#3‬‬
‫‪writeln(s); ž ALM‬‬
‫; ‪s[0]:=#10‬‬
‫ﻣﻌﻠﻮﻡ ﻧﻴﺴﺖ ﮐﻪ ﺩﻭ ﮐﺎﺭﺍﮐﺘﺮ ﺁﺧﺮ ﭼﻪ ﭼﻴﺰﻱ ﺑﺎﺷﺪ‪writeln(s); ž ALMREZAB‬‬
‫ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﺑﻪ ﮐﺎﺭﺍﮐﺘﺮ ﻫﺎﻱ ﺩﺍﺧﻞ ﺭﺷﺘﻪ ﺩﺳﺘﺮﺳﻲ ﻣﺴﺘﻘﻴﻢ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﻭ ﮐﺎﺭﺍﮐﺘﺮﻫﺎ ﺭﺍ ﺗﻐﻴﻴﺮدﻫﯿﻢ ﻳﺎ ﭼﺎﭖ ﮐﻨﻴﻢ‪.‬ﺍﮔﺮ ﺩﺳﺘﻮﺭ ﺍﻧﺘـﺴﺎﺏ‬
‫ﺑﺮ ﺭﻭﻱ ﮐﻞ ﺭﺷﺘﻪ ﺍﻧﺠﺎﻡ ﺷﻮﺩ)ﺧﻂ ﺍﻭﻝ ﺩﺭ ﻣﺜﺎﻝ ﺑﺎﻻ( ﺳﻠﻮﻝ ﺷﻤﺎﺭﻩ ﺻﻔﺮ‪ ،‬ﺗﻐﻴﻴﺮ ﻣﻲ ﮐﻨﺪ ﺍﻣﺎ ﺍﮔﺮ ﺑﺮ ﺭﻭﻱ ﻳﮑﻲ ﺍﺯ ﺧﺎﻧﻪ ﻫﺎﻱ ﺭﺷﺘﻪ ﺑﺎﺷﺪ‬
‫ﺳﻠﻮﻝ ﺷﻤﺎﺭﻩ ﺻﻔﺮ ﺗﻐﻴﻴﺮ ﻧﻤﻲ ﮐﻨﺪ )ﺧﻂ ﭘﻨﺠﻢ ﺩﺭ ﻣﺜﺎﻝ ﺑﺎﻻ( ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ ﺗﻮﺍﻧﺪ ﺧﺎﻧﻪ ﺷﻤﺎﺭﻩ ﺻﻔﺮ ﺭﺍ ﺗﻐﻴﻴﺮ ﺩﻫﺪ ﮐﻪ ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ‬
‫ﻃﻮﻝ ﺭﺷﺘﻪ ﺗﻐﻴﻴﺮ ﮐﺮﺩﻩ ﺍﺳﺖ‪.‬‬
‫‪ ü‬ﻧﮑﺘﻪ‪ :‬ﺩﺳﺘﻮﺭ ﺭﻭﺑﺮﻭ ﺧﻄﺎﺳﺖ‪S[0]:=4 • .‬‬

‫ﻣﻘﺎﻳﺴﻪ ﺭﺷﺘـﻪ ﻫﺎ ‪:‬‬

‫ﺑﺮﺍﻱ ﻣﻘﺎﻳﺴﻪ ﺭﺷﺘﻪ ﻫﺎ ﺣﺮﻑ ﺍﻭﻝ ﺭﺷﺘﻪ ﺍﻭﻝ ﺑﺎ ﺣﺮﻑ ﺍﻭﻝ ﺭﺷﺘﻪ ﺩﻭﻡ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮﺩ ﺍﮔﺮ ﻧﺘﻴﺠﻪ ﮔﺮﻓﺘﻪ ﻧﺸﺪ ﺣﺮﻑ ﺩﻭﻡ ﻫﺎ ﺭﺍ ﻣﻘﺎﻳﺴﻪ‬
‫ﻣﻲ ﮐﻨﻴﻢ ﻭ ﺍﻟﻲ ﺁﺧﺮ‪ .‬ﻣﻌﻴﺎﺭ ﻣﻘﺎﻳﺴﻪ ﮐﺪ ﺍﺳﮑﻲ ﮐﺎﺭﺍﮐﺘﺮﻫﺎﺳﺖ‪ .‬ﺍﺯ ﻫﺮ ﺣﺮﻓﻲ ﮐﻪ ﻧﺘﻴﺠﻪ ﮔﺮﻓﺘﻪ ﺷﺪ ﻣﺎﺑﻘﻲ ﺣﺮﻭﻑ ﻣﻘﺎﻳﺴﻪ ﻧﻤﻲ ﺷﻮﺩ‪.‬‬

‫ﻣﺜﺎل ‪ ( 1‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ رﺷﺘﻪ را درﯾﺎﻓﺖ ﮐﻨﺪ و اﻋﺪاد داﺧﻞ آﻧﺮا اﺳﺘﺨﺮاج ﮐﻨﺪ ‪:‬‬
‫‪var‬‬
‫;]‪s:string[50‬‬ ‫ﺑﻌﻨﻮان ﻣﺜﺎل رﺷﺘﻪ ‪ A5B82C‬را درﯾﺎﻓﺖ ﮐﻨﺪ و ﻋﺪد ‪ 582‬را‬
‫;‪N:longint‬‬
‫در ﺧﺮوﺟﯽ ﭼﺎپ ﮐﻨﺪ ‪.‬‬
‫;‪i:integer‬‬
‫‪Begin‬‬
‫;)‪readln(S‬‬
‫;‪N:=0‬‬
‫‪for i:=1 to ord(S[0]) do‬‬
‫‪if (S[i]>='0') and (S[i]<='9') then‬‬
‫; ‪N := N * 10 + Ord(s[i]) – 48‬‬
‫;)‪writeln(N‬‬
‫‪End.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪85‬‬
‫ﻣﺜﺎل ‪ ( 2‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ رﺷﺘﻪ را درﯾﺎﻓﺖ ﮐﻨﺪ و ﻣﻌﮑﻮس آﻧﺮا در ﺧﺮوﺟﯽ ﭼﺎپ ﮐﻨﺪ ‪:‬‬
‫‪var‬‬
‫;‪s,m:string‬‬ ‫ﺑﻌﻨﻮان ﻣﺜﺎل رﺷﺘﻪ ‪ pascal‬را درﯾﺎﻓﺖ ﮐﻨﺪ و رﺷﺘﻪ ‪ lacsap‬را ﭼﺎپ ﮐﻨﺪ‪.‬‬
‫;‪i:integer‬‬
‫‪Begin‬‬
‫;)‪readln(S‬‬
‫;''=‪m:‬‬
‫‪for i:=1 to ord(S[0]) do‬‬
‫;‪m:= s[i] + m‬‬
‫;]‪m[0]:=s[0‬‬
‫;)‪writeln(m‬‬
‫‪End.‬‬

‫ﻣﺜﺎل ‪ ( 3‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ رﺷﺘﻪ از ﮐﺎرﺑﺮ درﯾﺎﻓﺖ ﮐﻨﺪ و ﻓﺮاواﻧﯽ ﻫﺮ ﯾﮏ از ﺣﺮوف اﻟﻔﺒـﺎي اﻧﮕﻠﯿـﺴﯽ را ﭼـﺎپ ﮐﻨـﺪ و‬
‫ﻫﻤﭽﻨﯿﻦ ﻓﺮاواﻧﯽ ﮐﺎراﮐﺘﺮﻫﺎي دﯾﮕﺮ را ﺑﻮﺳﯿﻠﻪ ﻣﺘﻐﯿﺮي ﺑﻨﺎم ‪ other‬ﭼﺎپ ﻧﻤﺎﯾﺪ ‪:‬‬
‫‪var‬‬
‫;‪S:string‬‬ ‫ﺑﻌﻨﻮان ﻣﺜﺎل رﺷﺘﻪ ‪ WWW)987HHKKPHH‬را درﯾﺎﻓﺖ ﻣـﯽ ﮐﻨـﺪ‬
‫;‪f:array['A'..'Z']of byte‬‬ ‫و ﺧﺮوﺟﯽ آن ﺑﺼﻮرت زﯾﺮ ﻣﯽ ﺑﺎﺷﺪ ‪:‬‬
‫;‪other,i:integer‬‬
‫;‪C:char‬‬ ‫‪W 3‬‬
‫‪begin‬‬ ‫‪H 4‬‬
‫;)‪readln(S‬‬ ‫‪K 2‬‬
‫‪for C:='A' to 'Z' do‬‬ ‫‪P 1‬‬
‫;‪f[C]:=0‬‬ ‫‪OTHER 4‬‬
‫;‪other:=0‬‬
‫‪for i:=1 to ord(s[0]) do‬‬
‫‪if (S[i]>='A') and (S[i]<='Z') then‬‬
‫‪F[S[i]]:=F[S[i]]+1‬‬
‫‪else‬‬
‫;‪other:=other+1‬‬
‫‪for c:='A' to 'Z' do‬‬
‫‪if F[C]>0 then‬‬
‫;)]‪Writeln(C ,' ', F[C‬‬
‫;)‪writeln('Other=',other‬‬
‫‪end.‬‬
‫ﺍﻟﺤﺎﻕ ﺭﺷﺘـﻪ ﻫﺎ ‪:‬‬
‫ﺑﺮﺍﻱ ﺍﻟﺤﺎﻕ ﺭﺷﺘﻪ ﻫﺎ ﺍﺯ ﺩﻭ ﺭﻭﺵ ﺯﻳﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﮐﻨﻴﻢ ‪:‬‬
‫‪ -1‬ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻋﻤﻠﮕﺮ ‪+‬‬
‫‪ -2‬ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺗﺎﺑﻊ ‪concat‬‬
‫ﺍﻟﺤﺎﻕ ﺩﺭ ﭘﺎﺳﮑﺎﻝ ﺧﺎﺻﻴﺖ ﺟﺎﺑﺠﺎﻳﻲ ﻧﺪﺍﺭﺩ‪.‬‬
‫ﺍﺭﺳﺎﻝ ﺭﺷﺘـﻪ ﺑﻪ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ‪:‬‬
‫ﺭﺷﺘﻪ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﻪ ﺳﻪ ﺭﻭﺵ ﻣﻘﺪﺍﺭ)ﺍﺭﺯﺷﻲ( ﻭﻣﺘﻐﻴﺮ)ﻣﺮﺟﻊ( ﻳﺎ ﺛﺎﺑﺖ ﺑﻪ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﺍﺭﺳﺎﻝ ﮐﺮﺩ‪.‬ﺧﺮﻭﺟﻲ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮﺍﻧﺪ ﺭﺷﺘﻪ ﺍﻱ ﺑﺎﺷﺪ‬
‫ﺩﺭ ﺻﻮﺭﺗﻲ ﮐﻪ ﺁﺭﺍﻳﻪ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺑﺎﺷﺪ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪86‬‬
‫ﺁﺭﺍﻳﻪ ﺍﻱ ﺍﺯ ﺭﺷﺘـﻪ ﻫﺎ ‪:‬‬
‫ﺁﺭﺍﻳﻪ ﺍﯼ ﺍﺯ ﺭﺷﺘﻪ ﻫﺎ ‪ ،‬ﺁﺭﺍﻳﻪ ﺍﻱ ﺍﺳﺖ ﮐﻪ ﻫﺮ ﻋﻨﺼﺮ ﺁﻥ ﻣﻲ ﺗﻮﺍﻧﺪ ﻳﮏ ﺭﺷﺘﻪ ﺭﺍ ﺩﺭ ﺧﻮﺩ ﻧﮕﻪ ﺩﺍﺭﺩ‪.‬‬

‫‪Var‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫…‬ ‫‪10‬‬

‫; ]‪S : array[1..10] of string [20‬‬ ‫‪0 1‬‬ ‫‪20‬‬ ‫‪0 1‬‬ ‫‪20‬‬ ‫‪0 1‬‬ ‫‪20‬‬
‫; ‪I : Integer‬‬ ‫…‬
‫‪...‬‬ ‫‪...‬‬ ‫…‬
‫‪Begin‬‬
‫‪For I := 1 to 10 do‬‬ ‫ﺳﻮﺍﻝ ( ﺩﺳﺘﻮﺭ ;) ]‪ Writeln( s[3][2] , s[2,4‬ﭼﻪ ﭼﻴـﺰﻱ ﺩﺭ ﺧﺮﻭﺟـﯽ‬
‫; ) ]‪Readln(S [I‬‬
‫;'‪s[2]:='abcdef‬‬ ‫ﭼﺎﭖ ﻣﯽ ﮐﻨﺪ ؟‬
‫;'‪s[3]:='xyz‬‬
‫;) ]‪writeln( s[3][2] , s[2,4‬‬
‫‪For I := 1 to 10 do‬‬
‫; ) ]‪writeln( S [I‬‬
‫;‪Readln‬‬ ‫ﺁﺭﺍﻳﻪ ﺍﻱ ﺍﺯ ﺭﺷﺘﻪ ﻫﺎ ﺷﺒﻴﻪ ﻳﮏ ﻣﺎﺗﺮﻳﺲ ﺩﻭﺑﻌﺪﻱ ﺍﺯ ﻧﻮﻉ ‪ char‬ﺍﺳﺖ‪.‬‬
‫‪End.‬‬

‫ﺛﺎﺑﺖ ﻧـﻮﻉ ﺁﺭﺍﻳﻪ ﺍﻱ‪:‬‬

‫‪Type‬‬
‫; ‪Ar = array [1..5] of string‬‬
‫‪Const‬‬
‫; ) '‪Name : Ar = ( 'ali' , 'reza' , '' , 'amin' , 'akbar‬‬
‫ﺁﺭﺍﻳﻪ ‪ Name‬ﺍﺯ ﻧﻮﻉ ﺭﺷﺘﻪ ﺍﺳﺖ ﻭ ﻳﮏ ﺛﺎﺑﺖ ﻧﻮﻉ ﺩﺍﺭ ﺍﺳﺖ ﮐﻪ ﺩﺭ ﻟﺤﻈﻪ ﺗﻌﺮﻳﻒ ﻣﻘﺪﺍﺭ ﺩﻫﻲ ﺍﻭﻟﻴﻪ ﺷﺪﻩ ﺍﺳﺖ ﻭ ﻣﻲ ﺗﻮﺍﻥ ﻣﻘﺎﺩﻳﺮ ﺩﺍﺧـﻞ‬
‫ﺁﻥ ﺭﺍ ﺩﺭ ﻫﻨﮕﺎﻡ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﺩﺍﺩ‪.‬‬
‫ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﻫﺎﻱ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺭﺷﺘـﻪ ﺍﻱ ‪:‬‬

‫ﺗﺎﺑﻊ ‪ : length‬ﻃﻮﻝ ﻳﮏ ﺭﺷﺘﻪ ﺭﺍ ﺑﺮﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬

‫;)‪Ord( s[0] )=length(s‬‬

‫ﺗﺎﺑﻊ ‪ : concat‬ﺍﻳﻦ ﺗﺎﺑﻊ ﺗﻌﺪﺍﺩ ﻧﺎﻣﺸﺨﺼﻲ ﺍﺯ ﺭﺷﺘﻪ ﻫﺎ ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﮐﺮﺩﻩ ﻭﺁﻧﻬﺎ ﺭﺍ ﺍﻟﺤﺎﻕ ﮐﺮﺩﻩ ﻭﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ ﺍﻳﻦ ﺗﺎﺑﻊ ﺣﺎﺻﻴﺖ ﺟﺎﺑﺠﺎﻳﻲ‬
‫ﻧﺪﺍﺭﺩ‪.‬‬
‫) ﺭﺷﺘﻪ‪ , … , n‬ﺭﺷﺘﻪ‪ , ۲‬ﺭﺷﺘﻪ‪ • Concat (۱‬ﺭﺷﺘﻪ‬

‫‪S:=concat('ali' , 'reza' , 'akbar' ); ž alirezaakbar‬‬

‫ﭘﺮوﺳﯿﺠﺮ ‪ : str‬ﺍﻳﻦ ﭘﺮﻭﺳﻴﺠﺮﻳﮏ ﻋﺪﺩﺩﺭﻳﺎﻓﺖ ﮐﺮﺩﻩ ﻭﺁﻥ ﺭﺍ ﺗﺒﺪﻳﻞ ﺑﻪ ﺭﺷﺘﻪ ﻣﻲ ﮐﻨﺪ ﻭ ﺭﺷﺘﻪ ﺭﺍ ﺩﺭﭘﺎﺭﺍﻣﺘﺮﺩﻭﻡ ﻣﻲ ﺭﻳﺰﺩ‪.‬‬

‫;)‪) str (14,s1‬ﻣﺜﺎﻝ‬

‫;)‪str (2.5,s2‬‬ ‫) ﻣﺘﻐﻴﺮ ﺭﺷﺘﻪ ﺍﻱ ‪ ,‬ﻋﺒﺎﺭﺕ ﻳﺎ ﻣﺘﻐﻴﺮ ﻳﺎ ﻋﺪﺩ( ‪str‬‬
‫‪writeln(s1,s2); ž 142.5‬‬
‫;)‪) str($12+3,s‬ﻣﺜﺎﻝ‬
‫‪Writeln(s); ž 21‬‬
87 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
: ‫ ﺭﺍ ﺷﺒﻴﻪ ﺳﺎﺯﻱ ﻛﻨﺪ‬str ‫ ( ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﭘﺮﻭﺳﻴﺠﺮ‬۴ ‫ﻣﺜﺎﻝ‬
procedure mystr(n:integer ;var s:string);
var
r,i:integer; m:string;
begin
i:=1;
while n>0 do
begin
r:=n mod 10;
n:=n div 10;
s[i]:=chr(r+48);
i:=i+1;
end;
s[0]:=chr(i-1);
m:='';
for i:=1 to length(s) do
m:=s[i]+m;
m[0]:=s[0];
s:=m;
end;
var
z:string;
begin
mystr(348,z);
writeln(z);
end.

‫ﺗﻤﺮﻳﻦ ( ﺧﺮﻭﺟﻲ ﺑﺮﻧﺎﻣﻪ ﭼﻴﺴﺖ ؟‬

var
s:string;
begin
str(-3.758:0:2,s);
writeln(s);
writeln(length(s));
end.

.‫ ﺍﻳﻦ ﺗﺎﺑﻊ ﻳﮏ ﮐﺎﺭﺍﮐﺘﺮ ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﮐﺮﺩﻩ ﻭﺣﺮﻑ ﺑﺰﺭﮒ ﺁﻥ ﺭﺍ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ‬: upcase ‫ﺗﺎﺑﻊ‬

Upcase ('b'); ž B ‫ • ﮐﺎﺭﺍﮐﺘﺮ‬Upcase(‫)ﮐﺎﺭﺍﮐﺘﺮ‬

Upcase ('A'); ž A
Upcase ('+'); ž +

: ‫ ( ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻚ ﺭﺷﺘﻪ ﺍﺯ ﻛﺎﺭﺑﺮ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﻫﻤﻪ ﻱ ﺣﺮﻭﻑ ﺁﻧﺮﺍ ﺑﻪ ﻛﻮﭼﻚ ﺗﺒﺪﻳﻞ ﻛﻨﺪ‬۵ ‫ﻣﺜﺎﻝ‬
var
s:string; i:integer;
begin
readln(s);
for i:=1 to length(s) do
if (s[i]>='A') and (s[i]<='Z') then
s[i] := chr ( ord (s[i]) + 32 );
writeln(s);
end.
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪88‬‬
‫ﭘﺮوﺳﯿﺠـﺮ ‪ : val‬ﺍﻳﻦ ﭘﺮﻭﺳﻴﺠﺮ ﻳﮏ ﺭﺷﺘﻪ ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﮐﻨﺪ ﻭ ﺩﺭ ﺻﻮﺭﺗﻲ ﮐﻪ ﺑﺘﻮﺍﻧﺪ ﺁﻥ ﺭﺍ ﺗﺒﺪﻳﻞ ﺑﻪ ﻋﺪﺩ ﮐﻨﺪ ﻋﺪﺩ ﺭﺍ ﺩﺭ ﭘﺎﺭﺍﻣﺘﺮ ﺩﻭﻡ ﻭ‬
‫ﻋﺪﺩ ﺻﻔﺮ ﺭﺍ ﺩﺭ ﭘﺎﺭﺍﻣﺘﺮ ﺳﻮﻡ ﻣﻲ ﺭﻳﺰﺩ ﻭﻟﻲ ﺍﮔﺮ ﻧﺘﻮﺍﻧﺪ ﺗﺒﺪﻳﻞ ﮐﻨﺪ ﺁﻧﮕﺎﻩ ﻣﺤﻞ ﺧﻄﺎ)ﻣﺤﻞ ﮐﺎﺭﺍﮐﺘﺮ ﻏﻴﺮ ﻣﺠﺎﺯ( ﺭﺍ ﺩﺭ ﭘﺎﺭﺍﻣﺘﺮ ﺳﻮﻡ ﻣﻲ ﺭﻳﺰﺩ ﻭ‬
‫ﺩﺭ ﭘﺎﺭﺍﻣﺘﺮ ﺩﻭﻡ ﺻﻔﺮ ﻣﻲ ﺭﻳﺰﺩ‪.‬‬
‫)ﻣﺘﻐﻴﺮ ﺻﺤﻴﺢ ‪ ,‬ﻣﺘﻐﻴﺮ ﻋﺪﺩﻱ ‪ ,‬ﺭﺷﺘﻪ(‪Val‬‬

‫)ﻣﺜﺎﻝ‬ ‫;)‪val ('128' , a , c‬‬ ‫ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ‪ c=0‬ﻭ‪a=128‬‬

‫)ﻣﺜﺎﻝ‬ ‫;) ‪val ('12a45' , a, c‬‬ ‫ﺩﺭﺍﻳﻦ ﻣﺜﺎﻝ ‪ c=3‬ﻭ ‪a=0‬‬
‫)ﻣﺜﺎﻝ‬ ‫ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ‪ intC=0‬ﻭ ‪val ('12.56' , rlA , intC ); rlA=12.56‬‬
‫)ﻣﺜﺎﻝ‬ ‫ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ‪ intC=3‬ﻭ ‪val ('14.76' , intA , intC ); intA=0‬‬

‫ﺗﺎﺑﻊ ‪ : pos‬ﺍﻳﻦ ﺗﺎﺑﻊ ﺭﺷﺘﻪ ‪ ۱‬ﺭﺍ ﺩﺭ ﺭﺷﺘﻪ ‪ ۲‬ﺟﺴﺖ ﻭﺟﻮ ﻣﻲ ﮐﻨﺪ ﺩﺭﺻﻮﺭﺕ ﭘﻴﺪﺍﺷﺪﻥ ﻣﺤﻞ ﺍﻭﻟﻴﻦ ﻭﻗﻮﻉ ﺁﻥ ﺭﺍﺑﺮﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬
‫)ﺭﺷﺘﻪ ‪ , ۲‬ﺭﺷﺘﻪ ‪ • Pos(۱‬ﻋﺪﺩ ﺻﺤﻴﺢ‬
‫)'‪6 • Pos ('amh' , 'amzhbamhdqamh‬‬
‫)'‪0 • Pos ('abc' , 'aBCdABcd‬‬
‫)'‪0 • pos ('ABCDEF' , 'CD‬‬

‫ﺗﺎﺑﻊ ‪ : copy‬ﺍﻳﻦ ﺗﺎﺑﻊ ﻗﺴﻤﺘﻲ ﺍﺯ ﻳﮏ ﺭﺷﺘﻪ ﺭﺍ ﺍﺳﺘﺨﺮﺍﺝ ﻣﻲ ﮐﻨﺪ‪.‬‬

‫)ﻋﺪﺩ ﺻﺤﻴﺢ ﻃﻮﻝ ‪ ,‬ﻋﺪﺩ ﺻﺤﻴﺢ ﺷﺮﻭﻉ ‪ ,‬ﺭﺷﺘﻪ(‪• Copy‬ﺭﺷﺘﻪ‬

‫)‪BCD• Copy ('ABCDEFG', 2,3‬‬

‫)‪D• copy ('ABCD' , 4,3‬‬

‫ﻣﺜﺎﻝ ‪ ( ۶‬ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺗﺎﺑﻊ ﻛﭙﻲ ﺭﺍ ﺷﺒﻴﻪ ﺳﺎﺯﻱ ﻛﻨﺪ ‪:‬‬

‫;‪function mycopy(s:string; k,n:integer):string‬‬
‫‪var‬‬
‫;‪m:string; i:integer‬‬
‫‪begin‬‬
‫;''=‪m:‬‬
‫‪If n+k > length(s) then‬‬
‫;‪n := length(s) – k + 1‬‬
‫‪for‬‬ ‫‪i:=k to k+n do‬‬
‫;]‪m[i-k+1] := s[i‬‬
‫;)‪m[0] := chr(n‬‬
‫;‪mycopy := m‬‬
‫;‪end‬‬
‫‪begin‬‬
‫;) )‪writeln(mycopy( 'abcdef' , 2 , 4‬‬
‫‪end.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪89‬‬
‫ﭘﺮوﺳﯿﺠـﺮ ‪ : insert‬ﺍﻳﻦ ﭘﺮﻭﺳﻴﺠﺮ ﻳﮏ ﺭﺷﺘﻪ ﺭﺍ ﺍﺯ ﻣﺤﻞ ﻣﺸﺨﺼﻲ ﺩﺭ ﺭﺷﺘﻪ ﺩﻳﮕﺮ ﺩﺭﺝ ﻣﻲ ﮐﻨﺪ‪.‬‬

‫) ﻋﺪﺩ ﺻﺤﻴﺢ ‪ ,‬ﻣﺘﻐﻴﺮ ﺭﺷﺘﻪ ﺍﻱ ‪ ,‬ﺭﺷﺘﻪ ‪Insert (۱‬‬

‫;'‪) s:='ABCDEFG‬ﻣﺜﺎﻝ‬
‫;)‪Insert ('XYZ',s,5‬‬
‫'‪Writeln(s); ž 'ABCDXYZEFG‬‬
‫ﻧﮑﺘﻪ ‪ :‬ﺩﺳﺘﻮﺭ )‪ insert(s1,s2,length(s2)+1‬ﺑﺮﺍﺑﺮ ﺍﺳﺖ ﺑﺎ ‪s2:=s2+s1‬‬
‫ﻧﮑﺘﻪ ‪ :‬ﺩﺳﺘﻮﺭ ‪ insert‬ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﺎ ﺗﺮﮐﻴﺐ ﺩﺳﺘﻮﺭﻫﺎﻱ ‪ copy‬ﻭ ﺍﻟﺤﺎﻕ ﺍﻧﺠﺎﻡ ﺩﺍﺩ‪:‬‬
‫ﺑﺮﺍﺑﺮ ﺍﺳﺖ ﺑﺎ ﺧﻂ ﺯﻳﺮ )‪Insert(s2,s1,x‬‬
‫)‪S1:= copy (s1,1,x-1) + s2 + copy (s1, x , length(s1) – x + 1‬‬

‫ﭘﺮوﺳﯿﺠـﺮ ‪ : delete‬ﺍﻳﻦ ﭘﺮﻭﺳﻴﺠﺮ ﻗﺴﻤﺘﻲ ﺍﺯ ﻳﮏ ﺭﺷﺘﻪ ﺭﺍ ﺣﺬﻑ ﻣﻲ ﮐﻨﺪ‪.‬‬

‫)ﻋﺪﺩ ﺻﺤﻴﺢ ﻃﻮﻝ ‪ ,‬ﻋﺪﺩ ﺻﺤﻴﺢ ﺷﺮﻭﻉ ‪ ,‬ﻣﺘﻐﻴﺮ ﺭﺷﺘﻪ(‪Delete‬‬

‫; '‪S := 'ABCDEFG‬‬
‫;)‪Delete(s,3,2‬‬
‫'‪Write(s); ž 'ABEFG‬‬
‫ﺑﻪ ﻭﺳﻴﻠﻪ ﺗﺎﺑﻊ ‪ copy‬ﻭﻋﻤﻞ ﺍﻟﺤﺎﻕ ﭘﺮﻭﺳﻴﺠﺮ ‪ delete‬ﺭﺍ ﺷﺒﻴﻪ ﺳﺎﺯﻱ ﮐﻨﻴﺪ‪.‬‬

‫ﻣﺜﺎﻝ ‪ ( ۷‬ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺭﺷﺘﻪ ﻫﺎﻱ ‪ Z1 , Z2 , Z3‬ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ؛ﺳﭙﺲ ﺭﺷﺘﻪ ‪ Z2‬ﺭﺍ ﺍﺯ ‪ Z1‬ﺣـﺬﻑ ﻛﻨـﺪ ﻭ ﺑﺠـﺎﻱ ﺁﻥ ‪ Z3‬ﺭﺍ‬
‫ﻗﺮﺍﺭ ﺩﻫﺪ ‪:‬‬
‫;)‪procedure replace(var s1:string ; s2,s3:string‬‬
‫‪var‬‬
‫;‪p,L1:integer‬‬
‫‪begin‬‬ ‫ﻣـﺜﻼ ﺭﺷـﺘﻪ ‪ Z1 = abcdefcdghcd‬ﻭ ‪ Z2 = cd‬ﻭ ‪Z3 = pascal‬‬
‫;)‪L1:=length(s2‬‬ ‫ﺭﺍ ﻭﺍﺭﺩ ﻣــﻲ ﻛﻨــﻴﻢ ‪ cd ،‬ﺭﺍ ﻛــﻪ ﻫﻤــﺎﻥ ‪ Z2‬ﺍﺳــﺖ ﺍﺯ ‪ Z1‬ﻛــﻪ ﻫﻤــﺎﻥ‬
‫;)‪p:=pos(s2,s1‬‬
‫‪while(p<>0) do‬‬ ‫‪ abcdefcdghcd‬ﺍﺳﺖ ﺣﺬﻑ ﻣﻲ ﻛﻨـﺪ ﻭ ﺑﺠـﺎﻱ ‪ cd‬ﻫـﺎﻱ ﺣـﺬﻑ ﺷـﺪﻩ ‪،‬‬
‫‪begin‬‬ ‫‪ pascal‬ﺭﺍ ﻗــــــﺮﺍﺭ ﻣﻴﺪﻫــــــﺪ ؛ ﻳﻌﻨــــــﻲ ﺩﺭ ﻧﻬﺎﻳــــــﺖ ﺭﺷــــــﺘﻪ‬
‫;)‪delete(s1,p,L1‬‬ ‫‪ abpascalefpascalghpascal‬ﺭﺍ ﻛﻪ ﻫﻤﺎﻥ ‪ Z1‬ﺍﺳﺖ ﺩﺭ ﺧﺮﻭﺟﻲ ﭼـﺎﭖ‬
‫;)‪insert(s3,s1,p‬‬
‫ﻣﻲ ﻧﻤﺎﻳﺪ ‪.‬‬
‫;)‪p:=pos(s2,s1‬‬
‫;‪end‬‬
‫;‪end‬‬
‫‪var‬‬
‫;‪z1,z2,z3:string‬‬
‫‪begin‬‬
‫;)‪readln(z1‬‬
‫;)‪readln(z2‬‬
‫;)‪readln(z3‬‬
‫;)‪replace(z1,z2,z3‬‬
‫;)‪writeln(z1‬‬
‫‪end.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪90‬‬
‫ﻣﺜﺎﻝ ‪ ( ۸‬ﺑﺮﻧﺎﻣﻪ ﺍﻳﻲ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺭﺷﺘﻪ ﺍﻳﻲ ﺍﺯ ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﻛﻪ ﺑﻴﺎﻧﮕﺮ ﻳﻚ ﻋﺪﺩ ﺭﻭﻣﻲ ﺍﺳﺖ ﺭﺍ ﺍﺯ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﺑﺨﻮﺍﻧﺪ ﻭ ﺳﭙﺲ ﻋﺪﺩ ﻣﻌـﺎﺩﻝ ﺁﻥ‬
‫ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ‪ .‬ﺣﺮﻭﻑ ﺭﻭﻣﻲ ﺑﻪ ﺻﻮﺭﺕ ﺟﺪﻭﻝ ﺯﻳﺮ ﻫﺴﺘﻨﺪ‪.‬‬
‫ﺣﺮﻑ ﺭﻭﻣﻲ‬ ‫ﻋﺪﺩ ﻣﻌﺎﺩﻝ‬
‫‪M‬‬ ‫‪1000‬‬
‫‪D‬‬ ‫‪500‬‬
‫‪C‬‬ ‫‪100‬‬
‫‪L‬‬ ‫‪50‬‬
‫‪X‬‬ ‫‪10‬‬
‫‪V‬‬ ‫‪5‬‬
‫‪I‬‬ ‫‪1‬‬

‫ﻣﺜﻼ ﺭﺷﺘﻪ ‪ MCX‬ﻣﻌﺎﺩﻝ ﻋﺪﺩ ‪ 1110‬ﺍﺳﺖ ﻳﺎ ﺭﺷﺘﺔ ‪ DLXVI‬ﻣﻌﺎﺩﻝ ﻋﺪﺩ ‪ 566‬ﺍﺳﺖ‪ .‬ﻳﺎ ﺭﺷﺘﺔ ‪ CXXV‬ﻣﻌﺎﺩﻝ ﻋﺪﺩ‪ 125‬ﺍﺳﺖ‪.‬‬

‫;‪function rumi (s:string):longint‬‬

‫‪var‬‬
‫;‪i:integer‬‬
‫;‪n:longint‬‬
‫‪begin‬‬
‫;‪n:=0‬‬
‫‪for i:=1 to length(s) do‬‬
‫‪case s[i] of‬‬
‫;‪'M': n:=n+1000‬‬
‫;‪'D': n:=n+500‬‬
‫;‪'C': n:=n+100‬‬
‫;‪'L': n:=n+50‬‬
‫;‪'X': n:=n+10‬‬
‫;‪'V': n:=n+5‬‬
‫;‪'I' : n:=n+1‬‬
‫;‪end‬‬
‫;‪rumi:=n‬‬
‫;‪end‬‬
‫‪var‬‬
‫;‪z:string‬‬
‫‪begin‬‬
‫;)‪readln(z‬‬
‫;))‪writeln(rumi(z‬‬
‫‪end.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪91‬‬
‫رﮐـﻮرد ‪:‬‬
‫ﺭﻛﻮﺭﺩ ﻣﺠﻤﻮﻋﻪ ﺍﻱ ﺍﺯ ﻓﻴﻠﺪ ﻫﺎ ﺍﺳﺖ ﻛﻪ ﻫﺮ ﻛﺪﺍﻡ ﻣﻲ ﺗﻮﺍﻧﻨﺪ ﻳﻚ ﻧﻮﻉ ﺧﺎﺻﻲ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ ﻭ ﻫﺮ ﻛﺪﺍﻡ ﻧﻴﺰ ﺩﺍﺭﺍﻱ ﻳﻚ ﻧـﺎﻡ ﻫـﺴﺘﻨﺪ ﻭ‬
‫ﺗﺤﺖ ﻳﻚ ﻧﺎﻡ ﺫﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﻣﺜﻼ ﺑﺮﺍﻱ ﺫﺧﻴﺮﻩ ﻛﺮﺩﻥ ﺍﻃﻼﻋﺎﺕ ﻳﻚ ﺩﺍﻧﺶ ﺁﻣﻮﺯ ﺷﺎﻣﻞ ﻧﺎﻡ ﻓﺎﻣﻴﻠﻲ ‪ ،‬ﺷﻤﺎﺭﻩ ﺩﺍﻧﺶ ﺁﻣﻮﺯﻱ ﻭ ﻣﻌﺪﻝ ﺭﻛﻮﺭﺩ‬
‫ﺯﻳﺮ ﺭﺍ ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬
‫‪Name‬‬ ‫‪Family‬‬ ‫‪StdId‬‬ ‫‪AVG‬‬

‫‪Student‬‬

‫ﺗﻔـﺎوت آراﯾـﻪ و رﮐـﻮرد ‪:‬‬

‫‪ - ۱‬ﻧﻮﻉ ﺳﻠﻮﻝ ﻫﺎﻱ ﺁﺭﺍﻳﻪ ﻳﻜﺴﺎﻥ ﺍﺳﺖ ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ ﻓﻴﻠﺪ ﻫﺎﻱ ﺭﻛﻮﺭﺩ ﻣﻲ ﺗﻮﺍﻧﻨﺪ ﻫﻢ ﻧﻮﻉ ﻧﺒﺎﺷﻨﺪ‪.‬‬
‫‪ - ۲‬ﺁﺭﺍﻳﻪ ﺩﺍﺭﺍﻱ ﺍﻧﺪﻳﺲ ﺍﺳﺖ ﺍﻣﺎ ﺭﻛﻮﺭﺩ ﻫﺮ ﻓﻴﻠﺪﺵ ﺩﺍﺭﺍﻱ ﻳﻚ ﻧﺎﻡ ﺍﺳﺖ ‪.‬‬

‫ﻧﺤﻮه ي ﺗﻌـﺮﯾﻒ رﮐﻮرد ‪:‬‬

‫ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﺭﮐﻮﺭﺩ ﺍﺑﺘﺪﺍ ﺩﺭ ﻗﺴﻤﺖ ‪ Type‬ﻧﻮﻉ ﺁﻥ ﺭﺍ ﺗﻌﺮﻳﻒ ﻣﻲ ﮐﻨﻴﻢ ﺳﭙﺲ ﺩﺭ ﻗﺴﻤﺖ ‪ var‬ﻣﺘﻐﻴﺮ ﺭﮐﻮﺭﺩﻱ ﺭﺍ ﺗﻌﺮﻳﻒ ﻣﻲ ﮐﻨﻴﻢ‬
‫ﺑﺮﺍﻱ ﺗﻌﺮﻳﻒ ﻧﻮﻉ ﺭﮐﻮﺭﺩ ﺍﺯ ﮐﻠﻤﻪ ﺭﺯﺭﻭ ﺷﺪﻩ ‪ record‬ﺑﻪ ﺭﻭﺵ ﺯﻳﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﮐﻨﻴﻢ ‪:‬‬
‫‪Type‬‬
‫‪Rec1=record‬‬
‫;]‪Name : string [10‬‬
‫;]‪Family: string [15‬‬
‫;‪AVG: real‬‬
‫;‪STDid : longint‬‬
‫;‪End‬‬
‫‪Var‬‬
‫;‪Student : rec1‬‬
‫ﻣﺠﻤﻮﻉ ﻓﻀﺎﻱ ﺍﺷﻐﺎﻟﻲ ﻓﻴﻠﺪ ﻫﺎ ‪ ،‬ﺣﺎﻓﻈﻪ ﺍﺷﻐﺎﻝ ﺷﺪﻩ ﻱ ﺭﻛﻮﺭﺩ ﺭﺍ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ ‪.‬‬
‫‪11+16+6+4=37‬‬ ‫ﺑﺮﺍﻱ ﻣﺜﺎﻝ ﻓﻀﺎﻱ ﺍﺷﻐﺎﻟﻲ ﺭﮐﻮﺭﺩ ﺑﺎﻻ ﺍﺯ ﻣﺤﺎﺳﺒﻪ ﺭﻭﺑﺮﻭ ﺑﻪ ﺩﺳﺖ ﻣﻲ ﺁﻳﺪ ‪:‬‬

‫ﻫﻨﮕﺎﻣﻴﻜﻪ ﻣﻲ ﺧﻮﺍﻫﻴﻢ ﺍﻃﻼﻋﺎﺕ ﻣﺨﺘﻠﻔﻲ ﺍﺯ ﺷﻲ ﻳﺎ ﻓﺮﺩ ﻳﺎ ‪ ...‬ﺭﺍ ﺫﺧﻴﺮﻩ ﻛﻨﻴﻢ ﺑﻬﺘﺮ ﺍﺳﺖ ﻛﻪ ﺍﻃﻼ ﻋﺎﺕ ﺁﻥ ﺭﺍ ﻛﻨﺎﺭ ﻫﻢ ﺩﺍﺷﺘﻪ ﺑﺎﺷـﻴﻢ ﺑـﻪ‬
‫ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺍﺯ ﺭﻛﻮﺭﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬
‫ﻧﺤﻮﻩ ﻱ ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﻓﻴﻠﺪﻫﺎﻱ ﺭﻛـﻮﺭﺩ ‪:‬‬
‫ﺑﺮﺍﻱ ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﻓﻴﻠﺪﻫﺎﻱ ﻳﻚ ﺭﻛﻮﺭﺩ ﺍﺑﺘﺪﺍ ﻧﺎﻡ ﺭﻛﻮﺭﺩ ﺭﺍ ﻧﻮﺷﺘﻪ ‪،‬ﺳﭙﺲ ﻳﻚ ﻧﻘﻄﻪ ﻣﻲ ﮔﺬﺍﺭﻳﻢ ﻭ ﺑﻌﺪ ﺍﺯ ﺁﻥ ﻧﺎﻡ ﻓﻴﻠﺪ ﺭﺍ ﻣﻲ ﮔﺬﺍﺭﻳﻢ‪.‬‬
‫ﻧﺎم ﻓﯿﻠﺪ ‪ .‬ﻧﺎم رﮐـﻮرد‬
‫‪Begin‬‬
‫;’‪Student . name := ‘ali‬‬
‫;)‪Readln (student . family‬‬
‫;‪Student . AVG := student . AVG+10‬‬
‫;)‪Writeln (student . STDid‬‬
‫;‪Student . name[0] := #3‬‬
‫‪End.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪92‬‬
‫ﺑﺮﺍﻱ ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﻓﻴﻠﺪ ﻫﺎﻱ ﻳﻚ ﺭﻛﻮﺭﺩ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﺍﺯ ﺩﺳﺘﻮﺭ‪ With‬ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﻢ‪.‬ﺗﻜﺮﺍﺭ ﻧﺎﻡ ﺭﻛﻮﺭﺩ ﻭﻗﺖ ﮔﻴﺮ ﻭ ﺧﺴﺘﻪ ﻛﻨﻨﺪﻩ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﻣﺜﺎﻝ ‪ ( ۱‬ﺑﺮﺍﻱ ﭘﻲ ﺑﺮﺩﻥ ﺑﻪ ﭼﮕﻮﻧﮕﻲ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ With‬ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻱ ﺯﻳﺮ ﺩﻗﺖ ﻛﻨﻴﺪ ‪:‬‬

‫‪TYPE‬‬
‫‪STD=RECORD‬‬
‫;‪NAME:STRING‬‬
‫;‪FAMILY:STRING‬‬
‫;‪AVG:REAL‬‬
‫;‪END‬‬
‫‪VAR‬‬
‫; ‪S1 , S2 : STD‬‬
‫‪BEGIN‬‬
‫; '‪S1.NAME := 'ALI‬‬
‫‪WITH S1 DO‬‬
‫‪BEGIN‬‬
‫; '‪FAMILY := 'HASANI‬‬
‫; ‪AVG := 14‬‬
‫;‪END‬‬
‫;‪S2 := S1‬‬
‫‪END.‬‬

‫ﺭﺷﺘﻪ ﻫﺎ ﻭ ﺁﺭﺍﻳﻪ ﻫﺎ ﺭﺍ ﻧﻤﻲ ﺗﻮﺍﻥ ﻳﻜﺠﺎ ﺩﺭﻳﺎﻓﺖ ﻳﺎ ﭼﺎﭖ ﮐﺮﺩ ‪.‬‬ ‫‪ü‬‬
‫ﺍﮔﺮ ﺩﻭ ﺭﻛﻮﺭﺩ ﻫﻢ ﻧﻮﻉ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﺑﺎ ﻳﻚ ﺩﺳﺘﻮﺭ ﺍﻧﺘﺴﺎﺏ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﻣﺤﺘﻮﺍﻱ ﻓﻴﻠﺪ ﻫﺎﻱ ﻳﻜﻲ ﺭﺍ ﺩﺭ ﺩﻳﮕﺮﻱ ﻛﭙﻲ ﻛﻨﻴﻢ‪.‬‬ ‫‪ü‬‬
‫ﺭﻛـﻮﺭﺩ ﻫﺎﻱ ﺗﻮ ﺩﺭ ﺗﻮ )ﺭﻛﻮﺭﺩ ﺣﺎﻭﻱ ﺭﻛﻮﺭﺩ( ‪:‬‬
‫ﻓﻴﻠﺪﻫﺎﻱ ﻳﻚ ﺭﻛﻮﺭﺩ ﻣﻲ ﺗﻮﺍﻧﻨﺪ ﺍﺯ ﻧﻮﻉ ﺭﻛﻮﺭﺩ ﺩﻳﮕﺮﻱ ﺑﺎﺷﻨﺪ ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﻣﻲ ﺧﻮﺍﻫﻴﻢ ﺍﻃﻼﻋﺎﺕ ﻳﻚ ﺩﺍﻧﺶ ﺁﻣﻮﺯ ﺷﺎﻣﻞ‬
‫ﺷﻤﺎﺭﻩ ﺩﺍﻧﺶ ﺁﻣﻮﺯﻱ‪ ،‬ﻧﺎﻡ‪ ،‬ﻓﺎﻣﻴﻠﻲ ﻭ ﺗﺎﺭﻳﺦ ﺗﻮﻟﺪ ﺭﺍ داﺷﺘﻪ ﺑﺎﺷﯿﻢ ﮐﻪ ﺗﺎرﯾﺦ ﺗﻮﻟﺪ ﺧﻮﺩ ﺍﺯ ﺳﻪ ﻗﺴﻤﺖ ﺳﺎﻝ‪،‬ﻣﺎﻩ‪،‬ﺭﻭﺯ ﺗﺸﻜﻴﻞ ﻣﻲ ﺷﻮﺩ ‪.‬‬

‫‪ID‬‬ ‫‪Name‬‬ ‫‪Family‬‬ ‫‪BirthDate‬‬

‫‪Student‬‬ ‫‪y‬‬ ‫‪m‬‬ ‫‪d‬‬

‫‪Type‬‬
‫‪Rec1= record‬‬
‫;‪Y: integer‬‬
‫;‪M: 1 .. 12‬‬
‫;‪D: 1 .. 31‬‬
‫;‪End‬‬
‫‪Rec2= record‬‬
‫;‪Id: longint‬‬
‫;]‪Name: string[10‬‬
‫;]‪Family: string [15‬‬
‫;‪BirthDate : rec1‬‬
‫;‪End‬‬
‫‪Var‬‬
‫;‪Student : rec2‬‬
‫ﻣﺘﻐﻴﺮ ‪ student‬ﭼﻨﺪ ﺑﺎﻳﺖ ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﻣﻲ ﮐﻨﺪ؟‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪93‬‬
‫ﺁﺭﺍﻳﻪ ﺍﻱ ﺍﺯ ﺭﻛـﻮﺭﺩ ﻫﺎ ‪:‬‬
‫ﺑﺮﺍﻱ ﺫﺧﻴﺮﻩ ﺍﻃﻼ ﻋﺎﺕ ‪ ۱۰۰‬ﺩﺍﻧﺶ ﺁﻣﻮﺯﻛﻪ ﻫﺮ ﺩﺍﻧﺶ ﺁﻣﻮﺯ ﺩﺍﺭﺍﻱ ﻧﺎﻡ‪،‬ﻓﺎﻣﻴﻠﻲ ﻭ ﻣﻌﺪﻝ ﺍﺳﺖ ﺍﺯ ﺳﺎﺧﺘﺎﺭ ﺯﻳﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪:‬‬
‫‪1‬‬ ‫‪2‬‬ ‫…‬ ‫‪100‬‬
‫‪Name Family AVG Name Family AVG‬‬ ‫‪Name Family AVG‬‬
‫‪Students‬‬ ‫‪...‬‬

‫ﻧﺤـﻮه ﺗﻌﺮﯾﻒ ‪:‬‬

‫‪Type‬‬
‫‪Rec = record‬‬
‫;]‪Name : string [10‬‬
‫;]‪Family: string [15‬‬
‫;‪AVG : real‬‬
‫;‪End‬‬
‫‪Var‬‬
‫; ‪Students : array [1..100] of Rec‬‬
‫ﻧﺤـﻮه دﺳﺘـﺮﺳﯽ ‪:‬‬
‫; ﻣﻘـﺪار =‪ :‬ﻓﯿﻠﺪ‪ ].‬اﻧﺪﯾﺲ [ ﻧﺎم آراﯾﻪ‬
‫; ‪) Students [2].AVG := 11‬ﻣﺜﺎل‬
‫ﺑﺮﺍﻱ ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﺗﻤﺎﻡ ﺳﻠﻮﻟﻬﺎﻱ ﺁﺭﺍﻳﻪ ﺍﺯ ﺣﻠﻘﻪ ‪ FOR‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﻣﺜﺎﻝ ‪ ( ۲‬ﺍﻃﻼﻋﺎﺕ ﺭﻭﺑﺮﻭ ﻣﺮﺑﻮﻁ ﺑﻪ ﻣﺸﺘﺮﻛﻴﻦ ﺗﻠﻔﻦ ﻣﻲ ﺑﺎﺷﺪ ‪ :‬ﺷﻤﺎﺭﻩ ﺗﻠﻔﻦ ‪ ،‬ﻧﺎﻡ ‪ ،‬ﺁﺩﺭﺱ ﻭ ﻫﺰﻳﻨﻪ ‪.‬ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳـﺴﻴﺪ ﻛـﻪ ﺑـﺎ ﺁﻥ ﺑﺘـﻮﺍﻧﻴﻢ‬
‫ﺍﻃﻼﻋﺎﺕ ﻣﺮﺑﻮﻁ ﺑﻪ ‪ ۵۰‬ﻣﺸﺘﺮﻙ ﺭﺍ ﺫﺧﻴﺮﻩ ﻛﻨﻴﻢ ‪ .‬ﻫﻤﭽﻨﻴﻦ ﺑﻮﺳﻴﻠﻪ ﻱ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺍﻱ ﻣﺸﺘﺮﻛﻴﻦ ﭘﺮ ﻣﺼﺮﻑ ﺭﺍ ﭼﺎﭖ ﻧﻤﺎﻳﻴﺪ‪ ).‬ﻣﺸﺘﺮﻛﻴﻨﻲ ﺭﺍ ﭘﺮ‬
‫ﻣﺼﺮﻑ ﻓﺮﺽ ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ ﻫﺰﻳﻨﻪ ﺷﺎﻥ ﺍﺯ ﻣﻴﺎﻧﮕﻴﻦ ﻫﺰﻳﻨﻪ ﺗﻤﺎﻡ ‪ ۵۰‬ﻣﺸﺘﺮﻙ ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ(‪.‬‬

‫‪TYPE‬‬
‫‪begin‬‬
‫‪REC=record‬‬
‫‪for i:=1 to 50 do‬‬
‫;‪number:integer‬‬
‫‪with M[i] do‬‬
‫;]‪name:string[10‬‬
‫‪begin‬‬
‫;]‪address:string[20‬‬
‫;)‪readln(number‬‬
‫;‪cost:longint‬‬
‫;)‪readln(name‬‬
‫;‪end‬‬
‫;)‪readln(address‬‬
‫‪var‬‬
‫;)‪readln(cost‬‬
‫;‪M:array[1..50] of REC‬‬
‫;‪end‬‬
‫;‪i:integer‬‬
‫;‪Hazine‬‬
‫;‪procedure Hazine‬‬
‫‪end.‬‬
‫‪var‬‬
‫;‪s:longint‬‬
‫‪begin‬‬
‫;‪s:=0‬‬
‫‪for i:=1 to 50 do‬‬ ‫ﻣﺤﺎﺳﺒﻪ ﻣﻴﺎﻧﮕﻴﻦ‬
‫ﻫﺰﻳﻨﻪ ﻣﺸﺘﺮﻛﻴﻦ ; ‪s := s + M[i].cost‬‬
‫;‪s:=s div 50‬‬
‫‪for i:=1 to 50 do‬‬ ‫ﭼﺎﭖ ﻣﺸﺘﺮﻛﻴﻦ ﭘﺮ ﻣﺼﺮﻑ‬
‫‪if M[i].cost > s then‬‬
‫;)‪writeln(M[i].number,M[i].name,M[i].cost‬‬
‫;‪end‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪94‬‬
‫رﮐـﻮردي از آراﯾـﻪ ‪:‬‬
‫ﺑﺮﺍﻱ ﺫﺧﻴﺮﻩ ﻛﺮﺩﻥ ﺍﻃﻼﻋﺎﺕ ﻳﻚ ﺩﺍﻧﺶ ﺁﻣﻮﺯ ﺷﺎﻣﻞ ﻧﺎﻡ ﻭ ﻓﺎﻣﻴﻠﻲ ﻭ ﻧﻤﺮﺍﺕ ‪ ۱۰‬ﺩﺭﺱ ﺁﻥ ﺍﺯ ﺳﺎﺧﺘﺎﺭ ﺯﻳﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ ‪:‬‬
‫‪Name‬‬ ‫‪Family‬‬ ‫‪Grades‬‬

‫‪1‬‬ ‫‪2‬‬ ‫…‬ ‫‪10‬‬

‫‪Student‬‬

‫ﻧﺤـﻮه ي ﺗﻌـﺮﯾﻒ ‪:‬‬

‫‪Type‬‬
‫‪Rec = record‬‬
‫;]‪Name : string[10‬‬
‫;]‪Family: string[15‬‬
‫; ‪Grades : Array [1..10] of real‬‬
‫;‪End‬‬
‫‪Var‬‬
‫;‪Student : Rec‬‬

‫ﻧﺤـﻮه دﺳﺘـﺮﺳﯽ ‪:‬‬

‫; ﻣﻘـﺪار =‪ ] :‬اﻧﺪﯾﺲ [ ﻧﺎم آراﯾﻪ ‪ .‬ﻧﺎم رﮐﻮرد‬
‫; ‪Student . Grades[2] := 5.5‬‬

‫ﺛﺎﺑﺖ ﻧـﻮﻉ ﺩﺍﺭ ﺭﻛـﻮﺭﺩﻱ ‪:‬‬

‫ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﻳﻚ ﺛﺎﺑﺖ ﻧﻮﻉ ﺩﺍﺭ ﺍﺯ ﻧﻮﻉ ﺭﻛﻮﺭﺩ ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ ﻭ ﻣﻘﺪﺍﺭ ﺩﻫﻲ ﺍﻭﻟﻴﻪ ﻛﻨﻴﻢ‪.‬ﺍﻳﻦ ﺭﻛﻮﺭﺩ ﺩﺭ ﻃﻮﻝ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﻗﺎﺑﻞ ﺗﻐﻴﻴﺮ ﺍﺳـﺖ ‪.‬‬
‫ﻧﺤﻮﻩ ﻱ ﺗﻌﺮﻳﻒ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ ‪:‬‬
‫‪Type‬‬
‫‪Rec = record‬‬
‫;]‪Name : string[10‬‬
‫; ‪ID : longint‬‬
‫; ‪AVG : real‬‬
‫;‪End‬‬
‫‪const‬‬
‫; ) ‪Student : Rec = ( Name : ’ali’ ; ID : 57438 ; AVG : 13.25‬‬

‫ارﺳﺎل رﮐـﻮرد ﺑﻪ زﯾﺮ ﺑﺮﻧﺎﻣﻪ ‪:‬‬

‫ﻳﻚ ﺭﻛﻮﺭﺩ ﺭﺍ ﻣﻲ ﺗﻮﺍﻥ ﺑﻪ ﺻﻮﺭﺕ ﻳﻚ ﭘﺎﺭﺍﻣﺘﺮ ﺑﻪ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﺍﺭﺳﺎﻝ ﻛﺮﺩ‪ .‬ﺑﺮﺍﻱ ﺍﻳﻦ ﻛﺎﺭ ﺑﺎﻳﺪ ﭘﺎﺭﺍﻣﺘﺮ ﺗﺤﻮﻳـﻞ ﺩﺍﺩﻩ ﺷـﺪﻩ)ﺁﺭﮔﻮﻣـﺎﻥ(ﺑـﺎ‬
‫ﭘﺎﺭﺍﻣﺘﺮﻣﺠﺎﺯﻱ ﻫﻢ ﻧﻮﻉ ﺑﺎﺷﺪ‪.‬ﭘﺎﺭﺍﻣﺘﺮ ﻣﺠﺎﺯﻱ ﻣﻲ ﺗﻮﺍﻧﺪ ﺍﺯ ﻧﻮﻉ ﻣﺮﺟﻊ ﻳﺎ ﻣﻘﺪﺍﺭ ﻳﺎ ﺛﺎﺑﺖ ﺑﺎﺷﺪ‪.‬‬

‫‪ -‬ﺧﺮﻭﺟﻲ ﺗﺎﺑﻊ)ﻣﻘﺪﺍﺭ ﺑﺮﮔﺸﺘﻲ ﺁﻥ( ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺍﺯ ﻧﻮﻉ ﺁﺭﺍﻳﻪ ﻳﺎ ﺭﻛﻮﺭﺩ ﺑﺎﺷﺪ‪.‬ﺩﺭ ﺻﻮﺭﺕ ﻧﻴﺎﺯ ﺑﻪ ﻳﺮﮔﺸﺖ ﻳﻚ ﺭﻛﻮﺭﺩ ﺍﺯ ﻳﻚ ﺗﺎﺑﻊ ﺑﺎﻳﺪ ﺁﻥ ﺭﺍ‬
‫ﺑﻪ ﺻﻮﺭﺕ ﻣﺮﺟﻊ)ﻣﺘﻐﻴﺮ( ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪95‬‬
‫رﮐـﻮرد ﻣﺘﻐﯿـﺮ ‪:‬‬
‫ﻣﻲ ﺧﻮﺍﻫﻴﻢ ﺍﻃﻼﻋﺎﺕ ﺩﺍﻧﺶ ﺁﻣﻮﺯﺍﻥ ﻳﻚ ﻣﺪﺭﺳﻪ ﺭﺍ ﺫﺧﻴﺮﻩ ﻛﻨﻴﻢ‪ .‬ﺩﺭ ﻣﺪﺭﺳﻪ ﺩﻭ ﻧﻮﻉ ﺩﺍﻧﺶ ﺁﻣﻮﺯ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪ :‬ﺩﺍﻧﺶ ﺁﻣﻮﺯ ﺗﺮﻣﻲ ﻭ ﺩﺍﻧﺶ‬
‫ﺁﻣﻮﺯ ﺳﺎﻟﻲ ﻭﺍﺣﺪﻱ‪ .‬ﺑﺮﺍﻱ ﺫﺧﻴﺮﻩ ﺁﻧﻬﺎ ﻣﻲ ﺧﻮﺍﻫﻴﻢ ﻳﻚ ﺭﻛﻮﺭﺩ ﺑﺎ ﻣﺸﺨﺼﺎﺕ زﯾﺮﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ‪.‬‬

‫ﺗﺮﻣﻲ ) ﻧﺎﻡ ‪ -‬ﻓﺎﻣﻴﻠﻲ ‪ -‬ﺷﻤﺎﺭﻩ ﺩﺍﻧﺶ ﺁﻣﻮﺯﻱ ‪ -‬ﺷﻤﺎﺭﻩ ﺗﺮﻡ ‪ -‬ﻣﻌﺪﻝ ﺗﺮﻡ ‪ -‬ﻣﺒﻠﻎ ‪ -‬ﺗﻌﺪﺍﺩ ﻭﺍﺣﺪ(‬
‫ﺳﺎﻟﻲ ﻭﺍﺣﺪﻱ )ﻧﺎﻡ ‪ -‬ﻓﺎﻣﻴﻠﻲ ‪ -‬ﺷﻤﺎﺭﻩ ﺩﺍﻧﺶ ﺁﻣﻮﺯﻱ ‪ -‬ﻣﻌﺪﻝ ﺳﺎﻝ ‪ -‬ﺳﻦ ‪ -‬ﺑﻴﻤﻪ(‬

‫ﺍﻳﻦ ﺩﻭ ﻧﻮﻉ ﺩﺍﻧﺶ ﺁﻣﻮﺯ ﺩﺍﺭﺍﻱ ﺳﻪ ﻓﻴﻠﺪ ﻣﺸﺘﺮﻙ ﻣﻲ ﺑﺎﺷﻨﺪ)ﻧﺎﻡ ‪ -‬ﻓﺎﻣﻴﻠﻲ ‪ -‬ﺷﻤﺎﺭﻩ ﺩﺍﻧﺶ ﺁﻣﻮﺯﻱ( ‪ .‬ﺍﻣﺎ ﺑﻘﻴﻪ ﺍﻃﻼﻋﺎﺕ ﺁﻧﻬﺎ ﺑﺎ ﻫﻢ ﻣﺘﻔــﺎﻭﺕ‬
‫ﺍﺳﺖ‪.‬‬
‫ﺑﺮﺍﻱ ﺫﺧﻴﺮﻩ ﻛﺮﺩﻥ ﺁﻧﻬﺎ ﻳﻚ ﺭﻛﻮﺭﺩ ﺑﻪ ﺻـﻮﺭﺕ ﺯﻳﺮ ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﻴﻢ ‪:‬‬

‫ﻗﺴﻤﺖ ﻣﺸﺘﺮﮎ‬ ‫ﻗﺴﻤﺖ ﻣﺘﻐﻴﺮ‬

‫ﻣﺸﺮﻭﻁ)ﺣﺎﻟﺖ(‬

‫‪Sh-T‬‬ ‫‪AVG-T‬‬ ‫‪Price‬‬ ‫‪T-V‬‬

‫‪Name‬‬ ‫‪Family‬‬ ‫‪Sh-D‬‬
‫ﻓﻴﻠﺪ‬

‫‪AVG-S‬‬ ‫‪Age‬‬ ‫‪Bimeh‬‬

‫ﻗﺴﻤﺖ ﻣﺘﻐﻴﺮ ﺭﻛﻮﺭﺩ ‪ ،‬ﻳﻚ ﻓﻀﺎﻱ ﻣﺸﺘﺮﻙ ﺍﺳﺖ ﺑﻴﻦ ﺩﻭ ﺣﺎﻟﺖ ﺗﺮﻣﻲ ﻭ ﺳﺎﻟﻲ ﻭﺍﺣﺪﻱ ‪ -‬ﻳﻌﻨﻲ ﻣﻲ ﺗﻮﺍﻥ ﺍﻳﻦ ﻗﺴﻤﺖ ﺭﺍ ﻛﻪ ﻳﻚ ﻓﻀﺎ‬
‫ﺍﺳﺖ ﺩﺭ ﻳﻚ ﺣﺎﻟﺖ ﺑﺎ ﭼﻬﺎﺭ ﻓﻴﻠﺪ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺖ) ﺗﺮﻣﻲ( ﻭ ﺩﺭ ﺣﺎﻟﺖ ﺩﻳﮕﺮ ﻫﻤﻴﻦ ﻓﻀﺎ ﺭﺍ ﺳﻪ ﻓﻴﻠﺪ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺖ)ﺳﺎﻟﻲ ﻭﺍﺣﺪﻱ(‪.‬ﻗﺴﻤﺖ‬
‫ﻣﺘﻐﻴﺮ ﺁﻥ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ ‪:‬‬

‫‪Sh-T‬‬ ‫‪AVG-T‬‬ ‫‪Price‬‬ ‫‪T-V‬‬

‫‪Avg-s‬‬ ‫‪age‬‬ ‫‪bimeh‬‬

‫ﺭﻛﻮﺭﺩ ﻣﺘﻐﻴﺮ ﺩﺍﺭﺍﻱ ﻳﻚ ﻓﻴﻠﺪ ﺑﻪ ﻧﺎﻡ ﻓﻴﻠﺪ ﻣﺸﺮﻭﻁ)ﺣﺎﻟﺖ( ﺍﺳﺖ ﻛﻪ ﻧﺸﺎﻥ ﺩﻫﻨﺪﻩ ﻱ ﺗﻔﺴﻴﺮ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺍﺯ ﻗﺴﻤﺖ ﻣﺘﻐﻴﺮ ﺍﺳﺖ ‪.‬‬
‫ﻓﻴﻠﺪ ﻣﺸﺮﻭﻁ )ﺣﺎﻟﺖ( ﺑﺎﻳﺪ ﺍﺯ ﻧﻮﻉ ﺍﺳﻜﺎﻟﺮ ﺑﺎﺷﺪ ‪.‬‬
‫ﭼﮕﻮﻧﮕﯽ ﺗﻌﺮﯾﻒ رﮐـﻮرد ﻣﺘﻐﯿـﺮ ‪:‬‬
‫‪Type‬‬
‫‪Rec = record‬‬
‫;]‪Name : string [10‬‬
‫;]‪Family : string [15‬‬
‫;‪Shstd : longint‬‬
‫‪Case ts : byte of‬‬
‫;);‪1: ( sh-t:byte; avg-s:real; price:longint; T-V:byte‬‬
‫;);‪2: ( avg-t:real; age:byte; bimeh:boolean‬‬
‫;‪End‬‬
‫‪Var‬‬
‫;‪Student : rec‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪96‬‬
‫ﻣﻘﺪﺍﺭ ﻓﻀـﺎﻱ ﺍﺷﻐﺎﻟﻲ ﺭﻛـﻮﺭﺩ ﻫﺎﻱ ﻣﺘﻐﻴﺮ ‪:‬‬
‫ﺑﺮﺍﻱ ﻣﺤﺎﺳﺒﻪ ﻣﻘﺪﺍﺭ ﻓﻀﺎﻱ ﺍﺷﻐﺎﻟﻲ ﻳﻚ ﺭﻛﻮﺭﺩ ﻣﺘﻐﻴﺮ ﺑﻪ ﺭﻭﺵ ﺯﻳﺮ ﻋﻤﻞ ﻣﻲ ﻛﻨﻴﻢ ‪:‬‬

‫ﻣﺎﮐﺰﯾﻤﻢ ﺣﺎﻟﺖ ﻣﺘﻐﯿﺮ ‪) +‬ﻓﯿﻠﺪ ﺗﻌﯿﯿﻦ ﮔﻮﻧﻪ( اﻧﺪازه ي ﻓﯿﻠﺪ ﻣﺸﺮوط ‪ +‬اﻧﺪازه ي ﻗﺴﻤﺖ ﺛﺎﺑﺖ = ﻓﻀﺎي اﺷﻐﺎﻟﯽ‬

‫ﻧﺤﻮﻩ ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﻓﻴﻠﺪ ﻫﺎﻱ ﺭﻛﻮﺭﺩ ﻣﺘﻐﻴﺮ ‪:‬‬

‫ﻧﺤﻮﻩ ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﻓﻴﻠﺪ ﻫﺎﻱ ﺭﻛﻮﺭﺩ ﻣﺘﻐﻴﺮ ﺗﻔﺎﻭﺗﻲ ﺑﺎ ﺭﻛﻮﺭﺩ ﻫﺎﻱ ﻗﺒﻠﻲ ﻧﺪﺍﺭﺩ ؛ ﻓﻘﻂ ﺑﺎ ﻳﻚ ﺩﺳﺘﻮﺭ‪ if‬ﻳﺎ ‪ case‬ﻗﺴﻤﺖ ﻣﺘﻐﻴﺮ ﺭﺍ ﺣﺎﻟﺖ‬
‫ﺑﻨﺪﻱ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬

‫ﻣﺜﺎﻝ ‪ ( ۳‬ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻛﻮﺭﺩ ﻣﺘﻐﻴﺮ ‪ ،‬ﺩﻭ ﻧﻮﻉ ﻛﺎﺭﮔﺮ ﺭﺳﻤﻲ ﻭ ﻗﺮﺍﺭﺩﺍﺩﻱ ﺭﺍ ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﻴﻢ ﻭ ﺑﺮﻧﺎﻣﻪ ﻱ ﺩﺭﻳﺎﻓﺖ ﺍﻃﻼﻋﺎﺕ ﺍﻳﻦ ﺩﻭ ﻧﻮﻉ ﻛﺎﺭﮔﺮ‬
‫ﺭﺍ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ‪:‬‬
‫ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ‪ ۳‬ﻓﻴﻠﺪ ﻣﺸﺘﺮﻙ )ﻧﺎﻡ ‪ ،‬ﻓﺎﻣﻴﻠﻲ ﻭ ﺷﻤﺎﺭﻩ ﺷﻨﺎﺳﺎﻳﻲ( ﺩﺍﺭﻳﻢ ﻛﻪ ﺑﺮﺍﻱ ﻫﺮ ﺩﻭ ﻧﻮﻉ ﻛﺎﺭﮔﺮ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫ﺍﻣﺎ ﺑﺮﺍﻱ ﻛﺎﺭﮔﺮ ﺭﺳﻤﻲ ﻋﻼﻭﻩ ﺑﺮ ‪ ۳‬ﻓﻴﻠﺪ ﻣﺸﺘﺮﻙ ﻓﻴﻠﺪﻫﺎﻱ ﺑﻴﻤﻪ ‪ ،‬ﺣﻘﻮﻕ ﺛﺎﺑﺖ ﻭ ﭘﺎﺩﺍﺵ ﺩﺭ ﻧﻈﺮ ﻣـﻲ ﮔﻴـﺮﻳﻢ ﻭ ﺑـﺮﺍﻱ ﻛـﺎﺭﮔﺮ ﻗـﺮﺍﺭﺩﺍﺩﻱ ﻫـﻢ‬
‫ﻋﻼﻭﻩ ﺑﺮ ‪ ۳‬ﻓﻴﻠﺪ ﻣﺸﺘﺮﻙ ‪ ،‬ﻓﻴﻠﺪﻫﺎﻱ ﻣﺪﺕ ﻗﺮﺍﺭﺩﺍﺩ ﻭ ﺣﻘﻮﻕ ﺭﺍ ﺩﺭ ﻧﻈﺮ ﻣﻲ ﮔﻴﺮﻳﻢ‪.‬‬
‫‪type‬‬
‫‪Worker = record‬‬
‫; ]‪name:string[10‬‬
‫ﻓﻴﻠﺪ ﻫﺎﻱ ﻣﺸﺘﺮﻙ ; ]‪family:string[20‬‬
‫; ‪id:integer‬‬

‫‪case t :boolean of‬‬

‫;) ‪true : ( modat : integer; salary : longint‬‬ ‫ﻓﻴﻠﺪ ﻣﺸﺮﻭﻁ )ﺣﺎﻟﺖ(‬
‫;) ‪false : (bime : integer; sabet : longint; padash : integer‬‬
‫;‪end‬‬
‫‪var‬‬
‫;‪W :worker‬‬ ‫;‪c:char‬‬
‫‪begin‬‬
‫;)‪readln(w.name‬‬
‫;)‪readln(w.family‬‬
‫;)‪readln(w.id‬‬

‫;)‪readln(c‬‬
‫ﺩﺭﻳﺎﻓﺖ ﻳﻚ ﻛﺎﺭﺍﻛﺘﺮ ﺍﺯ ﻭﺭﻭﺩﻱ ‪:‬‬
‫‪if c = 'r' then‬‬
‫‪w.t := false‬‬ ‫ﺍﮔﺮ ﻛﺎﺭﺍﻛﺘﺮ ‪) r‬ﻛﺎﺭﮔﺮ ﺭﺳﻤﻲ( ﺑﺎﺷﺪ ﻓﻴﻠﺪ ﺣﺎﻟـﺖ ﺭﺍ ‪ false‬ﻣـﻲ ﻛﻨـﻴﻢ‪.‬‬
‫‪else‬‬ ‫ﺩﺭ ﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ ﻓﻴﻠﺪ ﺣﺎﻟﺖ ﺭﺍ ‪ True‬ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬
‫;‪w.t := true‬‬
‫ﺣﺎﻝ ﺍﮔﺮ ‪ w.t‬ﻛﻪ ﻫﻤﺎﻥ ﻓﻴﻠﺪ ﻣﺸﺮﻭﻁ )ﺣﺎﻟﺖ( ﺍﺳـﺖ ‪ False‬ﺑـﻮﺩ ‪،‬‬
‫‪if w.t = false then‬‬
‫ﺍﻃﻼﻋﺎﺕ ﻣﺮﺑﻮﻁ ﺑﻪ ﻛﺎﺭﮔﺮ ﺭﺳﻤﻲ)ﺑﻴﻤﻪ ‪ ،‬ﺣﻘﻮﻕ ﺛﺎﺑﺖ ﻭ ﭘﺎﺩﺍﺵ( ﺭﺍ ﺍﺯ ) ‪readln( w.bime , w.sabet , w.padash‬‬
‫‪else‬‬ ‫ﻭﺭﻭﺩﻱ ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﻛﻨﻴﻢ ﺩﺭ ﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ )ﺍﮔـﺮ ; ‪( w.t = true‬‬
‫;) ‪readln( w.modat , w.salary‬‬ ‫ﺍﻃﻼﻋﺎﺕ ﻣﺮﺑﻮﻁ ﺑﻪ ﻛـﺎﺭﮔﺮ ﻗـﺮﺍﺭﺩﺍﺩﻱ )ﻣـﺪﺕ ﻗـﺮﺍﺭﺩﺍﺩ ﻭ ﺣﻘـﻮﻕ( ﺭﺍ‬
‫‪end.‬‬
‫ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪97‬‬
‫روﺷﻬـﺎي ﺟﺴﺘﺠﻮ و ﻣﺮﺗﺐ ﺳﺎزي‬
‫ﺗﻌﺮﯾﻒ ﻟﯿﺴﺖ ‪:‬‬
‫ﻟﻴﺴﺖ ﺍﺯ ﺗﻌﺪﺍﺩﻱ ﺩﺍﺩﻩ ﺗﺸﻜﻴﻞ ﺷﺪﻩ ﺍﺳﺖ ﻛﻪ ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﺩﺭ ﺧﺎﺻﻴﺘﻲ ﻣﺸﺘﺮﻙ ﻫﺴﺘﻨﺪﻭ ﺗﻌﺮﻳﻒ ﻟﻴـﺴﺖ ﺑـﺴﻴﺎﺭ ﺷـﺒﻴﻪ ﺗﻌﺮﻳـﻒ ﻣﺠﻤﻮﻋـﻪ ﺩﺭ‬
‫ﺭﻳﺎﺿﻲ ﺍﺳﺖ ﺑﺎ ﺍﻳﻦ ﺗﻔﺎﻭﺕ ﻛﻪ ‪:‬‬
‫• ﺩﺭ ﻣﺠﻤﻮﻋﻪ)‪ (Set‬ﻋﻀﻮ ﺗﻜﺮﺍﺭﻱ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ ﺍﻣﺎ ﺩﺭ ﻟﻴﺴﺖ ﻣﻤﻜﻦ ﺍﺳﺖ ﺩﺍﺩﻩ ﺗﻜﺮﺍﺭﻱ ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫• ﺩﺭ ﻣﺠﻤﻮﻋﻪ ﺗﺮﺗﻴﺐ ﺍﻋﻀﺎ ﺍﻫﻤﻴﺖ ﻧﺪﺍﺭﺩ ﺍﻣﺎ ﺩﺭ ﻟﻴﺴﺖ ﺗﺮﺗﻴﺐ ﺩﺍﺩﻩ ﻫﺎ ﺍﻫﻤﻴﺖ ﺩﺍﺭﺩ‪.‬‬
‫ﺳﺌﻮﺍﻝ( ﺁﻳﺎ ﻧﻤﺮﺍﺕ ﺩﺭﺱ ﭘﺎﺳﻜﺎﻝ ﻣﻲ ﺗﻮﺍﻧﺪ ﻣﺠﻤﻮﻋﻪ ﺑﺎﺷﺪ؟ ﺟﻮﺍﺏ ‪ :‬ﺍﮔﺮ ﻧﻤﺮﻩ ﺗﻜﺮﺍﺭﻱ ﺩﺭ ﺁﻧﻬﺎ ﻧﺒﺎﺷﺪ ﻣﻲ ﺗﻮﺍﻧﺪ ﻣﺠﻤﻮﻋﻪ ﺑﺎﺷﺪ‬
‫ﺳﺌﻮﺍﻝ( ﺁﻳﺎ ﻟﻴﺴﺖ ﺭﻭﺑﺮﻭ ﻣﻲ ﺗﻮﺍﻧﺪ ﻣﺠﻤﻮﻋﻪ ﺑﺎﺷﺪ؟ }‪ {2 , 7 , 8 , 3 , 2 , 4‬ﺟﻮﺍﺏ ‪ :‬ﺧﻴﺮ ﺯﻳﺮﺍ ﻋﻀﻮﺗﻜﺮﺍﺭﻱ ﺩﺍﺭﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﻳﻚ ﻣﺠﻤﻮﻋﻪ ﻣﻲ ﺗﻮﺍﻧﺪ ﺣﺘﻤﺎ ﻟﻴﺴﺖ ﺑﺎﺷﺪ ﺍﻣﺎ ﻳﻚ ﻟﻴﺴﺖ ﻫﻤﻴﺸﻪ ﻳﻚ ﻣﺠﻤﻮﻋﻪ ﻧﻤﻲ ﺗﻮﺍﻧﺪ ﺑﺎﺷﺪ‪.‬‬
‫}‪{ ali , 14 , 15.5 , 18‬‬ ‫ﻧﻜﺘﻪ( ﺩﺍﺩﻩ ﻫﺎﻱ ﻣﻮﺟﻮﺩ ﺩﺭ ﻳﻚ ﻟﻴﺴﺖ ﻣﻲ ﺗﻮﺍﻧﺪ ﺍﺯ ﭼﻨﺪ ﻧﻮﻉ ﺩﺍﺩﻩ ﻣﺘﻔﺎﻭﺕ ﺑﺎﺷﺪ ﻣﺜﻼ ‪:‬‬
‫ﺩﻗﺖ ﺷﻮﺩ ﻛﻪ ﺩﺍﺩﻩ ﻫﺎﻱ ﻳﻚ ﻟﻴﺴﺖ ﺩﺭ ﺧﺎﺻﻴﺘﻲ ﺑﺎﻳﺪ ﻣﺸﺘﺮﻙ ﺑﺎﺷﻨﺪ‪.‬‬
‫ﻧﻜﺘﻪ( ﺭﻛﻮﺭﺩ ﻭ ﺁﺭﺍﻳﻪ ﻣﻲ ﺗﻮﺍﻧﻨﺪ ﻳﻚ ﻟﻴﺴﺖ ﺑﺎﺷﻨﺪ‪.‬‬
‫‪5‬‬ ‫‪8.5‬‬ ‫'‪'A‬‬ ‫‪ALI‬‬ ‫‪5‬‬ ‫‪25‬‬ ‫‪19‬‬ ‫‪14‬‬ ‫‪6‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪8‬‬

‫ﺟﺴﺘﺠﻮدر ﻟﯿﺴﺖ ‪:‬‬

‫ﺩﺭ ﻣﻮﺍﺭﺩﻱ ﻣﻲ ﺧﻮﺍﻫﻴﻢ ﻳﻚ ﺩﺍﺩﻩ ﺧﺎﺻﻲ ﺭﺍ ﺩﺭ ﻳﻚ ﻟﻴﺴﺖ ﭘﻴﺪﺍ ﻛﻨﻴﻢ ؛ ﺑﻪ ﺍﻳﻦ ﺩﺍﺩﻩ ﻛﻠﻴـﺪ ﻣﻲ ﮔﻮﻳﻨﺪ‪ .‬ﺭﻭﺵ ﻫﺎﻱ ﻣﺨﺘﻠﻔﻲ ﺑﺮﺍﻱ ﺟﺴﺘﺠﻮ ﺩﺭ‬
‫ﻟﻴﺴﺖ ﻫﺎ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﺩﺭ ﺍﻳﻨﺠﺎ ﺑﻪ ﺩﻭ ﻣﻮﺭﺩ ﺁﻥ ﺍﺷﺎﺭﻩ ﻣﻲ ﻛﻨﻴﻢ ‪:‬‬
‫‪ - 1‬روش ﺟﺴﺘﺠﻮي ﺧﻄـﯽ )ﺗﺮﺗﯿﺒﯽ(‬
‫ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﻛﻠﻴﺪ) ﺩﺍﺩﻩ ﺍﻳﻲ ﻛﻪ ﻗﺮﺍﺭ ﺍﺳﺖ ﺟﺴﺘﺠﻮ ﺷﻮﺩ( ﺑﺎ ﺍﻭﻟﻴﻦ ﺩﺍﺩﺓ ﻟﻴﺴﺖ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮﺩ ﺍﮔﺮ ﭘﻴﺪﺍ ﺷﺪ ﻛﺎﺭ ﺑﻪ ﭘﺎﻳﺎﻥ ﻣﻲ ﺭﺳﺪ ﺩﺭ ﻏﻴﺮ‬
‫ﺍﻳﻦ ﺻﻮﺭﺕ ﺑﺎ ﺩﻭﻣﻴﻦ ﺩﺍﺩﺓ ﻟﻴﺴﺖ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮﺩ ﻭ ﺍﻳﻦ ﻛﺎﺭ ﺗﺎ ﭘﺎﻳﺎﻥ ﻟﻴﺴﺖ ﺍﺩﺍﻣﻪ ﻣﻲ ﻳﺎﺑﺪ‪.‬‬
‫ﻣﺜﺎﻝ( ﺍﮔﺮ ﻛﻠﻴﺪ ‪ 12‬ﺑﺎﺷﺪ ﺩﺭ ﻟﻴﺴﺖ ﺯﻳﺮ ﭼﻨﺪ ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﺗﺎ ﻛﻠﻴﺪ ﭘﻴﺪﺍ ﺷﻮﺩ؟ ) ﺑﻪ ﺭﻭﺵ ﺧﻄﻲ(‬

‫‪10‬‬ ‫‪13‬‬ ‫‪14‬‬ ‫‪11‬‬ ‫‪7‬‬ ‫‪12‬‬ ‫‪19‬‬ ‫‪17‬‬ ‫‪12‬‬ ‫‪2‬‬

‫ﻧﻜﺘﻪ( ﺍﮔﺮ ﺩﺭ ﻟﻴﺴﺖ ﭼﻨﺪ ﻣﻮﺭﺩ ﺍﺯ ﻛﻠﻴﺪ ﺑﺎﺷﺪ ﻭ ﺑﻪ ﺭﻭﺵ ﺧﻄﻲ ﺟﺴﺘﺠﻮ ﻛﻨﻴﻢ ﺍﻭﻟﻴﻦ ﻛﻠﻴﺪ ﺭﺍ ﭘﻴﺪﺍ ﻣﻲ ﻛﻨﺪ ﻭ ﺍﻧﺪﻳﺲ )ﻓﻴﻠﺪ( ﻟﻴﺴﺖ ﺭﺍ ﺑﺮﻣﻲ‬
‫ﮔﺮﺩﺍﻧﺪ ﻭ ﻛﺎﺭ ﺟﺴﺘﺠﻮ ﺗﻤﺎﻡ ﻣﻲ ﺷﻮﺩ‪ .‬ﺩﺭ ﻣﺜﺎﻝ ﺑﺎﻻ ﺩﻭ ﻋﺪﺩ ‪ 12‬ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﺍﻣﺎ ﺍﻭﻟﻴﻦ ‪ 12‬ﻛﻪ ﺩﺭ ﺧﺎﻧﻪ ﺷﺸﻢ ﺍﺳﺖ ﭘﻴﺪﺍ ﻣﻲ ﺷﻮﺩ ﻭ ﻛﺎﺭ ﺗﻤﺎﻡ‬
‫ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺩﺭ ﺭﻭﺵ ﺟﺴﺘﺠﻮﻱ ﺧﻄﻲ ﻻﺯﻡ ﻧﻴﺴﺖ ﻛﻪ ﻟﻴﺴﺖ ﻣﺎ ﻣﺮﺗﺐ ﺷﺪﻩ ﺑﺎﺷﺪ‪).‬ﻳﻌﻨﻲ ﺩﺍﺩﻩ ﻫﺎ ﺩﺭ ﻟﻴﺴﺖ ﺻﻌﻮﺩﻱ ﻳﺎ ﻧﺰﻭﻟﻲ ﺑﺎﺷﻨﺪ(‪.‬‬
‫‪Var‬‬ ‫;‪A: Array[1..100] of integer‬‬ ‫ﻧﻜﺘﻪ( ﺩﺭ ﺑﻬﺘﺮﻳﻦ ﺣﺎﻟﺖِ ﺟﺴﺘﺠﻮﻱ ﺧﻄﻲ ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﻳﻜﺒﺎﺭ ﺍﻧﺠﺎﻡ ﻣﻴﺸﻮﺩ‪.‬ﺩﺭ‬
‫;‪Key , F:integer; B:Boolean‬‬
‫‪Begin‬‬ ‫ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖِ ﺟﺴﺘﺠﻮﻱ ﺧﻄﻲ‪ ،‬ﺑﻪ ﺗﻌﺪﺍﺩ ﺧﺎﻧﻪ ﻫﺎﻱ ﻟﻴﺴﺖ‪ ،‬ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺍﻧﺠﺎﻡ‬
‫‪For F:=1 to 100 do‬‬ ‫ﻣﻴﺸﻮﺩ ؛ ﺑﻨﺎﺑﺮﺍﻳﻦ ﺍﮔﺮ ﻟﻴﺴﺖ ‪ N‬ﺗﺎ ﻋﻨﺼﺮ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ‪ N‬ﻋﻤﻞِ ﻣﻘﺎﻳﺴﻪ‬
‫;)]‪Readln( A[F‬‬
‫ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪ .‬ﺩﺭ ﺣﺎﻟﺖ ﻣﺘﻮﺳﻂ ‪ N / 2‬ﻋﻤﻞِ ﻣﻘﺎﻳﺴﻪ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫;)‪Readln(Key‬‬
‫;‪B:=False‬‬ ‫ﺳﺌﻮﺍﻝ( ﺍﮔﺮ ﻟﻴﺴﺘﻲ ﺩﺍﺭﺍﻱ ‪ ٢٠‬ﻋﻨﺼﺮ ﺑﺎﺷﺪ ﺩﺭ ﺭﻭﺵ ﺟﺴﺘﺠﻮﻱ ﺧﻄﻲ ﺩﺭ‬
‫‪For F:=1 to 100 do‬‬
‫‪IF A[F] = Key then‬‬
‫ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ ﻭ ﺣﺎﻟﺖ ﻣﺘﻮﺳﻂ ﭼﻨﺪ ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ؟‬
‫‪Begin‬‬
‫;‪B:=True‬‬
‫;‪Break‬‬ ‫ﻧﻜﺘﻪ( ﺩﺭ ﺭﻭﺵ ﺟﺴﺘﺠﻮﻱ ﺧﻄﻲ ﻟﻴﺴﺖ ﻣﻲ ﺗﻮﺍﻧﺪ ﻧﺎﻣﺮﺗﺐ ﺑﺎﺷﺪ‪.‬‬
‫;‪End‬‬ ‫ﻭﻟﻲ ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﻪ ﻫﺎﺯﻳﺎﺩ ﺍﺳﺖ ﻭ ﺟﺴﺘﺠﻮ ﺑﻪ ﻛﻨﺪﻱ ﺻﻮﺭﺕ ﻣﻲ ﮔﻴﺮﺩ‪.‬‬
‫‪If B=False then‬‬
‫)' ‪Writeln(' Not Found‬‬
‫‪Else‬‬
‫;)‪Wrietln(' Find ' , F‬‬
‫‪End.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪98‬‬
‫‪ - 2‬روش ﺟﺴﺘﺠﻮي دودوﯾـﯽ ) ﺑﺎﯾﻨﺮي( ‪:‬‬
‫ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺑﺎﻳﺪ ﻟﻴﺴﺖ ﺍﺯ ﻗﺒﻞ ﻣﺮﺗﺐ ﺑﺎﺷﺪ‪ .‬ﭘﺲ ﺍﻳﻦ ﺭﻭﺵ ﻣﺨﺼﻮﺹ ﻟﻴﺴﺖ ﻫﺎﻳﻲ ﺍﺳﺖ ﻛﻪ ﺍﺯ ﻗﺒﻞ ﻣﺮﺗﺐ) ﺻﻌﻮﺩﻱ ﻳﺎ ﻧﺰﻭﻟﻲ( ﺷﺪﻩ ﺍﻧﺪ‪.‬‬
‫ﻓﺮﺽ ﻛﻨﻴﺪ ﻛﻪ ﻳﻚ ﺁﺭﺍﻳﻪ ﻣﺮﺗﺐ ﺻﻌﻮﺩﻱ )ﺍﺯ ﻛﻮﭼﻚ ﺑﻪ ﺑﺰﺭﮒ( ﺩﺍﺭﻳﻢ ﻭ ﻣﻲ ﺧﻮﺍﻫﻴﻢ ﻛﻠﻴﺪﻱ ﺭﺍ ﺩﺭ ﺁﻥ ﺑﻪ ﺭﻭﺵ ﺑﺎﻳﻨﺮﻱ ﺟﺴﺘﺠﻮ ﻛﻨﻴﻢ ‪:‬‬
‫ﺁﺭﺍﻳﻪ ﺭﺍ ﺍﺯ ﻭﺳﻂ ﻧﺼﻒ ﻣﻲ ﻛﻨﻴﻢ ﻭ ﻛﻠﻴﺪ ﺭﺍ ﺑﺎ ﻋﻨﺼﺮ ﻭﺳﻂ ﺁﺭﺍﻳﻪ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ ﺳﻪ ﺣﺎﻟﺖ ﻣﻤﻜﻦ ﺍﺳﺖ ﺭﺥ ﺩﻫﺪ‪:‬‬
‫‪ (1‬ﮐﻠﯿﺪ از ﻋﻨﺼﺮ وﺳﻂ ﺑﺰرﮔﺘﺮ ﺑﺎﺷﺪ) ]‪ : (Key > A[C‬ﺩﺭ ﺍﻳﻦ ﺣﺎﻟﺖ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺍﻳﻨﻜﻪ ﻟﻴﺴﺖ ﻣﺮﺗﺐ )ﺻﻌﻮﺩﻱ( ﺍﺳﺖ ﺣﺘﻤﺎ ﻛﻠﻴﺪ ﺩﺭ‬
‫ﻧﻴﻤﻪ ﺳﻤﺖ ﺭﺍﺳﺖ ﺍﺳﺖ ﻭ ﻣﺎ ﺑﺎﻳﺪ ﻧﻴﻤﻪ ﺳﻤﺖ ﺭﺍﺳﺖ ﺭﺍ ﺟﺴﺘﺠﻮ ﻛﻨﻴﻢ ﻭ ﻧﻴﻤﻪ ﺳﻤﺖ ﭼﭗ ﺭﺍ ﺟﺴﺘﺠﻮ ﻧﺨﻮﺍﻫﻴﻢ ﻛﺮﺩ‪.‬‬

‫ﻧﻴﻤﻪ ﺳﻤﺖ ﭼﭗ‬ ‫ﻭﺳﻂ‬ ‫ﻧﻴﻤﻪ ﺳﻤﺖ ﺭﺍﺳﺖ‬

‫‪ (2‬ﮐﻠﯿﺪ از ﻋﻨﺼﺮ وﺳﻂ ﻟﯿﺴﺖ ﮐﻮﭼﮑﺘﺮ اﺳﺖ ‪ :‬ﺩﺭ ﺍﻳﻦ ﺣﺎﻟﺖ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺍﻳﻨﻜﻪ ﻟﻴﺴﺖ ﺑﻪ ﺻﻮﺭﺕ ﺻﻌﻮﺩﻱ ﻣﺮﺗﺐ ﺍﺳﺖ ﺣﺘﻤـﺎ ﻛﻠﻴـﺪ ﺩﺭ‬
‫ﻧﻴﻤﻪ ﺳﻤﺖ ﭼﭗ ﺍﺳﺖ ﻭ ﺑﺎﻳﺪ ﻧﻴﻤﻪ ﺳﻤﺖ ﭼﭗ ﺭﺍ ﺟﺴﺘﺠﻮ ﻛﺮﺩ ﻭ ﻧﻴﻤﻪ ﺳﻤﺖ ﺭﺍ ﺟﺴﺘﺠﻮ ﻧﺨﻮﺍﻫﻴﻢ ﻛﺮﺩ‪.‬‬
‫‪ (3‬در ﺑﻬﺘﺮﯾﻦ ﺣﺎﻟﺖ ﮐﻠﯿﺪ ﻣﺴﺎوي ﻋﻨﺼﺮ وﺳﻂ ﻟﯿﺴﺖ ﺑﺎﺷﺪ ‪ :‬ﺩﺭ ﺍﻳﻦ ﺣﺎﻟﺖ ﻛﻠﻴﺪ ﭘﻴﺪﺍ ﺷﺪﻩ ﺍﺳﺖ ﻭ ﻋﻤﻞ ﺟﺴﺘﺠﻮ ﻣﺘﻮﻗﻒ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﺍﮔﺮ ﻫﺮ ﻛﺪﺍﻡ ﺍﺯ ﺣﺎﻟﺖ ﻫﺎﻱ ﻳﻚ ﻳﺎ ﺩﻭ ﺭﺥ ﺩﻫﺪ؛ ﻋﻤﻞ ﺟﺴﺘﺠﻮ ﺭﺍ ﺩﺭ ﻧﻴﻤﻪ ﺳﻤﺖ ﺭﺍﺳﺖ ﻳﺎ ﭼﭗ ﺍﺩﺍﻣﻪ ﻣﻲ ﺩﻫﻴﻢ‪ .‬ﺑﻪ ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ ﻧﻴﻤﻪ ﺳﻤﺖ‬
‫ﺭﺍﺳﺖ ﻳﺎ ﻧﻴﻤﻪ ﺳﻤﺖ ﭼﭗ ﺭﺍ ﺩﻭﺑﺎﺭﻩ ﺍﺯ ﻭﺳﻂ ﻧﺼﻒ ﻣﻲ ﻛﻨﻴﻢ ﻭ ﺩﻭﺑﺎﺭﻩ ﻋﻤﻞ ﺑﺎﻻ ﺭﺍ ﺭﻭﻱ ﺁﻥ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﻴﻢ‪.‬‬

‫ﻧﻜﺘﻪ( ﺩﺭ ﺑﻬﺘﺮﻳﻦ ﺣﺎﻟﺖ ﺟﺴﺘﺠﻮﻱ ﺩﻭﺩﻭﻳﻲ ﻳﻚ ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‬

‫;‪Var A:array[1..20] of integer‬‬
‫;‪J, Key , C , E , S : integer‬‬ ‫ﻭ ﺩﺭ ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ ﺟﺴﺘﺠﻮﻱ ﺩﻭﺩﻭﻳﻲ ﻳﻚ ﻟﻴﺴﺘﻲ ﻛﻪ ﺩﺍﺭﺍﻱ ‪ N‬ﻋﻨﺼﺮ ﺑﺎﺷﺪ ؛‬
‫;‪F:Boolean‬‬ ‫ﺗﻌﺪﺍﺩ ﻋﻤﻞِ ﺟﺴﺘﺠﻮ ‪ [ Log 2 (N) ] +1‬ﺍﺳﺖ‪.‬‬
‫‪Begin‬‬
‫ﻣﺜﺎﻝ(‬
‫‪For J:= 1 to 20 do‬‬
‫; ) ] ‪Readln( A[ J‬‬ ‫ﻟﻴﺴﺘﻲ ﺩﺍﺭﺍﻱ ‪ ١٨‬ﻋﻨﺼﺮ ﺍﺳﺖ؛ ﺩﺭ ﺑﺪﺗﺮﻳﻦ ﻭ ﺑﻬﺘﺮﻳﻦ ﺣﺎﻟﺖ ﺟﺴﺘﺠﻮﻱ ﻳﻚ ﻛﻠﻴﺪ‬
‫}ﻳﻚ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺟﻬﺖ ﻣﺮﺗﺐ ﺳﺎﺯﻱ { ;)‪Sort(A‬‬ ‫ﺑﻪ ﺭﻭﺵ ﺩﻭﺩﻭﻳﻲ ﭼﻨﺪ ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ؟ ﺑﻪ ﺭﻭﺵ ﺧﻄﻲ ﭼﻄﻮﺭ ؟‬
‫;‪S:=1 ; E : =20‬‬
‫;)‪Readln(Key‬‬
‫;‪F:=False‬‬ ‫ﻧﻜﺘﻪ(‬
‫‪While (S ≤ E) and ( Not F) Do‬‬ ‫ﺟﺴﺘﺠﻮﻱ ﺍﻃﻼﻋﺎﺕ ﻏﻴﺮ ﻋﺪﺩﻱ) ﺭﺷﺘﻪ ﻳﺎ ﻛﺎﺭﺍﻛﺘﺮ( ﺩﻗﻴﻘﺎ ﻣﺎﻧﻨﺪ ﺍﻃﻼﻋﺎﺕ ﻋﺪﺩﻱ ﺍﺳﺖ‪.‬‬
‫‪Begin‬‬
‫ﻧﻜﺘﻪ(‬
‫;‪C:= ( S+E) Div 2‬‬
‫‪IF A[ C] < Key then‬‬ ‫ﻣﻌﻤﻮﻻ ﺩﺭ ﺣﺎﻟﺘﻬﺎﻳﻲ ﻛﻪ ﺗﻌﺪﺍﺩ ﻋﻨﺎﺻﺮ ﻟﻴﺴﺖ ﺯﻳﺎﺩ ﺑﺎﺷﺪ ﺟﺴﺘﺠﻮﻱ ﺩﻭﺩﻭﻳﻲ‬
‫‪S:=C+1‬‬ ‫ﺑﺴﻴﺎﺭ ﺑﻬﺘﺮﻋﻤﻞ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫‪Else‬‬
‫‪IF A[C] > Key then‬‬
‫‪E:=C-1‬‬ ‫ﺳﺌﻮﺍﻝ( ﺩﺭ ﺟﻪ ﺣﺎﻟﺘﻲ ﺟﺴﺘﺠﻮﻱ ﺧﻄﻲ ﺍﺯ ﺟﺴﺘﺠﻮﻱ ﺩﻭﺩﻭﻳﻲ ﺳﺮﻳﻌﺘﺮ ﺍﺳﺖ؟‬
‫‪Else‬‬
‫‪IF‬‬ ‫‪A[C]=Key then‬‬
‫;‪F:=True‬‬
‫;‪End‬‬ ‫ﺳﺌﻮﺍﻝ( ﺩﺭﺟﺴﺘﺠﻮﻱ ﺑﺎﻳﻨﺮﻱ ﺍﮔﺮ ﻛﻠﻴﺪ ﺩﺭ ﻟﻴﺴﺖ ﻧﺒﺎﺷﺪ‪ ،‬ﭼﮕﻮﻧﻪ ﻣﺘﻮﺟﻪ ﻣﻲ ﺷﻮﻳﻢ‬
‫‪IF F=False then‬‬ ‫ﻛﻪ ﻛﻠﻴﺪ ﺩﺭ ﻟﻴﺴﺖ ﻧﻴﺴﺖ؟‬
‫)'‪Writeln(' Not Found‬‬
‫‪Else‬‬
‫;)‪Writeln(' Find in index' , C‬‬
‫‪End.‬‬

‫ﺳﺌﻮﺍﻝ( ﺍﮔﺮ ﻋﻀﻮ ﺗﻜﺮﺍﺭﻱ ﺩﺭ ﻟﻴﺴﺖ ﺑﺎﺷﺪ ﻭ ﺑﻪ ﺭﻭﺵ ﺑﺎﻳﻨﺮﻱ ﺟﺴﺘﺠﻮ ﻛﻨﻴﻢ ﻛﺪﺍﻡ ﻋﻀﻮ ﭘﻴﺪﺍ ﺧﻮﺍﻫﺪ ﺷﺪ؟‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪99‬‬
‫ﺳﺌﻮﺍﻝ( ﺁﺭﺍﻳﻪ ﺭﻭﺑﺮﻭ ﺭﺍ ﺑﺮﺍﻱ ﻛﻠﻴﺪ ‪ 34‬ﺑﻪ ﺩﻭ ﺭﻭﺵ ﺧﻄﻲ ﻭ ﺑﺎﻳﻨﺮﻱ ﺟﺴﺘﺠﻮ ﻛﻨﻴﺪ ﻭ ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﻪ ﻫﺎ ﺭﺍ ﺩﺭ ﻫﺮ ﺩﻭ ﺭﻭﺵ ﺑﺪﺳﺖ ﺁﻭﺭﻳﺪ‪:‬‬

‫‪8‬‬ ‫‪15‬‬ ‫‪32‬‬ ‫‪17‬‬ ‫‪19‬‬ ‫‪34‬‬ ‫‪21‬‬ ‫‪12‬‬ ‫‪2‬‬ ‫‪38‬‬ ‫‪34‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪20‬‬

‫ﻣﺮﺗﺐ ﺳـﺎزي ﻟﯿﺴﺖ ‪:‬‬

‫ﻣﺮﺗﺐ ﺳﺎﺯﻱ ‪ :‬ﻣﻨﻈﻮﺭ ﺍﺯ ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﺩﺍﺩﻩ ﻫﺎ ﺗﻐﻴﻴﺮ ﺩﺍﺩﻥ ﻣﻮﻗﻌﻴﺖ ﺁﻧﻬﺎ ﺩﺭ ﻳﻚ ﻟﻴﺴﺖ ﺍﺳﺖ ﺗﺎ ﺩﺍﺩﻩ ﻫﺎ ﺩﺭ ﻟﻴﺴﺖ ﺑﻪ ﻃﻮﺭ ﻣﻨﻈﻢ ﺻﻌﻮﺩﻱ‬
‫ﻳﺎ ﻧﺰﻭﻟﻲ ﻗﺮﺍﺭ ﮔﻴﺮﻧﺪ‪.‬‬
‫‪2 , 7 , 8 , 9 , 15 , 18‬‬ ‫ﺻﻌﻮﺩﻱ ‪ ç‬ﺍﺯ ﻛﻤﺘﺮ ﺑﻪ ﺑﻴﺸﺘﺮ‬
‫‪18 , 15 , 9 , 8 , 7 , 2‬‬ ‫ﻧﺰﻭﻟﻲ ‪ ç‬ﺍﺯ ﺑﻴﺸﺘﺮ ﺑﻪ ﻛﻤﺘﺮ‬
‫ﺩﺭﻫﻤﻪ ﻣﺜﺎﻟﻬﺎﻳﻲ ﻛﻪ ﺩﺭ ﺯﻳﺮ ﺁﻣﺪﻩ ﺍﺳﺖ ﻣﻲ ﺧﻮﺍﻫﻴﻢ ﻟﻴﺴﺖ ﺭﺍ ﺻﻌﻮﺩﻱ ﻣﺮﺗﺐ ﻛﻨﻴﻢ‪.‬‬

‫‪ - 1‬روش ﻣﺮﺗﺐ ﺳﺎزي ﺣﺒﺎﺑـﯽ‪(Bubble Sort) :‬‬

‫ﻣﺮﺣﻠﻪ ﻳﺎ ﮔﺬﺭ ‪ (١‬ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺍﻭﻟﻴﻦ ﻋﺪﺩ ﻟﻴﺴﺖ ﺑﺎ ﺩﻭﻣﻴﻦ ﻋﺪﺩ ﻟﻴﺴﺖ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮﺩ ﻭ ﺍﮔﺮ ﺗﺮﺗﻴﺐ ﺁﻧﻬﺎ ﺩﺭﺳﺖ ﻧﺒﻮﺩ‪ )،‬ﻳﻌﻨﻲ ﺍﻳﻨﻜﻪ ﻋﺪﺩ‬
‫ﺍﻭﻟﻲ ﺍﺯ ﺩﻭﻣﻲ ﺑﺰﺭﮔﺘﺮ ﺑﺎﺷﺪ( ﺟﺎﻱ ﺁﻧﻬﺎ ﺭﺍ ﻋﻮﺽ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﺳﭙﺲ ﻋﺪﺩ ﺩﻭﻣﻲ ﺭﺍ ﺑﺎ ﻋﺪﺩ ﺳﻮﻣﻲ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﻛﻨﻴﻢ ﻭ ﺍﮔﺮ ﺗﺮﺗﻴﺐ ﺁﻧﻬﺎ ﺩﺭﺳﺖ ﻧﺒﻮﺩ ﺟﺎﻱ ﺁﻧﻬﺎ ﺭﺍ ﻋﻮﺽ ﻣﻲ ﻛﻨﻴﻢ‪ .‬ﻭ ﺍﻳـﻦ ﻛـﺎﺭ ﺭﺍ ﺗـﺎ ﺍﻧﺘﻬـﺎﻱ‬
‫ﻟﻴﺴﺖ) ﻓﺮﺽ ﺑﺮ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﻟﻴﺴﺖ ‪ N‬ﺗﺎ ﻋﻨﺼﺮ ﺩﺍﺭﺩ( ﺍﺩﺍﻣﻪ ﻣﻲ ﺩﻫﻴﻢ‪ .‬ﻋﺪﺩ ﺑﺰﺭﮔﺘﺮ ﺑﻪ ﺧﺎﻧﻪ ‪ N‬ﺍﻡ ﻣﻲ ﺭﻭﺩ‪ ).‬ﻣﺎﻧﻨﺪﻳﻚ ﺣﺒﺎﺏ(‬
‫ﻣﺮﺣﻠﻪ ‪ (٢‬ﺩﻭﺑﺎﺭﻩ ﺍﺯ ﺧﺎﻧﻪ ﺍﻭﻝ ﺷﺮﻭﻉ ﻣﻲ ﻛﻨﻴﻢ ﻭ ﺧﺎﻧﻪ ﺍﻭﻝ ﺭﺍ ﺑﺎ ﺧﺎﻧﻪ ﺩﻭﻡ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﻛﻨﻴﻢ ﻭ ﺍﮔﺮ ﺗﺮﺗﻴﺐ ﺁﻧﻬـﺎ ﺩﺭﺳـﺖ ﻧﺒـﻮﺩ ﺟـﺎﻱ ﺁﻧﻬـﺎ ﺭﺍ‬
‫ﻋﻮﺽ ﻣﻲ ﻛﻨﻴﻢ ﻭ ﺳﭙﺲ ﻋﺪﺩ ﺩﻭﻡ ﻭﻋﺪﺩ ﺳﻮﻡ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮﻧﺪ ﻭ ‪ .........‬ﻭ ﺍﻳﻦ ﻛﺎﺭ ﺗﺎ ﺧﺎﻧﻪ ‪ N-1‬ﺍﺩﺍﻣﻪ ﭘﻴﺪﺍ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﻣﺮﺣﻠﻪ ‪ ( ٣‬ﻣﺮﺣﻠﻪ ﺳﻮﻡ ﻧﻴﺰ ﻣﺎﻧﻨﺪ ﻣﺮﺣﻠﻪ ﺩﻭﻡ ﺍﺳﺖ ﺑﺎ ﺍﻳﻦ ﺗﻔﺎﻭﺕ ﻛﻪ ﺗﺎ ﺧﺎﻧﻪ ‪ N-2‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ ( ﺍﮔﺮ ﻟﻴﺴﺖ ﺩﺍﺭﻱ ‪ N‬ﺗﺎ ﺳﻠﻮﻝ ﺑﺎﺷﺪ ‪ N-1‬ﻣﺮﺣﻠﻪ ﺧﻮﺍﻫﻴﻢ ﺩﺍﺷﺖ‪.‬‬
‫‪12‬‬ ‫‪18‬‬ ‫‪10‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫ﻣﺜﺎﻝ( ﺁﺭﺍﻳﻪ ﺭﻭﺑﺮﻭ ﺭﺍ ﺑﻪ ﺭﻭﺵ ﺣﺒﺎﺑﻲ‪ ،‬ﺻﻌﻮﺩﻱ ﻣﺮﺗﺐ ﻛﻨﻴﺪ ‪:‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬
‫‪12‬‬ ‫‪18‬‬ ‫‪10‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪12‬‬ ‫‪10‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪18‬‬
‫‪12‬‬ ‫‪18‬‬ ‫‪10‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪12‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪18‬‬
‫‪12‬‬ ‫‪10‬‬ ‫‪18‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪12‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪18‬‬
‫‪12‬‬ ‫‪10‬‬ ‫‪17‬‬ ‫‪18‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪17‬‬ ‫‪9‬‬ ‫‪18‬‬
‫‪12‬‬ ‫‪10‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪18‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪17‬‬ ‫‪18‬‬
‫‪12‬‬ ‫‪10‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪18‬‬ ‫ﻣﺮﺣﻠﻪ ‪ : ٢‬ﭼﻬﺎﺭ ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﻭ ﺳﻪ ﺟﺎﺑﺠﺎﻳﻲ ﺭﺥ ﺩﺍﺩﻩ ﺍﺳﺖ‪.‬‬
‫ﻣﺮﺣﻠﻪ ‪ ٥ : ١‬ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﻭ ﭼﻬﺎﺭ ﺟﺎﺑﺠﺎﻳﻲ ﺭﺥ ﺩﺍﺩﻩ ﺍﺳﺖ‪.‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬
‫‪10‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪17‬‬ ‫‪18‬‬
‫‪10‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪17‬‬ ‫‪18‬‬ ‫‪10‬‬ ‫‪12‬‬ ‫‪9‬‬ ‫‪13‬‬ ‫‪17‬‬ ‫‪18‬‬
‫‪10‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫‪17‬‬ ‫‪18‬‬ ‫‪10‬‬ ‫‪12‬‬ ‫‪9‬‬ ‫‪13‬‬ ‫‪17‬‬ ‫‪18‬‬
‫‪10‬‬ ‫‪12‬‬ ‫‪9‬‬ ‫‪13‬‬ ‫‪17‬‬ ‫‪18‬‬ ‫‪10‬‬ ‫‪9‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪17‬‬ ‫‪18‬‬
‫ﻣﺮﺣﻠﻪ ‪ : ٣‬ﺳﻪ ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﻭ ﻳﻚ ﻋﻤﻞ ﺟﺎﺑﺠﺎﻳﻲ ﺭﺥ ﺩﺍﺩﻩ ﺍﺳﺖ‬ ‫ﻣﺮﺣﻠﻪ ‪ : ٤‬ﺩﻭ ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﻭ ﻳﻚ ﺟﺎﺑﺠﺎﻳﻲ ﺭﺥ ﺩﺍﺩﻩ ﺍﺳﺖ‪.‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬

‫ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ﻣﺠﻤﻮﻋﺎ ‪ ١٥‬ﻣﻘﺎﻳﺴﻪ ﻭ ‪ ١٠‬ﺟﺎﺑﺠﺎﻳﻲ ﺻﻮﺭﺕ ﮔﺮﻓﺘﻪ ﺍﺳﺖ‪.‬‬
‫‪10‬‬ ‫‪9‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪17‬‬ ‫‪18‬‬
‫‪9‬‬ ‫‪10‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪17‬‬ ‫‪18‬‬
‫ﻣﺮﺣﻠﻪ ‪ : ٥‬ﻳﻚ ﻣﻘﺎﻳﺴﻪ ﻭ ﻳﻚ ﺟﺎﺑﺠﺎﻳﻲ ﺭﺥ ﺩﺍﺩﻩ ﺍﺳﺖ‪.‬‬ ‫ﻧﻜﺘﻪ( ﺑﻄﻮﺭ ﻛﻠﻲ ﺩﺭ ﺭﻭﺵ ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﺣﺒﺎﺑﻲ ‪:‬‬
‫ﺍﮔﺮ ﻟﻴﺴﺖ ﺩﺍﺭﺍﻱ ‪ N‬ﺗﺎ ﻋﻨﺼﺮﺑﺎﺷﺪ ﺑﻪ ﺗﻌﺪﺍﺩ ‪ N(N-1) / 2‬ﺗﺎ ﻣﻘﺎﻳﺴﻪ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪100‬‬
‫ﻧﻜﺘﻪ( ﺗﻌﺪﺍﺩ ﺟﺎﺑﺠﺎﻳﻲ ﻫﺎ ﺩﺭ ﺭﻭﺵ ﺣﺒﺎﺑﻲ ﺭﺍ ﺩﻗﻴﻘﺎ ﻧﻤﻲ ﺗﻮﺍﻥ ﻣﺤﺎﺳﺒﻪ ﻛﺮﺩ ﻭ ﺑﺴﺘﮕﻲ ﺑﻪ ﺑﻲ ﻧﻈﻤﻲ ﺁﺭﺍﻳﻪ ﺩﺍﺭﺩ ﻭﻟـﻲ ﻣـﻲ ﺗـﻮﺍﻥ ﮔﻔـﺖ ﻛـﻪ‬
‫ﺣﺪﺍﻛﺜﺮ ﺗﻌﺪﺍﺩِ ﺟﺎﺑﺠﺎﻳﻲ ﻫﺎ ﺑﻪ ﺍﻧﺪﺍﺯﻩ ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﻪ ﻫﺎ ﺍﺳﺖ ﻳﻌﻨﻲ ﻫﺮ ﻣﻘﺎﻳﺴﻪ ﺍﻳﻲ ﻛﻪ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﻳﻚ ﺟﺎﺑﺠﺎﻳﻲ ﻧﻴﺰ ﺭﺥ ﺩﻫﺪ‪.‬‬
‫ﺍﮔﺮ ﺁﺭﺍﻳﻪ ﺍﻳﻲ ﻧﺰﻭﻟﻲ ﺑﺎﺷﺪ ﻭ ﺑﺨﻮﺍﻫﻴﻢ ﺁﻥ ﺭﺍ ﺑﻪ ﺭﻭﺵ ﺣﺒﺎﺑﻲ ﺻﻌﻮﺩﻱ ﻛﻨﻴﻢ ﺗﻌﺪﺍﺩ ﺟﺎﺑﺠﺎﻳﻲ ﻫﺎ ﺑﺮﺍﺑﺮ ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﻪ ﻫﺎ ﺍﺳﺖ‪.‬‬

‫ﺳﺌﻮﺍﻝ( ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﻳﻚ ﻟﻴﺴﺖ ‪ ١٠‬ﻋﻨﺼﺮﻱ ﺭﺍ ﺑﻪ ﺭﻭﺵ ﺣﺒﺎﺑﻲ ﻣﺮﺗﺐ ﻛﻨﻴﻢ ﭼﻨﺪ ﻣﻘﺎﻳﺴﻪ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ؟‬
‫ﺩ( ‪٤٥‬‬ ‫ﺝ( ‪٥٠‬‬ ‫ﺏ( ‪١٥‬‬ ‫ﺍﻟﻒ( ‪٩‬‬

‫ﺳﺌﻮﺍﻝ( ﺁﺭﺍﻳﻪ ﺯﻳﺮ ﺭﺍ ﺑﻪ ﺭﻭﺵ ﺣﺒﺎﺑﻲ ﻣﺮﺗﺐ ﻧﺰﻭﻟﻲ ﻛﻨﻴﺪ‪ ،‬ﺷﻜﻞ ﺁﺭﺍﻳﻪ ﺩﺭ ﮔﺬﺭ ﭼﻬﺎﺭﻡ ﭼﮕﻮﻧﻪ ﺍﺳﺖ؟‬
‫‪12‬‬ ‫‪18‬‬ ‫‪9‬‬ ‫‪13‬‬ ‫‪15‬‬ ‫‪7‬‬ ‫‪10‬‬ ‫‪14‬‬

‫ﻣﺜﺎﻝ ( ﺑﺮﻧﺎﻣﻪ ﺍﻳﻲ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻚ ﺁﺭﺍﻳﻪ ‪ ١٠‬ﻋﻨﺼﺮﻱ ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﺑﻪ ﺭﻭﺵ ﺣﺒﺎﺑﻲ‪ ،‬ﺻﻌﻮﺩﻱ ﻣﺮﺗﺐ ﻛﻨﺪ ﻭ ﭼﺎﭖ ﻛﻨﺪ ‪:‬‬
‫‪Var‬‬
‫;‪A:Array[1..10] of integer‬‬
‫;‪G, B , C:Integer‬‬
‫‪Begin‬‬
‫‪For B:=1 To 10 do‬‬
‫;)]‪Readln(A[B‬‬
‫‪For G:=9 Downto 1 do‬‬
‫‪For B:=1 To G Do‬‬
‫‪If A[ B] > A[B+1] then‬‬
‫} ﺟﺎﺑﺠﺎﻳﻲ { ‪Begin‬‬
‫;]‪C:=A[B‬‬
‫;]‪A[B]:=A[B+1‬‬
‫;‪A[B+1]:=C‬‬
‫;‪End‬‬
‫‪For B:=1 to 10 do‬‬
‫;)]‪Writeln(A[B‬‬
‫‪End.‬‬

‫ﻣﺜﺎﻝ ( ﺩﺭ ﻣﺜﺎﻝ ‪ ٢‬ﻓﺼﻞ ﺭﻛﻮﺭﺩ ﺩﺭ ﺻﻔﺤﻪ ‪ ٩٣‬ﻣﺮﺑﻮﻁ ﺑﻪ ﻣﺸﺘﺮﻛﻴﻦ ﺗﻠﻔﻦ ‪ ،‬ﭘﺮﻭﺳﻴﺠﺮﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻣﺸﺘﺮﻛﻴﻦ ﺭﺍ ﺑﺮ ﺍﺳﺎﺱ ﺷﻤﺎﺭﻩ ﺗﻠﻔﻦ‬
‫ﻣﺮﺗﺐ ﻛﻨﺪ ‪:‬‬
‫;‪procedure sort‬‬
‫‪var‬‬
‫;‪i,j:integer‬‬
‫;‪temp:REC‬‬
‫‪begin‬‬
‫‪for i:=49 downto 1 do‬‬
‫‪for j:=1 to i do‬‬
‫‪if M[j].number>M[j+1].number then‬‬
‫‪begin‬‬
‫;]‪temp:=M[j‬‬
‫;]‪M[j]:=M[j+1‬‬
‫;‪M[j+1]:=temp‬‬
‫;‪end‬‬
‫;‪end‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪101‬‬
‫‪ - 2‬روش ﻣﺮﺗﺐ ﺳﺎزي اﻧﺘﺨـﺎﺑﯽ ‪(Selection ) :‬‬
‫ﻓﺮﺽ ﻛﻨﻴﺪ ﻣﻲ ﺧﻮﺍﻫﻴﻢ ﻳﻚ ﻟﻴﺴﺖ ﺷﺎﻣﻞ ‪ N‬ﺧﺎﻧﻪ ﺭﺍ ﺑﻪ ﺭﻭﺵ ﺍﻧﺘﺨﺎﺑﻲ ﻣﺮﺗﺐ ﻛﻨﻴﻢ) ﺻﻌﻮﺩﻱ(‪:‬‬
‫ﻣﺮﺣﻠﻪ ﺍﻭﻝ( ﺍﺯ ﺍﺑﺘﺪﺍ ﺗﺎ ﺍﻧﺘﻬﺎﻱ ﻟﻴﺴﺖ ﺭﺍ ﺟﺴﺘﺠﻮ ﻛﺮﺩﻩ ﻭ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﺪﺩ ﺭﺍ ﭘﻴﺪﺍ ﻛﺮﺩﻩ ﻭ ﻣﺤﻞ ﺁﻥ ﺭﺍ ﺑﺎ ﺍﻭﻟﻴﻦ ﻋﻨﺼﺮ ﻟﻴﺴﺖ ﻋﻮﺽ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﻣﺮﺣﻠﻪ ﺩﻭﻡ( ﺍﺯ ﺧﺎﻧﻪ ﺩﻭﻡ ﺗﺎ ﺍﻧﺘﻬﺎﻱ ﻟﻴﺴﺖ ﺭﺍ ﺟﺴﺘﺠﻮ ﻛﺮﺩﻩ ﻭ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﺪﺩ ﺭﺍ ﭘﻴﺪﺍ ﻛﺮﺩﻩ ﻭ ﻣﺤﻞ ﺁﻥ ﺭﺍ ﺑﺎ ﺧﺎﻧﻪ ﺩﻭﻡ ﻋﻮﺽ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﺩﻗﺖ ﻛﻨﻴﺪ ﻛﻪ ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﻣﺤﻞ ﻭﺍﻗﻌﻲ ﻳﻚ ﺍﺯ ﺍﻋﺪﺍﺩ ﻣﺸﺨﺺ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻣﺮﺣﻠﻪ ﺳﻮﻡ( ﺍﺯ ﺧﺎﻧﻪ ﺳﻮﻡ ﺗﺎ ﺍﻧﺘﻬﺎﻱ ﻟﻴﺴﺖ ﺭﺍ ﺟﺴﺘﺠﻮﻛﺮﺩﻩ ﻭ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﺪﺩ ﺭﺍ ﭘﻴﺪﺍ ﻛﺮﺩﻩ ﻭ ﻣﺤﻞ ﺁﻥ ﺭﺍ ﺑﺎ ﺳﻮﻣﻴﻦ ﻋﻨـﺼﺮ ﻟﻴـﺴﺖ ﻋـﻮﺽ‬
‫ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﺍﻳﻦ ﻛﺎﺭ ﺭﺍ ﺗﺎ ﺍﻧﺘﻬﺎﻱ ﻟﻴﺴﺖ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﻴﻢ ‪.‬‬
‫ﺍﮔﺮ ﻟﻴﺴﺖ ﺩﺍﺭﺍﻱ ‪ N‬ﺗﺎ ﻋﻨﺼﺮ ﺑﺎﺷﺪ ‪ N-1‬ﮔﺬﺭ ﻳﺎ ﻓﺎﺯ ﺧﻮﺍﻫﻴﻢ ﺩﺍﺷﺖ ﻭ ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﻓﻘﻂ ﻳﻚ ﺟﺎﺑﺠﺎﻳﻲ ﺭﺥ ﻣﻲ ﺩﻫﺪ‪.‬‬

‫‪12‬‬ ‫‪18‬‬ ‫‪10‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪9‬‬ ‫ﺳﺌﻮﺍﻝ( ﺁﺭﺍﻳﻪ ﺭﻭﺑﺮﻭ ﺭﺍ ﺑﻪ ﺭﻭﺵ ﺍﻧﺘﺨﺎﺑﻲ‪ ،‬ﺻﻌﻮﺩﻱ ﻣﺮﺗﺐ ﻛﻨﻴﺪ‪:‬‬

‫‪9‬‬ ‫‪18‬‬ ‫‪10‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪12‬‬ ‫‪9‬‬ ‫‪10 18 17 13 12‬‬

‫ﮔﺬﺭ ‪ ٥ : ١‬ﻣﻘﺎﻳﺴﻪ ﻭ ﻳﻚ ﺟﺎﺑﺠﺎﻳﻲ‬ ‫ﮔﺬﺭ ‪ ٤ : ٢‬ﻣﻘﺎﻳﺴﻪ ﻭ ﻳﻚ ﺟﺎﺑﺠﺎﻳﻲ‬

‫‪9‬‬ ‫‪10‬‬ ‫‪12‬‬ ‫‪17‬‬ ‫‪13‬‬ ‫‪18‬‬ ‫‪9‬‬ ‫‪10 12 13 17 18‬‬

‫ﮔﺬﺭ ‪ ٣ : ٣‬ﻣﻘﺎﻳﺴﻪ ﻭ ﻳﻚ ﺟﺎﺑﺠﺎﻳﻲ‬ ‫ﮔﺬﺭ ‪ ٢ : ٤‬ﻣﻘﺎﻳﺴﻪ ﻭ ﻳﻚ ﺟﺎﺑﺠﺎﻳﻲ‬
‫‪9‬‬ ‫‪10 12 13 17 18‬‬
‫ﮔﺬﺭ ‪ ١ : ٥‬ﻣﻘﺎﻳﺴﻪ ﻭ ﻳﻚ ﺟﺎﺑﺠﺎﻳﻲ‬
‫ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ‪ ١٥‬ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﻭ ﭘﻨﺞ ﺟﺎﺑﺠﺎﻳﻲ ﺭﺥ ﺩﺍﺩﻩ ﺍﺳﺖ‪.‬‬
‫ﻫﻤﺎﻧﻄﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣﻲ ﻛﻨﻴﺪ ﻫﻤﻴﻦ ﺁﺭﺍﻳﻪ ﺑﻪ ﺭﻭﺵ ﺣﺒﺎﺑﻲ ‪ ١٠‬ﺟﺎﺑﺠﺎﻳﻲ ﺩﺍﺷﺖ ﻭﻟﻲ ﺑﻪ ﺭﻭﺵ ﺍﻧﺘﺨﺎﺑﻲ ﭘﻨﺞ ﺟﺎﺑﺠﺎﻳﻲ ﺩﺍﺭﺩ‪.‬‬
‫ﻧﻜﺘﻪ( ﺩﺭ ﺭﻭﺵ ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﺍﻧﺘﺨﺎﺑﻲ ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﻪ ﻫﺎ ﺑﺮﺍﺑﺮﺍﺳﺖ ﺑﺎ ‪N ( N-1) / 2‬‬
‫‪(N-1) + (N-2) + (N-3) +….+ 2 + 1 = N×(N-1) / 2‬‬
‫ﺩﺭ ﺭﻭﺵ ﺍﻧﺘﺨﺎﺑﻲ ﺗﻌﺪﺍﺩ ﺟﺎﺑﺠﺎﻳﻲ ﻫﺎ ﻫﻤﻴﺸﻪ ﺑﺮﺍﺑﺮ ‪ N-1‬ﺗﺎ ﺍﺳﺖ‪.‬‬
‫ﻧﻜﺘﻪ( ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﻪ ﻫﺎ ﺩﺭ ﺭﻭﺵ ﺍﻧﺘﺨﺎﺑﻲ ﻭ ﺣﺒﺎﺑﻲ ﻳﻜﺴﺎﻥ ﺍﺳﺖ‪.‬‬
‫ﻧﻜﺘﻪ( ﺗﻌﺪﺍﺩ ﺟﺎﺑﺠﺎﻳﻲ ﻫﺎ ﺩﺭ ﺭﻭﺵ ﺍﻧﺘﺨﺎﺑﻲ ﻛﻤﺘﺮ ﺍﺯ ﺭﻭﺵ ﺣﺒﺎﺑﻲ ﺍﺳﺖ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﺭﻭﺵ ﺍﻧﺘﺨﺎﺑﻲ ﺳﺮﻳﻌﺘﺮ ﺍﺯ ﺣﺒﺎﺑﻲ ﺍﺳﺖ‪.‬‬

‫ﺳﺌﻮﺍﻝ( ﺁﺭﺍﻳﻪ ﺭﻭﺑﺮﻭ ﺭﺍ ﺑﻪ ﺭﻭﺵ ﺍﻧﺘﺨﺎﺑﻲ ﻣﺮﺗﺐ ﻛﻨﻴﺪ ﻧﺰﻭﻟﻲ ﻛﻨﻴﺪ ﻭ ﮔﺬﺭ ﭼﻬﺎﺭﻡ ﺁﻥ ﺭﺍ ﺑﺪﺳﺖ ﺁﻭﺭﻳﺪ؟‬

‫‪12‬‬ ‫‪18‬‬ ‫‪9‬‬ ‫‪13‬‬ ‫‪15‬‬ ‫‪7‬‬ ‫‪10‬‬ ‫‪14‬‬

‫ﻧﻜﺘﻪ( ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﻟﻴﺴﺖ ﻫﺎﻱ ﻏﻴﺮ ﻋﺪﺩﻱ ﻧﻈﻴﺮ ﺭﺷﺘﻪ ﻫﺎ ﺩﻗﻴﻘﺎ ﻣﺎﻧﻨﺪ ﻟﻴﺴﺖ ﻫﺎﻱ ﻋﺪﺩﻱ ﺍﺳﺖ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪102‬‬
‫ﻣﺜﺎﻝ ( ﺑﺮﻧﺎﻣﻪ ﺍﻳﻲ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻚ ﺁﺭﺍﻳﻪ ‪ ١٠‬ﻋﻨﺼﺮﻱ ﺍﺯ ﺍﻋﺪﺍﺩ ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪﻭ ﺑﻪ ﺭﻭﺵ ﺍﻧﺘﺨﺎﺑﻲ ﻣﺮﺗﺐ ﺻﻌﻮﺩﻱ ﻛﻨﺪ ﻭ ﭼﺎﭖ ﻛﻨﺪ‪.‬‬
‫;‪Var A:Array [1 .. 10 ] of integer‬‬
‫;‪K , L , T,Min , C: integer‬‬
‫‪Begin‬‬
‫‪For K:=1 to 10 do‬‬
‫;)]‪Readln( A[K‬‬
‫‪For K:=1 to 9 do‬‬
‫‪Begin‬‬
‫;]‪Min:=A[K‬‬
‫} ﻣﻮﻗﻌﻴﺖ ﻋﺪﺩ ﻛﻮﭼﻚ{ ;‪C:=K‬‬
‫‪For L:=K+1 To 10 Do‬‬
‫‪IF A[L] < Min then‬‬
‫‪Begin‬‬
‫;]‪Min:=A[L‬‬
‫;‪C:=L‬‬
‫;‪End‬‬
‫;]‪T:=A[K‬‬
‫;‪A[K]:=Min‬‬ ‫ﺟﺎﺑﺠـﺎﻳﻲ‬
‫;‪A[C]:=T‬‬
‫;‪End‬‬
‫‪For L:=1 To 10 do‬‬
‫;)‪Writeln(A[L‬‬
‫‪End.‬‬

‫ﺗﺴﺖ‪ (١‬ﺍﮔﺮ ﺁﺭﺍﻳﻪ ‪ A‬ﻳﻚ ﺁﺭﻳﻪ ‪ N‬ﻋﻨﺼﺮﻱ ﻣﺮﺗﺐ ﺷﺪﻩ ﻧﺰﻭﻟﻲ ﺑﺎﺷﺪ ﺣﺪﺍﻛﺜﺮ ﭼﻨﺪ ﻋﻤـﻞ ﻣﻘﺎﻳـﺴﻪ ﻭ ﺟﺎﺑﺠـﺎﻳﻲ ﻻﺯﻡ ﺍﺳـﺖ ﺗـﺎ ﻣﺮﺗـﺐ ﺳـﺎﺯﻱ‬
‫ﺍﻧﺘﺨﺎﺑﻲ ﺑﻪ ﺻﻮﺭﺕ ﺻﻌﻮﺩﻱ ﺩﺭ ﺑﻴﺎﻳﺪ؟‬
‫ﺩ( ‪N‬‬
‫‪2‬‬
‫ﺝ( ‪Log2(N)+1‬‬ ‫ﺏ(‪N(N+1)/2‬‬ ‫ﺍﻟﻒ( ‪N(N-1)/2‬‬
‫ﺗﺴﺖ‪ (٢‬ﺍﮔﺮ ﺁﺭﺍﻳﻪ ‪ S‬ﻳﻚ ﺁﺭﺍﻳﻪ ‪ N‬ﻋﻨﺼﺮﻱ ﺑﺎﺷﺪ ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﺣﺪﺍﻛﺜﺮ ﭼﻨﺪ ﻋﻤﻞ ﺟﺎﺑﺠﺎﻳﻲ ﻻﺯﻡ ﺍﺳﺖ ﺗﺎ ﺑـﺎ ﻣﺮﺗـﺐ ﺳـﺎﺯﻱ ﺣﺒـﺎﺑﻲ ﺑﺘـﻮﺍﻥ‬
‫ﺁﺭﺍﻳﻪ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﺻﻌﻮﺩﻱ ﻣﺮﺗﺐ ﻧﻤﻮﺩ؟‬
‫ﺩ( ﻧﺎﻣﺸﺨﺺ ﺍﺳﺖ‬ ‫ﺝ(‪N(N+1)/2‬‬ ‫ﺏ( ‪N(N-1)/2‬‬ ‫ﺍﻟﻒ( ‪N+ N-1 + N-2 +….+2+1‬‬
‫ﺳﺌﻮﺍﻝ( ﺍﮔﺮ ﻳﻚ ﺁﺭﺍﻳﻪ ‪ 10‬ﻋﻨﺼﺮﻱ ﻧﺎﻣﺮﺗﺐ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﻭ ﺑﺨﻮﺍﻫﻴﻢ ﺩﺭ ﺭﺍ ﺑﻪ ﺭﻭﺵ ﺑﺎﻳﻨﺮﻱ ﻋﻤﻞ ﺟﺴﺘﺠﻮ ﺭﺍ ﺍﻧﺠﺎﻡ ﺩﻫﻴﻢ ﭼﻨﺪ ﻋﻤﻞ ﻣﻘﺎﻳـﺴﻪ‬
‫ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ؟‬
‫ﺗﺴﺖ‪ (٣‬ﺍﮔﺮﻋﻤﻠﻴﺎﺕ ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﺣﺒﺎﺑﻲ ﺭﺍ ﺑﺮﺍﻱ ﻣﺮﺗﺐ ﻛﺮﺩﻥ ﺻﻌﻮﺩﻱ ﺁﺭﺍﻳﻪ ﺯﻳﺮ ﺑﻜﺎﺭ ﺑﺒﺮﻳﻢ ﭘﺲ ﺍﺯ ﭼﻨﺪ ﮔﺬﺭ ﺁﺭﺍﻳﻪ ﻣﺮﺗﺐ ﻣﻲ ﺷﻮﺩ؟‬
‫‪5 , 3 , -4 , 204 , 190 , 180‬‬
‫ﺩ( ‪2‬‬ ‫ﺝ( ‪5‬‬ ‫ﺏ( ‪4‬‬ ‫ﺍﻟﻒ( ‪3‬‬
‫ﺗﺴﺖ‪ (٤‬ﺩﺭ ﺟﺴﺘﺠﻮﻱ ﺩﻭﺩﻭﻳﻲ ﻛﺪﺍﻡ ﮔﺰﻳﻨﻪ ﺻﺤﻴﺢ ﺍﺳﺖ؟‬
‫ﺝ( ﻋﻨﺼﺮ ﻣﻮﺭﺩ ﺟﺴﺘﺠﻮ ﺑﺎ ﺗﻚ ﺗﻚ ﻋﻨﺎﺻﺮ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮﺩ‬ ‫ﺍﻟﻒ( ﺳﺮﻋﺖ ﺟﺴﺘﺠﻮ ﻧﺴﺒﺖ ﺑﻪ ﺧﻄﻲ ﻛﻤﺘﺮ ﺍﺳﺖ‪.‬‬
‫ﺩ( ﻟﻴﺴﺖ ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﻣﺮﺗﺐ ﺑﺎﺷﺪ‬ ‫ﺏ( ﻟﻴﺴﺖ ﻣﺮﺗﺐ ﺷﺪﻩ ﺑﻬﺘﺮ ﺍﺳﺖ‬
‫ﺗﺴﺖ ‪(٥‬ﻟﻴﺴﺘﻲ ﺩﺍﺭﺍﻱ ‪ ١٠٠٠‬ﻋﻀﻮ ﺍﺳﺖ ﺣﺪﺍﻛﺜﺮ ﭼﻨﺪ ﻣﻘﺎﻳﺴﻪ ﺑﺮﺍﻱ ﭘﻴﺪﺍ ﻛﺮﺩﻥ ﻳﻚ ﺁﻳﺘﻢ ﺩﺭ ﻟﻴﺴﺖ ﻣﻮﺭﺩ ﻧﻈﺮ ﺑﺎ ﺭﻭﺵ ﺩﻭﺩﻭﻳﻲ ﻻﺯﻡ ﺍﺳﺖ؟‬
‫ﺩ(‪١٠٠٠‬‬ ‫ﺝ( ‪٥٠٠‬‬ ‫ﺏ( ‪١١‬‬ ‫ﺍﻟﻒ( ‪١٠‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪103‬‬

‫ﻓﺎﯾـﻠﻬﺎ )‪(FILES‬‬
‫ﻓﺎﯾﻞ ﭼﯿﺴﺖ ؟‬
‫ﻓﺎﻳﻞ ‪ ،‬ﻣﺠﻤﻮﻋﻪ ﺍﻱ ﺍﺯ ﺍﻃﻼﻋﺎﺕ ﺩﺭﺑﺎﺭﻩ ﻳﻚ ﻣﻮﺿﻮﻉ ﺍﺳﺖ ﻛﻪ ﺭﻭﻱ ﺣﺎﻓﻈﻪ ﻫﺎﻱ ﺟﺎﻧﺒﻲ ﻧﻈﻴﺮ ﺩﻳﺴﻜﺖ ﻭ ﻳﺎ ﻫﺎﺭﺩﺩﻳﺴﻚ ﻧﮕﻪ ﺩﺍﺭﻱ ﻣﻲ ﮔـﺮﺩﺩ‪.‬‬
‫ﺑﻨﺎﺑﺮﺍﻳﻦ ﺑﺮﺍﻱ ﺫﺧﻴﺮﻩ ﺩﺍﺋﻤﻲ ﺩﺍﺩﻩ ﻫﺎ ﻭ ﺍﻃﻼﻋﺎﺕ ﺍﺯ ﺳﺎﺧﺘﺎﺭﻱ ﺑﻨﺎﻡ ﻓﺎﻳﻞ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪ .‬ﭘﺲ ﺗﻤﺎﻡ ﺑﺮﻧﺎﻣﻪ ﻫﺎﻳﻲ ﻛﻪ ﺗﺎ ﻛﻨﻮﻥ ﻣﻲ ﻧﻮﺷﺘﻴﻢ ﻭ‬
‫ﻫﻤﭽﻨﻴﻦ ﻋﻤﻠﻴﺎﺕ ﻣﺮﺑﻮﻁ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺩﺭ ﺣﺎﻓﻈﻪ ﺍﺻﻠﻲ )‪ (RAM‬ﻛﺎﻣﭙﻴﻮﺗﺮ ﺍﻧﺠﺎﻡ ﻣﻲ ﮔﺮﻓﺖ ﻛﻪ ﮔـﺬﺭﺍ ﻭ ﻓﻘـﻂ ﺑـﻪ ﺯﻣـﺎﻥ ﺍﺟـﺮﺍﻱ ﺑﺮﻧﺎﻣـﻪ ﻭ‬
‫ﺭﻭﺷﻦ ﺑﻮﺩﻥ ﻛﺎﻣﭙﻴﻮﺗﺮ ﺑﺴﺘﮕﻲ ﺩﺍﺷﺖ‪.‬ﻭﻟﻲ ﺩﺭ ﻓﺎﻳﻞ ﻫﺎ ﭼﻨﻴﻦ ﻧﻴﺴﺖ‪ ،‬ﺑﻠﻜﻪ ﺩﺍﺩﻩ ﻫﺎ ﺩﺭ ﻓﺎﻳﻠﻬﺎﻳﻲ ﻗﺮﺍﺭ ﺩﺍﺭﻧﺪ ﻛﻪ ﺑﻌﺪﺍ ﻭ ﺣﺘـﻲ ﺑﻌـﺪ ﺍﺯ ﺧـﺎﻣﻮﺵ‬
‫ﻛﺮﺩﻥ ﻛﺎﻣﭙﻴﻮﺗﺮ‪ ،‬ﺑﺎﺯ ﻫﻢ ﺩﺍﺩﻩ ﻫﺎ ﻗﺎﺑﻞ ﺩﺳﺘﺮﺳﻲ ﻫﺴﺘﻨﺪ‪.‬‬
‫ﺩﺭ ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ ﻛﻪ ﺩﺭ ﺣﺎﻝ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﻫﺴﺘﻴﻢ ﻛﻪ ‪ ۱۰۰‬ﻋﺪﺩ ﺍﺯ ﻭﺭﻭﺩﻱ ﺩﺭﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﻭ ‪ ۲۰۰‬ﻋـﺪﺩ ﺩﺭ ﺧﺮﻭﺟـﻲ ﺗﻮﻟﻴـﺪ ﻣـﻲ ﻛﻨـﺪ‪.‬‬
‫ﺣﺎﻝ ﺑﺎ ﻫﺮ ﺑﺎﺭ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣﻪ‪ ،‬ﺑﺎﻳﺪ ﺗﻌﺪﺍﺩ ‪ ۱۰۰‬ﻋﺪﺩ ﺑﻌﻨﻮﺍﻥ ﺩﺍﺩﻩ ﻫﺎﻱ ﻭﺭﻭﺩﻱ ﺑﻪ ﺑﺮﻧﺎﻣﻪ‪ ،‬ﻭﺍﺭﺩ ﻛﻨﻴﻢ ﺗﺎ ﺩﺭ ﺧﺮﻭﺟﻲ ‪ ۲۰۰‬ﻋﺪﺩ ﺑﺒﻴﻨﻴﻢ ﻛـﻪ ﺍﻳـﻦ‬
‫ﺑﺴﻴﺎﺭ ﺧﺴﺘﻪ ﻛﻨﻨﺪﻩ ﺍﺳﺖ‪ .‬ﻟﺬﺍ ﺑﻬﺘﺮ ﺍﺳﺖ ﻛﻪ ﺍﻳﻦ ‪ ۱۰۰‬ﻋﺪﺩ ﺍﺯ ﻗﺒﻞ ﻳﻜﺒﺎﺭ ﺩﺭ ﻓﺎﻳﻠﻲ ﺫﺧﻴﺮﻩ ﺷﻮﻧﺪ ﻭ ﺩﺭ ﻫﻨﮕﺎﻡ ﺍﺟﺮﺍﻱ ﺑﺮﻧﺎﻣـﻪ ﻓﺎﻳـﻞ ﺍﺯ ﻭﺭﻭﺩﻱ‬
‫ﺧﻮﺍﻧﺪﻩ ﺷﻮﺩ ﻭ ﻫﻤﭽﻨﻴﻦ ﺍﻃﻼﻋﺎﺕ ﺧﺮﻭﺟﻲ ﻧﻴﺰ ﺩﺭ ﻓﺎﻳﻞ ﺗﻮﻟﻴﺪ ﺷﻮﺩ ﻭ ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ ﺩﺍﺩﻩ ﻫﺎ ﻣﺎﻧﺪﮔﺎﺭ ﺷﻮﻧﺪ ﻭ ﺍﺯ ﺑﻴﻦ ﻧﻴﺰ ﻧﺮﻭﻧﺪ‪.‬‬

‫ﺑﯿﺸﺘﺮ ﺑﺪاﻧﯿﻢ ‪...‬‬

‫ﻫﺮ ﻓﺎﻳﻞ ﺩﺍﺭﺍﻱ ﻳﻚ ﻧﺎﻡ ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﺩﺭ ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ‪ DOS‬ﻧﺎﻡ ﻳﻚ ﻓﺎﻳﻞ ﺣﺪﺍﻛﺜﺮ ﺍﺯ ‪ ۸‬ﺣﺮﻑ ﺗﺸﻜﻴﻞ ﺷﺪﻩ ﻭ ﻣﻤﻜﻦ ﺍﺳﺖ ﺩﺍﺭﺍﻱ ﭘـﺴﻮﻧﺪ ﺑـﺎ‬
‫ﺣﺪﺍﻛﺜﺮ ‪ ۳‬ﺣﺮﻑ ﺑﺎﺷﺪ ‪.‬‬

‫ﺩﺭ ﺯﺑﺎﻥ ﭘﺎﺳﻜﺎﻝ ﺳـﻪ ﻧﻮﻉ ﻓﺎﻳﻞ ﺯﻳﺮ ﻭﺟﻮﺩ ﺩﺍﺭﻧﺪ ﻛﻪ ﺩﺭ ﺍﻳﻦ ﻓﺼﻞ ﺩﺳﺘﻮﺭﺍﺕ ﻣﺮﺑﻮﻁ ﺑﻪ ﻫﺮ ﻳﻚ ﺭﺍ ﺑﺮﺭﺳﻲ ﻣﻲ ﻛﻨﻴﻢ ‪:‬‬
‫‪ - 1‬ﻓﺎﯾﻠﻬﺎي ﻣﺘﻨﯽ ‪ ) -Text -‬ﺗﺮﺗﯿﺒﯽ (‬
‫‪ -2‬ﻓﺎﯾﻠﻬﺎي ﻧﻮع دار ‪ ) - Typed File -‬ﺑﺎﯾﻨﺮي ﯾﺎ دودوﯾﯽ ﯾﺎ ﺗﺼﺎدﻓﯽ (‬
‫‪ - 3‬ﻓﺎﯾﻠﻬﺎي ﺑﺪون ﻧﻮع ‪Untyped File -‬‬

‫ﺑﺮاي ﮐﺎر ﺑﺎ ﻫﺮ ﻧﻮع ﻓﺎﯾﻞ در ﺗﻮرﺑـﻮ ﭘﺎﺳﮑﺎل ﺑﺎﯾﺪ روﻧﺪ زﯾﺮ اﻧﺠﺎم ﮔﯿﺮد ‪:‬‬

‫‪ -۱‬ﺗﻌﺮﻳﻒ ﻳﻚ ﺍﺷﺎﺭﻩ ﮔﺮ ﺑﻪ ﻓﺎﻳﻞ‬ ‫‪ -۱‬ﺑﺮﺍﻱ ﻛﺎﺭ ﺑﺎ ﻫﺮ ﻧﻮﻉ ﻓﺎﻳﻞ ﺍﺑﺘﺪﺍ ﺑﺎﻳﺪ ﻣﺘﻐﻴﺮﻱ ﺍﺯ ﻧﻮﻉ ﻓﺎﻳﻞ ﻣﻮﺭﺩﻧﻈﺮ ﺍﻳﺠﺎﺩ ﻧﻤﺎﻳﻴﻢ‪.‬‬
‫ﺑﻌﻨﻮﺍﻥ ﻣﺜﺎﻝ ﺑﺮﺍﻱ ﻓﺎﻳﻠﻬﺎﻱ ﻣﺘﻨﻲ‪ ،‬ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ)ﻳﺎ ﺍﺷﺎﺭﻩ ﮔﺮ( ﭼﻨﻴﻦ ﺍﺳﺖ ‪:‬‬
‫‪Var‬‬
‫; ‪F:Text‬‬
‫‪ -۲‬ﻧﺴﺒﺖ ﺩﺍﺩﻥ ﺍﺷﺎﺭﻩ ﮔﺮ ﻓﺎﻳﻞ ﺑﻪ‬
‫ﻧﻜﺘﻪ ( ﺷﻨﺎﺳﻪ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ‪ Text‬ﻧﻮﻉ ﻓﺎﻳﻠﻬﺎﻱ ﻣﺘﻨﻲ ﺭﺍ ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﻳﻚ ﻓﺎﻳﻞ ﺩﺭ ﺣﺎﻓﻈﻪ ﻱ ﺟﺎﻧﺒﻲ‬
‫‪ - ۲‬ﺑﻌﺪ ﺍﺯ ﺗﻌﺮﻳﻒ ﺍﺷﺎﺭﻩ ﮔﺮ‪ ،‬ﺑﺎﻳﺪ ﺁﻧﺮﺍ ﺑﺎ ﻧﺎﻡ ﻳﻚ ﻓﺎﻳﻞ ﺩﺭ ﻫﺎﺭﺩ ﺩﻳﺴﻚ ﻣﺮﺗﺒﻂ ﻛﻨـﻴﻢ‪ ،‬ﻳـﺎ‬
‫ﺑﻌﺒﺎﺭﺕ ﺩﻳﮕﺮ ﺑﺎﻳﺪ ﺁﻧﺮﺍ ﺑﻪ ﻳﻚ ﻓﺎﻳﻞ ﺩﺭ ﺣﺎﻓﻈﻪ ﺟﺎﻧﺒﻲ ﻧﺴﺒﺖ ﺩﻫﻴﻢ‪ .‬ﺍﻳﻦ ﻛـﺎﺭ ﺑـﺎ ﺩﺳـﺘﻮﺭ‬
‫‪ Assign‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪.‬ﺑﻌﻨﻮﺍﻥ ﻣﺜﺎﻝ ﺑﺮﺍﻱ ﻧﺴﺒﺖ ﺩﺍﺩﻥ ﺍﺷﺎﺭﻩ ﮔـﺮ ‪ F‬ﺑـﻪ ﻓﺎﻳـﻞ ﻣﺘﻨـﻲ‬
‫‪ -۳‬ﺑﺎﺯ ﻛﺮﺩﻥ ﻓﺎﻳﻞ‬
‫‪ Student.txt‬ﺩﺭ ﺩﺭﺍﻳﻮ ‪ C‬ﻛﺎﻣﭙﻴﻮﺗﺮﻣﺎﻥ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﻋﻤﻞ ﻣﻲ ﻛﻨﻴﻢ ‪:‬‬
‫‪VAR‬‬
‫;‪F : TEXT‬‬
‫‪ -۴‬ﭘﺮﺩﺍﺯﺵ )ﺧﻮﺍﻧﺪﻥ ﺍﺯ ﻓﺎﻳﻞ ﻳﺎ‬
‫‪BEGIN‬‬
‫ﻧﻮﺷﺘﻦ ﺩﺭ ﻓﺎﻳﻞ ﻭ ‪(...‬‬ ‫;) ‘ ‪ASSIGN( F, ‘ C:\Student.TXT‬‬
‫ﻧﻜﺘﻪ ( ﺩﺳﺘﻮﺭ ‪ Assign‬ﻓﻘﻂ ﻛﺎﻓﻲ ﺍﺳﺖ ﻳﻜﺒﺎﺭ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﺷﺘﻪ ﺷﻮﺩ‪.‬‬
‫ﺑﻌﺪ ﺍﺯ ﺍﺟﺮﺍﻱ ﺩﺳﺘﻮﺭ ‪، Assign‬ﺑﺮﺍﻱ ﺍﻧﺠﺎﻡ ﻋﻤﻞ ﺧﻮﺍﻧﺪﻥ ﻳﺎ ﻧﻮﺷﺘﻦ ﻭ ﻳﺎ ﺗﻐﻴﻴـﺮ ﺩﺍﺩﻥ ﺩﺭ‬
‫‪ -۵‬ﺑﺴﺘﻦ ﻓﺎﻳﻞ‬
‫ﻓﺎﻳﻞ ﺍﺯ ﺍﺷﺎﺭﻩ ﮔﺮ ‪ F‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪.‬ﺑﻌﺒﺎﺭﺕ ﺩﻳﮕﺮ ﻫﺮ ﻋﻤﻠﻲ ﻛﻪ ﺑﺮ ﺭﻭﻱ ‪ F‬ﺍﻧﺠﺎﻡ ﺷـﻮﺩ‬
‫ﺩﺭ ﻭﺍﻗﻊ ﺑﺮ ﺭﻭﻱ ﻓﺎﻳﻞ ‪ Student.txt‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪104‬‬
‫ﻣﺮﺍﺣﻞ ‪ ۳‬ﻭ ‪ ۴‬ﻭ‪ ۵‬ﺑﺮﺍﻱ ﻓﺎﻳﻠﻬﺎ ﺩﻗﻴﻘﺎ ﻣﺎﻧﻨﺪ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺑﺨﻮﺍﻫﻴﻢ ﻳﻚ ﭘﺮﻭﻧﺪﻩ ﻳﺎ ﻛﺘﺎﺑﻲ ﺭﺍ ﺍﺑﺘﺪﺍ ﺑﺎﺯ ﻛﺮﺩﻩ ﻭ ﺳﭙﺲ ﻣﻄﺎﻟﺒﻲ ﺭﺍ ﺍﺯ ﺁﻥ ﺧﻮﺍﻧـﺪﻩ ﻭ‬
‫ﻳﺎ ﺩﺭ ﺁﻥ ﺍﺿﺎﻓﻪ‪ ،‬ﺣﺬﻑ ﻭ ﻳﺎ ﺗﻐﻴﻴﺮ ﺩﺍﺩﻩ ﻭﺩﺭ ﺍﻧﺘﻬﺎ ﭘﺮﻭﻧﺪﻩ ﻳﺎ ﻛﺘﺎﺏ ﺭﺍ ﺑﺒﻨﺪﻳﻢ‪.‬‬
‫‪ -1‬ﻓﺎﯾﻠﻬﺎي ﻣﺘﻨـﯽ ‪:‬‬
‫ﻓﺎﻳﻞ ﻣﺘﻨﻲ‪ ،‬ﻓﺎﻳﻠﻲ ﺍﺳﺖ ﻛﻪ ﺍﺯ ﺗﻌﺪﺍﺩﻱ ﺧﻂ ﺷﺎﻣﻞ ﻛﺎﺭﺍﻛﺘﺮﻫﺎﻳﻲ ﺑﺎ ﻛﺪ ﺍﺳﻜﻲ ﺗﺸﻜﻴﻞ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﻫﺮ ﺧﻂ ﺑﻪ ﻛﺎﺭﺍﻛﺘﺮﻫﺎﻱ ‪ CR‬ﻭ ‪ LF‬ﺧﺘﻢ‬
‫ﻣﻲ ﮔﺮﺩﺩ‪.‬ﺗﺮﻛﻴﺐ ‪ CR‬ﻭ ‪ LF‬ﺑﻌﻨﻮﺍﻥ ﺟﺪﺍ ﻛﻨﻨﺪﻩ ﺧﻄﻮﻁ ﻣﻮﺭﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ‪ .‬ﻓﺎﻳﻠﻬﺎﻱ ﻣﺘﻨﻲ ﻣﻌﻤﻮﻻ ﺩﺍﺭﺍﻱ ﭘﺴﻮﻧﺪ ‪ TXT‬ﻣـﻲ‬
‫ﺑﺎﺷﻨﺪ‪.‬‬
‫ﻫﺮ ﺍﻃﻼﻋﺎﺗﻲ ﻛﻪ ﺩﺍﺧﻞ ﻓﺎﻳﻠﻬﺎﻱ ﻣﺘﻨﻲ ﺭﻳﺨﺘﻪ ﺷﻮﺩ ﺑﻪ ﺭﺷﺘﻪ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﺩ ؛ ﺑﻪ ﻫﻤﻴﻦ ﺩﻟﻴﻞ ﻓﺎﻳﻠﻬﺎﻱ ﻣﺘﻨﻲ ﻧﺴﺒﺖ ﺑﻪ ﺩﻭ ﻧﻮﻉ ﺩﻳﮕـﺮ ﻛﻨـﺪﺗﺮ‬
‫ﻫﺴﺘﻨﺪ‪.‬‬
‫ﻋﻤﻞ ﺑﺎﺯ ﻛﺮﺩﻥ ﻓﺎﻳﻞ ﻣﺘﻨـﻲ ﺑﺮﺍﻱ ﻳﻜﻲ ﺍﺯ ‪ ۳‬ﻫﺪﻑ ﺯﻳﺮ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ‪:‬‬
‫‪ - ۱‬ﺍﻳﺠﺎﺩ ﻛﺮﺩﻥ ﻳﻚ ﻓﺎﻳﻞ ﺟﺪﻳﺪ‬
‫‪ - ۲‬ﺧﻮﺍﻧﺪﻥ ﻣﺤﺘﻮﺍﻱ ﻳﻚ ﻓﺎﻳﻞ ﻣﻮﺟﻮﺩ‬
‫‪ - ۳‬ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ ﺩﺍﺩﻩ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﻳﻚ ﻓﺎﻳﻞ ﻣﺘﻨﻲ‬
‫ﺩﺭ ﺗﻮﺭﺑﻮ ﭘﺎﺳﻜﺎﻝ ﺑﺮﺍﻱ ﻫﺮ ﻳﻚ ﺍﺯ ﻋﻤﻠﻴﺎﺕ ﺑﺎﺯ ﻛﺮﺩﻥ ﻓﺎﻳﻞ ﻣﺘﻨﻲ ‪ ،‬ﻳﻚ ﺩﺳﺘﻮﺭ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪ .‬ﺑﺮﺍﻱ ﺍﻳﺠﺎﺩ ﻛﺮﺩﻥ ﻳﻚ ﻓﺎﻳـﻞ ﺟﺪﻳـﺪ ﺍﺯ ﺩﺳـﺘﻮﺭ‬
‫‪ Rewrite‬ﻭﺑﺮﺍﻱ ﺧﻮﺍﻧﺪﻥ ﺍﺯ ﻳﻚ ﻓﺎﻳﻞ ﻣﻮﺟـﻮﺩ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ Reset‬ﻭ ﺑﺮﺍﻱ ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ ﺩﺍﺩﻩ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﻳـﻚ ﻓﺎﻳـﻞ ﻣﺘﻨـﻲ ﺍﺯ ﺩﺳـﺘﻮﺭ‬
‫‪ Append‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬

‫‪ -1‬دﺳﺘﻮر ‪ : Rewrite‬ﺍﮔﺮ ﺑﻪ ﺍﻳﻦ ﺭﻭﺵ ﻓﺎﻳﻞ ﻣﺘﻨﻲ ﺭﺍ ﺑﺎﺯ ﻛﻨﻴﻢ ‪ ،‬ﻓﺎﻳﻞ ﻣﺘﻨﻲ ﺳﺎﺧﺘﻪ ﻣﻲ ﺷﻮﺩ ﻭ ﻓﻘﻂ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﺩﺍﺧﻞ ﺁﻥ ﺍﻃﻼﻋﺎﺕ‬
‫ﺑﺮﻳﺰﻳﻢ‪.‬ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ ﻓﺎﻳﻞ ﺍﺯ ﻗﺒﻞ ﻣﻮﺟﻮﺩ ﺑﺎﺷﺪ ﻭ ﺁﻥ ﺭﺍ ﺑﺎ ﺩﺳﺘﻮﺭ ‪ Rewrite‬ﺑﺎﺯ ﻛﻨﻴﻢ ‪ ،‬ﻓﺎﻳﻞ ﺭﺍ ﭘﺎﻙ ﻛﺮﺩﻩ ﻭ ﺍﺯ ﻧﻮ ﻣﻲ ﺳﺎﺯﺩ‪.‬‬

‫‪ – 2‬دﺳﺘﻮر ‪ : Reset‬ﺍﮔﺮ ﻓﺎﻳﻞ ﻣﺘﻨﻲ ﺭﺍ ﺑﻪ ﺍﻳﻦ ﺭﻭﺵ ﺑﺎﺯ ﻛﻨﻴﻢ ﻓﺎﻳﻞ ﺭﺍ ﻓﻘﻂ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﺑﺨﻮﺍﻧﻴﻢ ﻭ ﻧﻤﻲ ﺗـﻮﺍﻧﻴﻢ ﺩﺭ ﺁﻥ ﺍﻃﻼﻋـﺎﺕ ﺑﺮﻳـﺰﻳﻢ‪.‬‬
‫ﻧﻜﺘﻪ ﻣﻬﻤﻲ ﻛﻪ ﺑﺎﻳﺪ ﺑﻪ ﺁﻥ ﺗﻮﺟﻪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺑﺎﻳﺪ ﺍﺯ ﻗﺒﻞ ﻓﺎﻳﻞ ﻣﻮﺟﻮﺩ ﺑﺎﺷﺪ‪.‬ﺍﮔﺮ ﻓﺎﻳـﻞ ﻣﻮﺟـﻮﺩ ﻧﺒﺎﺷـﺪ ﻭ ﻣـﺎ‬
‫ﺑﺨﻮﺍﻫﻴﻢ ﻓﺎﻳﻞ ﻭﺟﻮﺩ ﻧﺪﺍﺷﺘﻪ ! ﺭﺍ ﺑﺎﺯ ﻛﻨﻴﻢ ﻗﻄﻌﺎ ﺑﺮﻧﺎﻣﻪ ‪ Error‬ﻣﻴﺪﻫﺪ‪.‬‬

‫‪ – 3‬دﺳﺘﻮر ‪ : Append‬ﺑﺎ ﺑﺎﺯ ﻛﺮﺩﻥ ﻓﺎﻳﻞ ﻣﺘﻨﻲ ﺑﻪ ﺍﻳﻦ ﺭﻭﺵ ﻓﻘﻂ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﻓﺎﻳﻞ ﺍﺯ ﻗﺒﻞ ﻣﻮﺟﻮﺩ ‪ ،‬ﺍﻃﻼﻋﺎﺕ ﺍﺿﺎﻓﻪ ﻛﻨﻴﻢ ‪.‬‬
‫ﻳﻌﻨﻲ ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﻧﻴﺰ ﻓﺎﻳﻞ ﺑﺎﻳﺪ ﺍﺯ ﻗﺒﻞ ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﻫﻤﭽﻨﻴﻦ ﺍﻃﻼﻋﺎﺕ ﺭﺍ ﻧﻴﺰ ﻧﻤﻲ ﺗﻮﺍﻥ ﺧﻮﺍﻧﺪ‪.‬‬

‫ﻧﻜﺘﻪ ( ﺩﺭ ﻫﺮ ﻟﺤﻈﻪ ﻓﻘﻂ ﺑﺎﻳﺪ ﺍﺯ ﻳﻜﻲ ﺍﺯ ‪ ۳‬ﺭﻭﺵ ﺑـﺎﻻ ﺍﺳـﺘﻔﺎﺩﻩ ﻛـﺮﺩ‪.‬ﻳﻌﻨـﻲ ﻧﻤـﻲ ﺗـﻮﺍﻧﻴﻢ ﻓﺎﻳـﻞ ﺭﺍ ﻫـﻢ ‪ Reset‬ﻛﻨـﻴﻢ ﻭ ﻫـﻢ ‪Rewrite‬‬
‫ﻛﻨﻴﻢ؛ﺑﻠﻜﻪ ﺑﺎﻳﺪ ﻓﺎﻳﻞ ﺭﺍ ﺑﺴﺖ ﻭ ﺩﻭﺑﺎﺭﻩ ﺑﻪ ﺭﻭﺵ ﺩﻳﮕﺮ ﺑﺎﺯ ﻛﺮﺩ‪.‬‬
‫ﺑﻮﺳﻴﻠﻪ ﺩﺳﺘﻮﺭﺍﺕ ‪ read , readln‬ﻣﻲ ﺗﻮﺍﻥ ﺍﻃﻼﻋﺎﺕ ﺭﺍ ﺍﺯ ﻓﺎﻳﻞ ﺧﻮﺍﻧﺪ‪.‬ﻭﺑﺮﺍﻱ ﻧﻮﺷﺘﻦ ﺍﻃﻼﻋـﺎﺕ ﺩﺭ ﻓﺎﻳـﻞ ﺍﺯ ‪ Write , Writeln‬ﺍﺳـﺘﻔﺎﺩﻩ‬
‫ﻣﻲ ﻛﻨﻴﻢ‪).‬ﺍﻟﺒﺘﻪ ﺑﻪ ﺷﺮﻁ ﺑﺎﺯ ﺑﻮﺩﻥ ﻓﺎﻳﻞ ﻣﻲ ﺗﻮﺍﻧﻴﻢ ﺍﺯ ﻓﺎﻳﻞ ﺑﺨﻮﺍﻧﻴﻢ ﻭ ﻳﺎ ﺩﺭ ﻓﺎﻳﻞ ﺑﻨﻮﻳﺴﻴﻢ(‪.‬‬
‫ﻧﻜﺘﻪ ( ﺗﻔﺎﻭﺕ ‪ Read‬ﺑﺎ ‪ Readln‬ﻭ ﻫﻢ ﭼﻨﻴﻦ ‪ Write‬ﺑﺎ ‪ Writeln‬ﻣﺎﻧﻨﺪ ﻗﺒﻞ ﺍﺳﺖ‪.‬‬
‫ﻫﻨﮕﺎﻣﻴﻜﻪ ﻓﺎﻳﻠﻲ ﺭﺍ ﺑﻪ ﺭﻭﺵ ‪ Reset‬ﺑﺎﺯ ﻣﻲ ﻛﻨﻴﻢ ﻳﻚ ﻣﻜﺎﻥ ﻧﻤﺎﻱ ﻓﺮﺿﻲ ﺩﺭ ﺍﺑﺘﺪﺍﻱ ﻓﺎﻳﻞ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ ؛ ﺑﺎ ﻫﺮ ﺑﺎﺭ ﺧﻮﺍﻧﺪﻥ ﺍﻃﻼﻋﺎﺕ ﻓﺎﻳـﻞ‬
‫‪ ،‬ﻣﻜﺎﻥ ﻧﻤﺎﻱ ﻓﺮﺿﻲ ﻳﻜﻲ ﺑﻪ ﺟﻠﻮ ﺣﺮﻛﺖ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﺍﮔﺮ ﻓﺎﻳﻠﻲ ﺭﺍ ﺑﻪ ﺭﻭﺵ ‪ Append‬ﺑﺎﺯ ﻛﻨﻴﻢ ﻣﻜﺎﻥ ﻧﻤﺎﻱ ﻓﺮﺿﻲ ﺩﺭ ﺍﻧﺘﻬﺎﻱ ﻓﺎﻳﻞ ﻗﺮﺍﺭ ﻣﻲ ﮔﻴﺮﺩ ﻛﻪ ﺑﺎ ﻫﺮ ﺑﺎﺭ ﻧﻮﺷﺘﻦ ﺍﻃﻼﻋﺎﺕ ﺩﺭ ﻓﺎﻳﻞ ‪ ،‬ﻣﻜـﺎﻥ‬
‫ﻧﻤﺎ ﻳﻜﻲ ﺑﻪ ﺟﻠﻮ ﺣﺮﻛﺖ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﺑﺮﺍﻱ ﺑﺴﺘﻦ ﻓﺎﻳﻞ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ Close‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﺩﺳﺘﻮﺭ ‪ close‬ﺑﺎﻋﺚ ‪ save‬ﺷﺪﻥ ﻓﺎﻳﻞ ﻣﻲ ﺷﻮﺩ ؛ ﺍﻟﺒﺘﻪ ﺍﮔﺮ ﻓﺎﻳﻞ ﺭﺍ ﺑﺒﻨﺪﻳﻢ ﺍﺭﺗﺒﺎﻁ ﺍﺷﺎﺭﻩ ﮔﺮ ﺑﺎ ﺁﻥ ﻓﺎﻳﻞ ﻗﻄﻊ ﻧﻤﻲ ﺷﻮﺩ ﻭ ﺑﺮﺍﻱ ﺑﺎﺯ ﻛﺮﺩﻥ‬
‫ﻣﺠﺪﺩ ﺁﻥ ﻓﺎﻳﻞ ﻧﻴﺎﺯﻱ ﺑﻪ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ Assign‬ﻧﻴﺴﺖ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪105‬‬
‫ﺣﺎﻝ ﺑﻪ ﻣﺜﺎﻟﻲ ﻛﻪ ﺩﺭ ﺯﻳﺮ ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺍﺳﺖ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ﻭ ﺑﻪ ﻧﺤﻮﻩ ﻱ ﺗﻌﺮﻳﻒ ﺍﺷﺎﺭﻩ ﮔﺮ ﻭ ﺑﺎﺯﻛﺮﺩﻥ ﻓﺎﻳﻞ ﻭ ﭘﺮﺩﺍﺯﺵ ﻓﺎﻳﻞ ﻭ ﺑـﺴﺘﻦ ﺁﻥ ﺩﻗـﺖ‬
‫ﻛﻨﻴﺪ ‪:‬‬
‫ﻣﺜﺎﻝ ‪ ( ۱‬ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺗﻌﺪﺍﺩﻱ ﻋﺪﺩ ﺍﺯ ﻛﺎﺭﺑﺮ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﺳﭙﺲ ﺩﺍﺧﻞ ﻳﻚ ﻓﺎﻳﻞ ﻣﺘﻨﻲ ﺑﺮﻳﺰﺩ‪.‬ﭘﺎﻳﺎﻥ ﺑﺨﺶ ﺩﺍﺩﻩ ﻫﺎ ﺻﻔﺮ ﺍﺳﺖ ﻭ‬
‫ﻫﻤﭽﻨﻴﻦ ﺑﻮﺳﻴﻠﻪ ﻳﻚ ﭘﺮﻭﺳﻴﺠﺮ ﺍﻋﺪﺍﺩ ﺩﺍﺧﻞ ﻓﺎﻳﻞ ﺭﺍ ﺧﻮﺍﻧﺪﻩ ﻭ ﺟﻤﻊ ﻭ ﺗﻌﺪﺍﺩ ﺍﻋﺪﺍﺩ ﺭﺍ ﺩﺭ ﻣﺎﻧﻴﺘﻮﺭ ﭼﺎﭖ ﻛﻨﺪ ‪:‬‬
‫‪var‬‬
‫;‪f:text‬‬
‫;‪n:integer‬‬
‫;‪procedure sum‬‬
‫‪var‬‬
‫;‪x,s,i:integer‬‬
‫‪begin‬‬
‫;)'‪assign(f,'c:\m.txt‬‬
‫;)‪reset(f‬‬
‫;‪i:=0; s:=0‬‬
‫‪while not eof(f) do‬‬
‫‪begin‬‬
‫;) ‪Readln ( f , x‬‬
‫;‪s:=s+x‬‬
‫;‪i:=i+1‬‬
‫;‪end‬‬
‫;)‪close(f‬‬
‫;)‪writeln(s‬‬
‫;)‪writeln(i‬‬
‫;‪end‬‬
‫‪begin‬‬
‫;)'‪assign(f,'c:\m.txt‬‬
‫;)‪rewrite(f‬‬
‫‪repeat‬‬
‫;)‪readln(n‬‬
‫;‪if n=0 then break‬‬
‫;) ‪writeln ( F , n‬‬
‫;‪until false‬‬
‫;)‪close(f‬‬
‫;‪sum‬‬
‫‪end.‬‬

‫ﺳﻮﺍﻝ ( ﺣﺎﻝ ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻱ ﺑﺎﻻ ﺩﺭ ﺍﻧﺘﻬﺎﻱ ﻓﺎﻳﻞ ﺩﻭ ﻣﺘﻐﻴﺮ ‪)S‬ﺟﻤﻊ ﺍﻋﺪﺍﺩ( ﻭ ‪) I‬ﺗﻌﺪﺍﺩ ﺍﻋﺪﺍﺩ( ﺍﺿﺎﻓﻪ ﺷﻮﺩ؛ ﭼﻪ ﺗﻐﻴﻴـﺮﻱ ﺑﺎﻳـﺪ ﺩﺭ‬
‫ﺑﺮﻧﺎﻣﻪ ﺑﺎﻻ ﺑﺪﻫﻴﻢ ﻳﺎ ﺑﻌﺒﺎﺭﺕ ﺩﻳﮕﺮ ﭼﻪ ﺩﺳﺘﻮﺭﻫﺎﻳﻲ ﺑﺎﻳﺪ ﺑﻪ ﻗﺴﻤﺖ ﭘﺮﻭﺳﻴﺠﺮ ﺑﺮﻧﺎﻣﻪ ﺑﺎﻻ ﺍﺿﺎﻓﻪ ﻛﻨﻴﻢ ؟‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪106‬‬
‫ﻣﺜﺎﻝ ‪ ( ۲‬ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻣﺤﺘﻮﺍﻱ ﻓﺎﻳﻞ ‪ m.txt‬ﺭﺍ ﺩﺭ ﻓﺎﻳﻞ ‪ p.txt‬ﻛﭙﻲ ﻛﻨﺪ ‪:‬‬
‫‪var‬‬
‫;‪f1,f2:text‬‬ ‫ﺳﻮﺍﻝ ( ﺍﮔﺮ ﺑﺠﺎﻱ ﺩﺳﺘﻮﺭ )‪ Read(f1,c‬ﺩﺳﺘﻮﺭ )‪ Readln(f1,c‬ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺑﻮﺩ ؛‬
‫;‪c:char‬‬ ‫ﻣﺤﺘﻮﺍﻱ ﻓﺎﻳﻞ ‪ F2‬ﭼﻪ ﺗﻐﻴﻴﺮﻱ ﻣﻲ ﻛﺮﺩ ؟‬
‫‪begin‬‬
‫;)'‪assign(f1,'c:\m.txt‬‬
‫;)'‪assign(f2,'c:\p.txt‬‬
‫;)‪reset(f1‬‬
‫;)‪rewrite(f2‬‬
‫‪while not eof(f1) do‬‬
‫‪begin‬‬
‫;)‪read(f1,c‬‬
‫;)‪write(f2,c‬‬
‫;‪end‬‬
‫;)‪close(f1‬‬
‫;)‪close(f2‬‬
‫‪end.‬‬

‫ﺗﺎﺑﻊ ﺑﻮﻟﯽ ‪: (End of file) Eof‬‬

‫ﺑﺮﺍﻱ ﺍﻃﻼﻉ ﺍﺯ ﺭﺳﻴﺪﻥ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﻓﺎﻳﻞ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻴﺸﻮﺩ‪ .‬ﺍﮔﺮ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﻓﺎﻳﻞ ﺑﺮﺳﻴﻢ ﻳﺎ ﺑﻌﺒﺎﺭﺗﻲ ﺗﻤﺎﻡ ﺧﻄﻮﻁ ﺑﺮﻧﺎﻣﻪ ﺧﻮﺍﻧﺪﻩ ﺷﺪﻩ ﺑﺎﺷﺪ ﺍﻳـﻦ‬
‫ﺗﺎﺑﻊ ﻣﻘﺪﺍﺭ ‪ True‬ﻭﮔﺮﻧﻪ ﻣﻘﺪﺍﺭ ‪ False‬ﺭﺍ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬
‫ﻧﻜﺘﻪ ( ﺩﺭ ﻓﺎﻳﻠﻬﺎﻱ ﻣﺘﻨﻲ ﺑﺮﺍﻱ ﺍﻳﻨﻜﻪ ﻣﺘﻮﺟﻪ ﺑﺸﻮﻳﻢ ﻛﻪ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﻳﻚ ﺧﻂ ﺭﺳﻴﺪﻩ ﺍﻳﻢ ﻳﺎ ﻧﻪ ﺍﺯ ﺗﺎﺑﻊ ‪ EOLN‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬
‫ﻧﻜﺘﻪ ( ﺩﺭ ﻓﺎﻳﻠﻬﺎ ﻱ ﻣﺘﻨﻲ ﻫﻨﮕﺎﻡ ﺧﻮﺍﻧﺪﻥ ﺍﻃﻼﻋﺎﺕ ﻓﺎﻳﻞ ﺑﺮﺍﻱ ﺍﻳﻨﻜﻪ ﻣﺘﻮﺟﻪ ﺑﺸﻮﻳﻢ ﻛﻪ ﺑﻪ ﺍﻧﺘﻬـﺎﻱ ﻓﺎﻳـﻞ ﺭﺳـﻴﺪﻩ ﺍﻳـﻢ ﻳـﺎ ﻧـﻪ ﺍﺯ ﺗـﺎﺑﻊ ‪Eof‬‬
‫ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪ .‬ﻣﺜﻼ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻱ ﺑﺎﻻ ﺑﺮﺍﻱ ﺧﻮﺍﻧﺪﻥ ﺗﻤﺎﻡ ﺍﻃﻼﻋﺎﺕ ﺍﺯ ﻓﺎﻳﻞ ‪ m.txt‬ﻭ ﺭﻳﺨﺘﻦ ﺁﻥ ﺑﻪ ﻓﺎﻳﻞ ‪ p.txt‬ﺍﺑﺘﺪﺍ ﺑﺎﻳﺪ ﺗﻤﺎﻡ ﻣﺤﺘـﻮﺍﻱ‬
‫ﻓﺎﻳﻞ ﺍﻭﻟﻲ ﺧﻮﺍﻧﺪﻩ ﺷﻮﺩ ‪،‬ﻛﻪ ﺑﺮﺍﻱ ﺍﻳﻨﻜﺎﺭ ﺍﺯ ﺣﻠﻘﻪ ﻱ ‪ while‬ﺍﻱ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩﻩ ﺍﻳﻢ ﻛﻪ ﺷﺮﻁ ﺁﻥ )‪ not eof(f1‬ﺍﺳﺖ ؛ ﻳﻌﻨﻲ ﺗﺎ ﺯﻣﺎﻧﻲ ﻛﻪ ﺑـﻪ‬
‫ﺍﻧﺘﻬﺎﻱ ﻓﺎﻳﻞ ﻧﺮﺳﻴﺪﻩ ﺍﻳﻢ ﺍﻃﻼﻋﺎﺕ ﺭﺍ ﺍﺯ ﻓﺎﻳﻞ ﺑﺨﻮﺍﻥ‪.‬ﻛﻪ ﻣﺴﻠﻤﺎ ﻭﻗﺘﻲ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﻓﺎﻳﻞ ﺑﺮﺳﻴﻢ ﺷـﺮﻁ ﺣﻠﻘـﻪ‪ True‬ﻣﻴـﺸﻮﺩ ﻭ ﺍﺯ ﺣﻠﻘـﻪ ﺧـﺎﺭﺝ‬
‫ﻣﻴﺸﻮﻳﻢ‪.‬‬

‫ﻣﺜﺎﻝ ‪ ( ۳‬ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻓﺎﻳﻠﻬﺎ ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ‪:‬‬

‫‪ -‬ﺑﺎ ﺯﺩﻥ ﻛﻠﻴﺪ ‪ A‬ﻳﻚ ﺩﺍﻧﺶ ﺁﻣﻮﺯ ﺑﺎ ﺍﻃﻼﻋﺎﺕ ‪ :‬ﻧﺎﻡ ‪ ،‬ﻓﺎﻣﻴﻠﻲ ﻭ ﻣﻌﺪﻝ ‪ ،‬ﺑﻪ ﻓﺎﻳﻞ ﺍﺿﺎﻓﻪ ﺷﻮﺩ‪.‬‬
‫‪ -‬ﺑﺎ ﺯﺩﻥ ﻛﻠﻴﺪ ‪ L‬ﻟﻴﺴﺖ ﺩﺍﻧﺶ ﺁﻣﻮﺯﺍﻥ ﺩﺍﺧﻞ ﻓﺎﻳﻞ ﺑﺮ ﺭﻭﻱ ﻣﺎﻧﻴﺘﻮﺭ ﻧﻤﺎﻳﺶ ﺩﺍﺩﻩ ﺷﻮﺩ‪.‬‬
‫‪ -‬ﺑﺎ ﺯﺩﻥ ﻛﻠﻴﺪ ‪ S‬ﻳﻚ ﻧﺎﻡ ﻭ ﻓﺎﻣﻴﻠﻲ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﺁﻧﺮﺍ ﺩﺭ ﻓﺎﻳﻞ ﺟﺴﺘﺠﻮ ﻛﻨﺪ)ﺟﺴﺘﺠﻮ ﺑﻪ ﺭﻭﺵ ﺧﻄﻲ( ؛ ﺍﮔﺮ ﺩﺭ ﻓﺎﻳﻞ ﻣﻮﺟﻮﺩ ﺑﻮﺩ ﺍﻃﻼﻋـﺎﺕ‬
‫ﻛﺎﻣﻞ ﺁﻥ ﺩﺍﻧﺶ ﺁﻣﻮﺯ ﺭﺍ ﭼﺎﭖ ﻛﻨﺪ ﻭ ﺍﮔﺮ ﻣﻮﺟﻮﺩ ﻧﺒﻮﺩ ﭘﻴﻐﺎﻡ ‪ Not Found‬ﺭﺍ ﺩﺭ ﻣﺎﻧﻴﺘﻮﺭ ﭼﺎﭖ ﻛﻨﺪ‪.‬‬
‫‪ -‬ﺑﺎ ﺯﺩﻥ ﻛﻠﻴﺪ ‪ Q‬ﺍﺯ ﺑﺮﻧﺎﻣﻪ ﺧﺎﺭﺝ ﺷﻮﻳﻢ‪.‬‬
‫ﻫﻤﭽﻨﻴﻦ ﺩﺍﻧﺶ ﺁﻣﻮﺯﺍﻧﻲ ﺭﺍ ﻛﻪ ﻣﻌﺪﻟﺸﺎﻥ ﻛﻤﺘﺮ ﺍﺯ ‪ ۱۰‬ﺍﺳﺖ ﺩﺭ ﻓﺎﻳﻠﻲ ﺑﻨﺎﻡ ‪ Mardud.txt‬ﺑﺮﻳﺰﺩ‪.‬‬
107 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
var
c:char;
F:text;
procedure add;
var
n,m:string[20];
avg:integer;
begin
assign(F,'c:\std.txt');
writeln('Enter name & Family & avg:');
readln(n);
readln(m);
readln(avg);
append(F);
writeln(F,n);
writeln(F,m);
writeln(F,avg);
close(f);
end;
{+++++++++++++}
procedure list;
var
n,m:string[20]; avg:integer;
begin
assign(F,'c:\std.txt');
writeln(' List File ');
reset(F);
while not eof(f) do
begin
readln(F,n);
readln(F,m);
readln(F,avg);
writeln(n ,' ',m,' ',avg);
end;
close(F);
end;
{-----------------}
procedure search;
var
x,p,n,m:string[20];
avg:integer; find:boolean;
begin
assign(F,'c:\std.txt');
writeln('name & family ');
readln(x);
readln(p);
find:=false;
reset(F);

{‫} ﺍﺩﺍﻣﻪ ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﺻﻔﺤﻪ ﺑﻌﺪ‬

108 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
while not eof(f) do
begin
readln(F,n);
readln(F,m);
readln(F,avg);
if (x=n) and(p=m) then
begin
writeln(x , ' ', p,' ',avg);
find:=true;
break;
end;
end;
close(F);
if find=false then
writeln(' not found');
end;
{============}
procedure mardud;
var
n,m:string[20];
avg:integer; f1:text;
begin
assign(f1,'c:\mardud.txt');
assign(f,'c:\std.txt');
reset(f);
rewrite(F1);
while not eof(F) do
begin
readln(F,n);
readln(F,m);
readln(F,avg);
if avg<10 then
begin
writeln(F1,n);
writeln(F1,m);
writeln(F1,avg);
end;
end;
close(F); close(F1);
end;
begin
repeat
writeln(' A or S or L or Q ?');
readln(c);
if c='A' then add;
if c='L' then list;
if c='S' then search;
until c='Q';
mardud;
end.
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪109‬‬
‫ﻓﺎﻳﻞ ﻫﺎﻱ ﻧـﻮﻉ ﺩﺍﺭ ‪:‬‬
‫ﻓﺎﻳﻞ ﻧﻮﻉ ﺩﺍﺭ ﺣﺎﻭﻱ ﺍﻃﻼﻋﺎﺗﻲ ﺍﺯ ﻳﻚ ﻧﻮﻉ ﺩﺍﺩﻩ ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﻣﺜﻼ ﻓﺎﻳﻠﻲ ﺍﺯ ﻧﻮﻉ ‪ ، Integer‬ﻓﻘﻂ ﺣﺎﻭﻱ ﺍﻋـﺪﺍﺩ ﺻـﺤﻴﺢ ﻭ ﻳـﺎ ﻓـﺎﻳﻠﻲ ﺍﺯ ﻧـﻮﻉ‬
‫‪ ، Real‬ﻓﻘﻂ ﺣﺎﻭﻱ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﻱ ﺍﺳﺖ‪ .‬ﻧﻮﻉ ﻓﺎﻳﻞ ﻣﻲ ﺗﻮﺍﻧﺪ ﻫﺮ ﻧﻮﻉ ﺩﺍﺩﻩ ‪ ،‬ﺣﺘﻲ ﺍﻧﻮﺍﻉ ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻱ ﻧﻈﻴﺮ ﺭﻛﻮﺭﺩ ﻧﻴﺰ ﺑﺎﺷـﺪ‪.‬ﻭﻳﮋﮔـﻲ ﺩﻳﮕـﺮ‬
‫ﻓﺎﻳﻠﻬﺎﻱ ﻧﻮﻉ ﺩﺍﺭ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﻫﻤﻬﻲ ﺍﻃﻼﻋﺎﺕ ﺩﺭ ﻳﻚ ﺧﻂ ﺫﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﻋﻤﻠﻴﺎﺕ ﺧﻮﺍﻧﺪﻥ ﻭ ﻧﻮﺷﺘﻦ ﺩﺭ ﻓﺎﻳﻠﻬﺎﻱ ﻧﻮﻉ ﺩﺍﺭ ﺑﺴﻴﺎﺭ ﺳـﺮﻳﻌﺘﺮ‬
‫ﺍﺯ ﻓﺎﻳﻠﻬﺎﻱ ﻣﺘﻨﻲ ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ‪ .‬ﺯﻳﺮﺍ ﺩﺭ ﻓﺎﻳﻠﻬﺎﻱ ﻧﻮﻉ ﺩﺍﺭ ‪ ،‬ﺍﻃﻼﻋﺎﺕ ﺑﺎ ﻫﻤﺎﻥ ﺍﻟﮕﻮﻳﻲ ﻛﻪ ﺩﺭ ﺣﺎﻓﻈﻪ ﻗﺮﺍﺭ ﺩﺍﺭﻧﺪ ‪ ،‬ﺑﺪﻭﻥ ﻫﻴﭻ ﮔﻮﻧﻪ ﺗﺒـﺪﻳﻠﻲ ﺩﺭ‬
‫ﻓﺎﻳﻞ ﺫﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﺑﻌﻨﻮﺍﻥ ﻣﺜﺎﻝ ‪ ،‬ﻳﻚ ﻋﺪﺩ ﺻﺤﻴﺢ ﻧﻮﻉ ‪ Integer‬ﺩﺭ ﻫﻨﮕﺎﻡ ﺫﺧﻴﺮﻩ ﺩﺭ ﻓﺎﻳﻞ ﻧﻮﻉ ﺩﺍﺭ ‪ ،‬ﻓﻘﻂ ﺩﻭ ﺑﺎﻳﺖ ﺭﺍ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨـﺪ‬
‫ﻳﻌﻨﻲ ﺑﻪ ﻫﻤﺎﻥ ﺻﻮﺭﺕ ﻛﻪ ﺩﺭ ﺣﺎﻓﻈﻪ ﺍﺻﻠﻲ ﻗﺮﺍﺭ ﺩﺍﺭﺩ ﺍﻣﺎ ﺩﺭ ﻫﻨﮕﺎﻡ ﺫﺧﻴﺮﻩ ﺩﺭ ﻓﺎﻳﻞ ﻣﺘﻨﻲ ﺑﻪ ﺍﺯﺍﻱ ﻫﺮ ﺭﻗﻢ ﻳﻚ ﺑﺎﻳﺖ ﺭﺍ ﺍﺷﻐﺎﻝ ﻣﻲ ﻧﻤﺎﻳﺪ ﺯﻳﺮﺍ‬
‫ﻫﺮ ﺭﻗﻢ ﺁﻥ ﺑﺎﻳﺪ ﺑﻪ ﻳﻚ ﻛﺪ ﺍﺳﻜﻲ ﺗﺒﺪﻳﻞ ﺷﻮﺩ‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﻳﻚ ﺗﺎ ﺷﺶ ﺑﺎﻳﺖ ﺭﺍ ﺍﺷﻐﺎﻝ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﺭﻭﺵ ﻛﺎﺭ ﻛﺮﺩﻥ ﺑﺎ ﻓﺎﻳﻠﻬﺎﻱ ﻧﻮﻉ ﺩﺍﺭ ﻣﺎﻧﻨﺪ ﻓﺎﻳﻠﻬﺎﻱ ﻣﺘﻨﻲ ﺍﺳﺖ ﻳﻌﻨﻲ ﺑﺎﻳﺪ ﺍﺑﺘﺪﺍ ﻣﺘﻐﻴﺮﻱ ﺑﻪ ﻋﻨـﻮﺍﻥ ﺍﺷـﺎﺭﻩ ﮔـﺮ ﻓﺎﻳـﻞ ﻧـﻮﻉ ﺩﺍﺭ ﺗﻌﺮﻳـﻒ ﻭ‬
‫ﺳﭙﺲ ﺁﻧﺮﺍ ﺑﺎ ﺩﺳﺘﻮﺭ ‪ Assign‬ﺑﻪ ﻳﻚ ﻧﺎﻡ ﻓﺎﻳﻞ ﺩﺭ ﺣﺎﻓﻈﻪ ﺟﺎﻧﺒﻲ ﻧﺴﺒﺖ ﺩﻫﻴﻢ‪.‬‬
‫ﻧﻜﺘﻪ ( ﻣﻌﻤﻮﻻ ﭘﺴﻮﻧﺪ ﻓﺎﻳﻠﻬﺎﻱ ﻧﻮﻉ ﺩﺍﺭ ﺭﺍ ‪ Dat‬ﻗﺮﺍﺭ ﻣﻲ ﺩﻫﻴﻢ ﻛﻪ ﺑﺎ ﻓﺎﻳﻠﻬﺎﻱ ﻣﺘﻨﻲ ﺍﺷﺘﺒﺎﻩ ﻧﺸﻮﻧﺪ‪.‬‬
‫ﺑﻌﻨﻮﺍﻥ ﻣﺜﺎﻝ ﺑﺮﺍﻱ ﺫﺧﻴﺮﻩ ﺗﻌﺪﺍﺩﻱ ﻋﺪﺩ ﺍﻋﺸﺎﺭﻱ ﺩﺭ ﻳﻚ ﻓﺎﻳﻞ ﻧﻮﻉ ﺩﺍﺭ ﺍﺷﺎﺭﻩ ﮔﺮ ﻓﺎﻳﻞ ﺍﻳﻨﮕﻮﻧﻪ ﺧﻮﺍﻫﺪ ﺑﻮﺩ ‪:‬‬
‫‪Var‬‬
‫; ‪F : FILE OF Real‬‬
‫ﻳﺎ ﺑﺮﺍﻱ ﺫﺧﻴﺮﻩ ﻧﺎﻡ ﻭ ﻧﺎﻡ ﺧﺎﻧﻮﺍﺩﮔﻲ ﻭ ﻧﻤﺮﻩ ﺩﺍﻧﺶ ﺁﻣﻮﺯﺍﻥ ﺍﺷﺎﺭﻩ ﮔﺮ ﻓﺎﻳﻞ ﻭ ﺩﺳﺘﻮﺭ ‪ Assign‬ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ ‪:‬‬
‫‪TYPE‬‬
‫‪Student = RECORD‬‬
‫; ]‪Name : STRING[20‬‬
‫; ]‪Family : STRING[20‬‬
‫; ‪Grade : Real‬‬
‫; ‪END‬‬
‫‪VAR‬‬
‫; ‪F : FILE OF student‬‬
‫‪BEGIN‬‬
‫;) '‪Assign ( F, 'c:\school info.dat‬‬
‫‪END.‬‬
‫ﺩﺭ ﻓﺎﻳﻠﻬﺎﻱ ﻧﻮﻉ ﺩﺍﺭ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ Rewrite‬ﺑﻪ ﻣﻨﻈﻮﺭ ﺑﺎﺯ ﻛﺮﺩﻥ ﻳﺎ ﺍﻳﺠﺎﺩ ﻳﻚ ﻓﺎﻳﻞ ﺟﺪﻳﺪ ﻭ ﺧﺎﻟﻲ ﺍﺯ ﺍﻃﻼﻋﺎﺕ )ﻣﺎﻧﻨﺪ ﻓﺎﻳﻠﻬﺎﻱ ﻣﺘﻨﻲ( ﻭ ﺍﺯ‬
‫ﺩﺳﺘﻮﺭ ‪ Reset‬ﺑﻪ ﻣﻨﻈﻮﺭ ﺧﻮﺍﻧﺪﻥ ﻭ ﻳﺎ ﻧﻮﺷﺘﻦ ﺩﺭ ﻳﻚ ﻓﺎﻳﻞ ﻣﻮﺟﻮﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﺷﻮﺩ‪.‬‬
‫ﻧﻜﺘﻪ ( ﺩﺳﺘﻮﺭ ‪ Append‬ﺑﺮﺍﻱ ﻓﺎﻳﻠﻬﺎﻱ ﻧﻮﻉ ﺩﺍﺭ ﻗﺎﺑﻞ ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻲ ﺑﺎﺷﺪ‪.‬‬
‫ﭘﺲ ﺍﺯ ﺑﺎﺯ ﻛﺮﺩﻥ ﻓﺎﻳﻞ ﻧﻮﻉ ﺩﺍﺭ ‪ ،‬ﻛﻪ ﺑﺎ ﻳﻜﻲ ﺍﺯ ﺩﻭ ﺩﺳﺘﻮﺭ ‪ Rewrite‬ﻳﺎ ‪ Reset‬ﺍﻧﺠﺎﻡ ﻣﻲ ﺷﻮﺩ ﺟﻬﺖ ﻧﻮﺷـﺘﻦ ﻭ ﺧﻮﺍﻧـﺪﻥ ﺍﻃﻼﻋـﺎﺕ ﺩﺭ ﺍﻳـﻦ‬
‫ﻧﻮﻉ ﻓﺎﻳﻠﻬﺎ ﺍﺯ ﺩﺳﺘﻮﺭﺍﺕ ‪ Write‬ﻭ ‪ Read‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﮔﺮﺩﺩ‪ .‬ﻭﺩﺭ ﻧﻬﺎﻳﺖ ﺑﺮﺍﻱ ﺑﺴﺘﻦ ﻓﺎﻳﻞ ﻧﻴﺰ ‪ ،‬ﺍﺯ ‪ Close‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﻧﻜﺘﻪ ( ﺩﺭ ﻓﺎﻳﻠﻬﺎﻱ ﻧﻮﻉ ﺩﺍﺭ ﻧﻤﻲ ﺗﻮﺍﻧﻴﻢ ﺍﺯ ﺩﺳﺘﻮﺭﺍﺕ ‪ Readln‬ﻭ ‪ Writeln‬ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﻢ‪.‬‬

‫ﻣﮑﺎن ﻧﻤﺎي ﻓﺎﯾﻞ ‪:‬‬

‫ﺩﺭ ﻫﺮ ﻟﺤﻈﻪ ﺗﻨﻬﺎ ﻳﻜﻲ ﺍﺯ ﺭﻛﻮﺭﺩﻫﺎﻱ ﻓﺎﻳﻞ ﻧﻮﻉ ﺩﺍﺭ ﻗﺎﺑﻞ ﺩﺳﺘﻴﺎﺑﻲ ﺍﺳﺖ‪ .‬ﻫﻨﮕﺎﻣﻴﻜﻪ ﻳﻚ ﻓﺎﻳﻞ ﺭﺍ ﺑﺎﺯ ﻣﻲ ﻛﻨﻴﻢ ﺍﻭﻟﻴﻦ ﺭﻛـﻮﺭﺩ ﻭ ﺑـﺎ ﺍﺟـﺮﺍﻱ ﻫـﺮ‬
‫ﺩﺳﺘﻮﺭ ‪ Read‬ﻳﺎ ‪ ، Write‬ﺭﻛﻮﺭﺩ ﺑﻌﺪﻱ ﻗﺎﺑﻞ ﺩﺳﺘﺮﺳﻲ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪ .‬ﺑﺮﺍﻱ ﻣـﺸﺨﺺ ﺷـﺪﻥ ﺍﻳـﻦ ﻛـﻪ ﺩﺭ ﺣـﺎﻝ ﺣﺎﺿـﺮ ﻛـﺪﺍﻡ ﺭﻛـﻮﺭﺩ ﻗﺎﺑـﻞ‬
‫ﺩﺳﺘﻴﺎﺑﻲ ﺍﺳﺖ ﺷﻤﺎﺭﻩ ﺭﻛﻮﺭﺩ ﻣﺰﺑﻮﺭ ﺩﺭ ﺩﺍﺧﻞ ﻣﺘﻐﻴﺮﻱ ﺑﻨﺎﻡ ﻣﻜﺎﻥ ﻧﻤﺎﻱ ﻓﺎﻳﻞ ﻛﻪ ﻓﻴﻠﺪﻱ ﺍﺯ ﻣﺘﻐﻴﺮ ﻓﺎﻳﻞ ﺍﺳﺖ ﻧﮕـﻪ ﺩﺍﺭﻱ ﻣﻴﮕـﺮﺩﺩ‪ .‬ﺑـﺎ ﺍﺟـﺮﺍﻱ‬
‫ﺩﺳﺘﻮﺭ ‪ Reset‬ﻳﺎ ‪ Rewrite‬ﺩﺭ ﻣﻜﺎﻥ ﻧﻤﺎﻱ ﻓﺎﻳﻞ ﻋﺪﺩ ﺻﻔﺮ ﻗﺮﺍﺭ ﻣﻴﮕﻴﺮﺩ ﻭ ﺍﺟﺮﺍﻱ ﺩﺳـﺘﻮﺭﺍﺕ ‪ Read‬ﻳـﺎ ‪ Write‬ﺳـﺒﺐ ﺍﻓـﺰﺍﻳﺶ ﻣﻘـﺪﺍﺭ‬
‫ﻣﻜﺎﻥ ﻧﻤﺎﻱ ﻓﺎﻳﻞ ﻧﻴﺰ ﻣﻲ ﺷﻮﺩ ﻛﻪ ﺍﺻﻄﻼﺣﺎ ﮔﻔﺘﻪ ﻣﻲ ﺷﻮﺩ ﻣﻜﺎﻥ ﻧﻤﺎﻱ ﻓﺎﻳﻞ ﺟﻠﻮ ﻣﻲ ﺭﻭﺩ‪.‬‬
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪110‬‬
‫ﺑﺮﺍﻱ ﺍﻳﻨﻜﻪ ﺑﺘﻮﺍﻥ ﻳﻚ ﺭﻛﻮﺭﺩ ﺩﻟﺨﻮﺍﻩ ﺍﺯ ﻓﺎﻳﻞ ﻧﻮﻉ ﺩﺍﺭ ﺭﺍ ﭘﺮﺩﺍﺯﺵ ﻛﺮﺩ ﻻﺯﻡ ﺍﺳﺖ ﻣﻜﺎﻥ ﻧﻤﺎﻱ ﻓﺎﻳﻞ ﺭﺍ ﺑﻪ ﺍﺑﺘﺪﺍﻱ ﺭﻛﻮﺭﺩ ﺩﻟﺨﻮﺍﻩ ﺑﺒﺮﻳﻢ ؛ ﺑﺮﺍﻱ‬
‫ﺍﻳﻨﻜﺎﺭ ﺍﺯ ﭘﺮﺩﺍﺯﻩ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ‪ Seek‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ ‪:‬‬
‫; ) ‪Seek ( f , n‬‬
‫ﻣﻨﻈﻮﺭ ﺍﺯ ‪ f‬ﻣﻜﺎﻥ ﻧﻤﺎﻱ ﻓﺎﻳﻞ ﺍﺳﺖ ﻭ ‪ n‬ﺷﻤﺎﺭﻩ ﺭﻛﻮﺭﺩ ﻣﻮﺭﺩ ﻧﻈﺮ ﺍﺳﺖ‪ .‬ﺷﻤﺎﺭﻩ ﺍﻭﻟﻴﻦ ﺭﻛﻮﺭﺩ ﺻﻔـﺮ ﺍﺳﺖ‪.‬‬
‫ﻣﺜﺎﻝ ( ﺩﺳﺘﻮﺭﺍﺕ ﻻﺯﻡ ﺑﺮﺍﻱ ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﻋﻨﺼﺮ ﺩﻫﻢ ﻓﺎﻳﻞ ‪ school info.dat‬ﺭﺍ ﺑﻨﻮﻳﺴﻴﺪ ‪:‬‬
‫; ) '‪Assign (f , 'c:\school info.dat‬‬
‫; )‪Reset (f‬‬
‫;) ‪Seek ( f , 9‬‬
‫ﻧﻜﺘﻪ ( ﺑﺮﺍﻱ ﺍﻃﻼﻉ ﺍﺯ ﺗﻌﺪﺍﺩ ﺭﻛﻮﺭﺩ ﻫﺎ ﻳﺎ ﺗﻌﺪﺍﺩ ﻋﻨﺎﺻﺮ ﻳﻚ ﻓﺎﻳﻞ ﻧﻮﻉ ﺩﺍﺭ ﺍﺯ ﺗﺎﺑﻊ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ‪ FileSize‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﻣﺜﺎﻝ ( ﺩﺳﺘﻮﺭﺍﺕ ﻻﺯﻡ ﺑﺮﺍﻱ ﺩﺳﺘﺮﺳﻲ ﺑﻪ ﺁﺧﺮﻳﻦ ﻋﻨﺼﺮ ﻓﺎﻳﻞ ‪ school info.dat‬ﺭﺍ ﺑﻨﻮﻳﺴﻴﺪ ‪:‬‬
‫; ) '‪Assign (f , 'c:\school info.dat‬‬
‫; )‪Reset (f‬‬
‫;) ‪Seek ( f , FileSize (f) - 1‬‬
‫ﻣﺜﺎﻝ ( ﺩﺳﺘﻮﺭﺍﺕ ﻻﺯﻡ ﺑﺮﺍﻱ ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ ﻳﻚ ﻋﻨﺼﺮ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﻓﺎﻳﻞ ‪ school info.dat‬ﺭﺍ ﺑﻨﻮﻳﺴﻴﺪ ‪:‬‬
‫; ) '‪Assign (f , 'c:\school info.dat‬‬
‫; )‪Reset (f‬‬
‫;) )‪Seek ( f , FileSize (f‬‬
‫ﺑﺮﺍﻱ ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ ﻳﻚ ﻋﻨﺼﺮ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﻓﺎﻳﻞ ‪ ،‬ﻛﺎﻓﻲ ﺍﺳﺖ ﻣﻜﺎﻥ ﻧﻤﺎﻱ ﻓﺎﻳﻞ ﺭﺍ ﺑﻌﺪ ﺍﺯ ﺁﺧﺮﻳﻦ ﻋﻨﺼﺮ ﻗﺮﺍﺭ ﺩﻫﻴﻢ ﻭ ﺳﭙﺲ ﺩﺳـﺘﻮﺭ‬
‫‪ Write‬ﺭﺍ ﺍﺟﺮﺍ ﻛﻨﻴﻢ‪.‬‬
‫ﻧﻜﺘﻪ ( ﺍﮔﺮ ﺑﺎ ﺩﺳﺘﻮﺭ ‪ seek‬ﺍﺷﺎﺭﻩ ﮔﺮ ﻓﺎﻳﻞ ﺭﺍ ﺍﺯ ﻣﺤﺪﻭﺩﻩ ﻓﺎﻳﻞ ﺧﺎﺭﺝ ﮐﻨﻴﻢ ﭘﻴﻐﺎﻡ ﺧﻄﺎﻱ ﺷﻤﺎﺭﻩ ‪ ۱۰۰‬ﻳﻌﻨﻲ ‪ disk read error‬ﺻﺎﺩﺭ‬
‫ﻣﻲ ﺷﻮﺩ‪.‬‬
‫‪Seek (f, filesize(f) +1) ž‬‬ ‫ﻏﻠﻂ‬
‫ﻏﻠﻂ ‪Seek (f,-1) ž‬‬

‫ﻧﻜﺘﻪ ( ﺗﺎﺑﻊ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ‪ filepos‬ﺷﻤﺎﺭﻩ ﺭﮐﻮﺭﺩ ﺟﺎﺭﻱ ﺭﺍ ﺑﺮ ﻣﻲ ﮔﺮﺩﺍﻧﺪ‪.‬‬

‫;)‪Reset(f‬‬
‫‪Write(filepos(f)); ž 0‬‬
‫;)‪Read(f,a‬‬
‫‪Write(filepos(f)); ž 1‬‬
‫ﻣﺜﺎﻝ ‪ ( ۴‬ﺑﺎ ﻓﺮﺽ ﻭﺟﻮﺩ ﻳﻚ ﻓﺎﻳﻞ ﻧﻮﻉ ﺩﺍﺭ ﺍﺯ ﻧﻮﻉ ‪ Integer‬ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ‪:‬‬
‫ﺍﻟﻒ ( ﻳﻚ ﻋﺪﺩ ﺑﻪ ﺍﻧﺘﻬﺎﻱ ﻓﺎﻳﻞ ﺍﺿﺎﻓﻪ ﻛﻨﺪ ‪.‬‬
‫ﺏ ( ﺍﻋﺪﺍﺩ ﺭﺍ ﺍﺯ ﺁﺧﺮ ﺑﻪ ﺍﻭﻝ ﺩﺭ ﻣﺎﻧﻴﺘﻮﺭ ﭼﺎﭖ ﻛﻨﺪ ‪.‬‬
‫‪Var‬‬
‫; ‪F: file of integer‬‬
‫; ‪n , i , x : integer‬‬
‫‪Begin‬‬
‫; ) '‪Assign ( F, 'c:\mydigit.dat‬‬
‫; )‪Rest (f‬‬
‫;) )‪Seek (f , filesize(f‬‬
‫;)‪Readln (x‬‬
‫;) ‪Write (f , x‬‬
‫;)‪Close (f‬‬
 111 ‫( – ﺻﻔﺤـﻪ‬mohammadi.mm@gmail.com) ‫ـﺪي‬‫ ﻣﻬﻨـﺪس ﻣﺤﻤ‬-1388 ‫ ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد‬- ‫ﭘﺎﺳـﮑﺎل‬
{‫} ﻗﺴﻤﺖ ﺏ ﺑﺮﻧﺎﻣﻪ‬
Reset (f) ;
n:= filesize(f) ;
for i:= n – 1 downto 0 do
begin
seek ( f , i ) ;
read ( f , x ) ;
writeln (x) ;
end ;
close(f) ;
End .

‫)ﭘﺎﻳﺎﻥ ﺑﺨﺶ ﺩﺍﺩﻫـﺎ )ﺁﺧـﺮﻳﻦ ﻋـﺪﺩ ﻭﺭﻭﺩﻱ( ﻋـﺪﺩ‬.‫ ( ﺑﺮﻧﺎﻣﻪ ﺍﻱ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺗﻌﺪﺍﺩﻱ ﻋﺪﺩ ﺍﺯ ﻛﺎﺭﺑﺮ ﺩﺭﻳﺎﻓﺖ ﻛﻨﺪ ﻭ ﺁﻧﺮﺍ ﺩﺭ ﻓﺎﻳﻞ ﺑﺮﻳﺰﺩ‬۵ ‫ﻣﺜﺎﻝ‬
‫ ﺑﺮﻳﺰﺩ ﻭ ﻫﻤﭽﻨﻴﻦ ﺗﻌـﺪﺍﺩ‬S ‫ ﺍﻋﺪﺍﺩ ﻣﻮﺟﻮﺩ ﺩﺭ ﻓﺎﻳﻞ ﺭﺍ ﺑﺎ ﻫﻢ ﺟﻤﻊ ﻛﻨﺪ ﻭ ﺩﺭ ﻣﺘﻐﻴﺮﻱ ﺑﻨﺎﻡ‬Sum ‫ﻫﻤﭽﻨﻴﻦ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﭘﺮﻭﺳﻴﺠﺮ‬.(‫ﺻﻔﺮ ﺍﺳﺖ‬
.‫ ﺭﺍ ﺩﺭ ﻣﺎﻧﻴﺘﻮﺭ ﭼﺎﭖ ﻛﻨﺪ‬I ‫ ﻭ‬S ‫ ﺑﺮﻳﺰﺩ ﻭ ﺳﭙﺲ‬I ‫ﺍﻋﺪﺍﺩ ﺭﺍ ﺩﺭ ﻣﺘﻐﻴﺮﻱ ﺑﻨﺎﻡ‬

Var
F: file of integer ; X: integer ;
Procedure Sum ;
Var
s , i , x : integer ;
Begin
Assign ( F, 'c:\mydigit.dat' ) ;
Reset (f) ;
s:= 0 ; i:= 0 ;
while not eof(f) do
begin
read( f , x ) ;
s:= s + x ; i := i + 1 ;
end ;
close (f) ;
writeln ( s ) ; writeln ( i ) ;
end;
Begin
Assign ( F, 'c:\mydigit.dat' ) ;
Rewrite (f) ;
Repeat
Read (x) ;
Write (f , x) ;
Until x = 0 ;
Close (f) ;
Sum ;
End.
 ‫ﭘﺎﺳـﮑﺎل ‪ -‬ﻧﺴﺨﻪ آزﻣﺎﯾﺸﯽ – ﺧﺮداد ‪ -1388‬ﻣﻬﻨـﺪس ﻣﺤﻤ‪‬ـﺪي )‪ – (mohammadi.mm@gmail.com‬ﺻﻔﺤـﻪ ‪112‬‬
‫ﻓﺎﻳﻞ ﺑﺪﻭﻥ ﻧـﻮﻉ‪:‬‬
‫ﻓﺎﻳﻞ ﺑﺪﻭﻥ ﻧﻮﻉ ﻓﺎﻳﻠﻲ ﺍﺳﺖ ﮐﻪ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺍﺟﺎﺯﻩ ﻣﻲ ﺩﻫﺪ ﺩﺭ ﻣﻮﺭﺩ ﺩﺍﺩﻩ ﻫﺎﻱ ﺩﺭﻭﻥ ﻓﺎﻳﻞ ﻫﺮﮔﻮﻧﻪ ﺗﻔﺴﻴﺮ ﺩﻟﺨﻮﺍﻫﻲ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‬
‫ﺩﺭ ﺍﻳﻦ ﻧﻮﻉ ﻓﺎﻳﻞ ﻫﺎ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ ﺗﻮﺍﻧﺪ ﺑﺎ ﻳﮏ ﺩﺳﺘﻮﺭ ﺧﻮﺍﻧﺪﻥ ﻭ ﻧﻮﺷﺘﻦ ﺣﺠﻢ ﺩﻟﺨﻮﺍﻫﻲ ﺍﺯ ﺩﺍﺩﻩ ﻫﺎ ﺭﺍ ﺑﺨﻮﺍﻧﺪ ﻳﺎ ﺑﻨﻮﻳﺴﺪ‪ .‬ﺍﻳـﻦ ﻧـﻮﻉ ﻓﺎﻳـﻞ‬
‫ﺍﻧﻌﻄﺎﻑ ﺯﻳﺎﺩ ﻭﺳﺮﻋﺖ ﺑﺴﻴﺎﺭ ﺑﺎﻻﻳﻲ ﺩﺍﺭﺩ‪.‬‬

‫ﻧﺤﻮﻩ ﺗﻌـﺮﻳﻒ ﺍﺷﺎﺭﻩ ﮔﺮ ﻓﺎﻳﻞ‪:‬‬

‫‪Var‬‬
‫; ‪F : file‬‬
‫ﺑﻌﺪ ﺍﺯ ﻛﻠﻤﻪ ‪ ، file‬ﻧﻮﻉ ﺩﺍﺩﻩ ﺍﻱ ﻧﺒﺎﻳﺪ ﻣﻌﻴﻦ ﮔﺮﺩﺩ‪.‬‬
‫ﺑﺎ ﺩﺳﺘﻮﺭ ‪ assign‬ﺍﺷﺎﺭﻩ ﮔﺮ ﻓﺎﻳﻞ ﺭﺍ ﻧﺴﺒﺖ ﻣﻲ ﺩﻫﻴﻢ‪.‬‬
‫ﺑﺮﺍﻱ ﺑﺎﺯ ﮐﺮﺩﻥ ﻓﺎﻳﻞ ﺑﺪﻭﻥ ﻧﻮﻉ ﺍﺯ ﺩﻭ ﭘﺮﺩﺍﺯﻩ ‪ rewrite‬ﻭ ‪ reset‬ﻣﺎﻧﻨﺪ ﻓﺎﻳﻞ ﻫﺎﻱ ﻧﻮﻉ ﺩﺍﺭ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩﻩ ﺑﺎ ﺍﻳﻦ ﺗﻔـﺎﻭﺕ ﻛـﻪ ﭘـﺎﺭﺍﻣﺘﺮ ﺩﻳﮕـﺮﻱ‬
‫ﺑﻌﻨﻮﺍﻥ ﺍﻧﺪﺍﺯﻩ ﻱ ﺩﺍﺩﻩ ﺑﺎﻳﺪ ﺫﻛﺮ ﻛﻨﻴﻢ‪.‬‬

‫ﺩﺳﺘﻮﺭ ;)‪ reset(f,10‬ﻓﺎﻳﻞ ‪ f‬ﺭﺍ ﺑﺮﺍﻱ ﺧﻮﺍﻧﺪﻥ ﻭﻧﻮﺷﺘﻦ ﺑﺎﺯ ﻣﻲ ﮐﻨﺪ ﺑﺎ ﺍﻳﻦ ﻓﺮﺽ ﮐﻪ ﻓﺎﻳﻞ ﻣﺰﺑﻮﺭ ﺍﺯ ﺩﺍﺩﻩ ﻫﺎﻳﻲ ﺑﻪ ﺍﻧﺪﺍﺯﻩ ‪ ۱۰‬ﺑﺎﻳﺖ ﺗـﺸﻜﻴﻞ‬
‫ﺷﺪﻩ ﺍﺳﺖ‪.‬‬
‫ﺩﺳﺘﻮﺭ ;)‪ rewrite(f,1‬ﻓﺎﻳﻞ ﺟﺪﻳﺪﻱ ﺍﻳﺠﺎﺩ ﻣﻲ ﮐﻨﺪ ﮐﻪ ﻫﺮ ﺩﺍﺩﻩ ﺍﻱ ﮐﻪ ﺩﺍﺧﻞ ﺁﻥ ﻣﻲ ﺭﻳﺰﻳﻢ ‪ ۱‬ﺑﺎﻳﺖ ﻓﻀﺎ ﺍﺷﻐﺎﻝ ﻣﻲ ﮐﻨﺪ‪.‬‬

‫ﻧﺤﻮﻩ ﺧﻮﺍﻧﺪﻥ ﻭ ﻧﻮﺷﺘﻦ ﺩﺭ ﻓﺎﻳﻞ ﺑﺪﻭﻥ ﻧـﻮﻉ ‪:‬‬

‫ﺑﺮﺍﻱ ﻧﻮﺷﺘﻦ ﻭ ﺧﻮﺍﻧﺪﻥ ﺩﺭ ﻓﺎﻳﻠﻬﺎﻱ ﺑﺪﻭﻥ ﻧﻮﻉ ﺍﺯ ﺩﺳﺘﻮﺭﻫﺎﻱ ‪ BlockWrite‬ﻭ ‪ BlockRead‬ﺑﺎ ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻳﻲ ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺘﻔﺎﺩﻩ‬
‫ﻣﻲ ﺷﻮﺩ ‪:‬‬
‫; ) ‪BlockWrite ( F , B , N , W‬‬
‫; ) ‪BlockRead ( F , B , N , R‬‬
‫ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﺩﺳﺘـﻮﺭ ‪: BlockWrite‬‬
‫‪ :F‬ﺍﺷﺎﺭﻩ ﮔﺮ ﻓﺎﻳﻞ‬
‫‪ :B‬ﺑﺎﻓﺮ ﮐﻪ ﻣﻌﻤﻮﻻ ﺁﺭﺍﻳﻪ ﺍﻱ ﺍﺯ ﻧﻮﻉ ‪ char‬ﺍﺳﺖ‪.‬‬
‫‪ :N‬ﻳﮏ ﻋﺪﺩ ﺻﺤﻴﺢ ﺍﺳﺖ ﮐﻪ ﻧﺸﺎﻥ ﺩﻫﻨﺪﻩ ﺗﻌﺪﺍﺩ ﺩﺍﺩﻩ ﻫﺎﻳﻲ ﺍﺳﺖ ﮐﻪ ﻗﺮﺍﺭ ﺍﺳﺖ ﺍﺯ ﺑﺎﻓﺮ )‪ (B‬ﺩﺭ ﻓﺎﻳﻞ ﺭﻳﺨﺘﻪ ﺷﻮﺩ‪.‬‬
‫‪ :W‬ﻣﺘﻐﻴﺮﻱ ﺻﺤﻴﺢ ﺍﺳﺖ ﮐﻪ ﺑﻌﺪ ﺍﺯ ﻋﻤﻠﻴﺎﺕ ﻧﻮﺷﺘﻦ ﺩﺭ ﻓﺎﻳﻞ ﻣﺸﺨﺺ ﻣﻴﮑﻨﺪ ﭼﻪ ﻣﻘﺪﺍﺭ ﺍﺯ ﺩﺍﺩﻩ ﻫﺎ ﺑﺎ ﻣﻮﻓﻘﻴﺖ ﺩﺭﻓﺎﻳﻞ ﺭﻳﺨﺘﻪ ﺷﺪﻩ ﺍﻧﺪ‪.‬‬
‫‪ -‬ﺍﮔﺮ ﺑﻌﺪ ﺍﺯ ﺍﺟﺮﺍﻱ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ‪ N=W‬ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﻫﻤﻪ ﺩﺍﺩﻩ ﻫﺎ ﺑﺎ ﻣﻮﻓﻘﻴﺖ ﺩﺭ ﻓﺎﻳﻞ ﺭﻳﺨﺘﻪ ﺷﺪﻩ ﺍﻧﺪ‪.‬‬
‫ﭘﺎﺭﺍﻣﺘﺮﻫﺎﻱ ﺩﺳﺘـﻮﺭ ‪: BlockRead‬‬
‫‪ :F‬ﺍﺷﺎﺭﻩ ﮔﺮ ﻓﺎﻳﻞ‬
‫‪ :B‬ﺑﺎﻓﺮ ﮐﻪ ﻣﻌﻤﻮﻻ ﺁﺭﺍﻳﻪ ﺍﻱ ﺍﺯ ﻧﻮﻉ ‪ char‬ﺍﺳﺖ‪.‬‬
‫‪ :N‬ﻳﮏ ﻋﺪﺩ ﺻﺤﻴﺢ ﺍﺳﺖ ﮐﻪ ﻧﺸﺎﻥ ﺩﻫﻨﺪﻩ ﺗﻌﺪﺍﺩ ﺩﺍﺩﻩ ﻫﺎﻳﻲ ﺍﺳﺖ ﮐﻪ ﻗﺮﺍﺭ ﺍﺳﺖ ﺍﺯ ﻓﺎﻳﻞ ﺧﻮﺍﻧﺪﻩ ﻭ ﺩﺭﺑﺎﻓﺮ )‪ (B‬ﺭﻳﺨﺘﻪ ﺷﻮﺩ‪.‬‬
‫‪ :R‬ﻣﺘﻐﻴﺮﻱ ﺻﺤﻴﺢ ﺍﺳﺖ ﮐﻪ ﺑﻌﺪ ﺍﺯﻋﻤﻠﻴﺎﺕ ﺧﻮﺍﻧﺪﻥ ﺍﺯ ﻓﺎﻳﻞ ﻣﺸﺨﺺ ﻣﻲ ﮐﻨﺪ ﭼﻪ ﻣﻘﺪﺍﺭ ﺍﺯ ﺩﺍﺩﻩ ﻫﺎ ﺑﺎ ﻣﻮﻓﻘﻴﺖ ﺍﺯﻓﺎﻳﻞ ﺧﻮﺍﻧﺪﻩ ﺷﺪﻩ ﺍﻧﺪ‪.‬‬
‫‪ -‬ﺍﮔﺮ ﺑﻌﺪ ﺍﺯ ﺍﺟﺮﺍﻱ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ‪ N=R‬ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﻫﻤﻪ ﺩﺍﺩﻩ ﻫﺎ ﺧﻮﺍﻧﺪﻩ ﺷﺪﻩ ﺍﺳﺖ ﻭﺍﮔﺮ ‪ R<N‬ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﺑﻪ ﺍﻧﺘﻬـﺎﻱ ﻓﺎﻳـﻞ ﺭﺳـﻴﺪﻩ‬
‫ﺍﻳﻢ‪.‬‬

‫ﺑﺎ ﺩﺳﺘﻮﺭ ‪ Close‬ﻓﺎﻳﻞ ﺑﺴﺘﻪ ﺧﻮﺍﻫﺪ ﺷﺪ‪.‬‬

‫ﻣﻌﻤﻮﻻ ﻓﺎﻳﻞ ﻫﺎﻱ ﺑﺪﻭﻥ ﻧﻮﻉ ﺟﻬﺖ ﮐﭙﻲ ﺑﺮﺩﺍﺭﻱ ﻳﺎ ﺍﻳﺠﺎﺩ ﻧﺴﺨﻪ ﭘﺸﺘﻴﺒﺎﻥ ﺍﺯ ﻓﺎﻳﻞ ﺑﻪ ﮐﺎﺭ ﻣﻲ ﺭﻭﺩ‪.‬‬