ഡാറ്റാ എൻട്രി ഓപ്പറേറ്റർമാർ. പാസ്കലിൽ ഡാറ്റ ഇൻപുട്ടും ഔട്ട്പുട്ടും എങ്ങനെയാണ് ഇൻപുട്ട് സ്റ്റേറ്റ്മെൻ്റ് എഴുതുന്നത്

ലക്ഷ്യ ലബോറട്ടറി എ മടുപ്പിക്കുന്ന ജോലി: ഇനിപ്പറയുന്ന സ്റ്റാൻഡേർഡ് ഡാറ്റ തരങ്ങൾ ഉപയോഗിച്ച് വേരിയബിളുകൾ ശരിയായി വിവരിക്കാൻ പഠിക്കുക: പൂർണ്ണസംഖ്യ. യഥാർത്ഥവും യുക്തിസഹവും; ഡാറ്റ ഇൻപുട്ട്/ഔട്ട്‌പുട്ട് ഓപ്പറേറ്റർമാരെ പഠിക്കുക, പാസ്കൽ എബിസി സിസ്റ്റത്തിൽ പ്രവർത്തിക്കാനുള്ള പ്രായോഗിക കഴിവുകൾ വികസിപ്പിക്കുക, ഒരു കമ്പ്യൂട്ടറിൽ പ്രവേശിക്കുക, ഡയലോഗ് മോഡിൽ പാസ്കൽ ഭാഷയിൽ ലളിതമായ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാനും ശരിയാക്കാനും പഠിക്കുക, എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ പിശകുകളെക്കുറിച്ചുള്ള കംപൈലറുടെ ഡയഗ്നോസ്റ്റിക് സന്ദേശങ്ങൾ പരിചയപ്പെടുക. ലീനിയർ അൽഗോരിതം നടപ്പിലാക്കുന്ന പ്രോഗ്രാമുകൾ.

പ്രവർത്തന പദങ്ങൾ, ഐഡൻ്റിഫയറുകൾ, ചില പ്രവർത്തനങ്ങൾ ചെയ്യുന്ന പ്രത്യേക പ്രതീകങ്ങൾ എന്നിവയുടെ ഒരു പ്രത്യേക കൂട്ടമാണ് ഓപ്പറേറ്റർ. ";" എന്ന അർദ്ധവിരാമത്താൽ ഓപ്പറേറ്റർമാരെ പരസ്പരം വേർതിരിക്കുന്നു. ഓപ്പറേറ്റർമാരുടെ ഉദാഹരണങ്ങൾ.

അസൈൻമെൻ്റ് ഓപ്പറേറ്റർ: (:=). വേരിയബിളുകൾക്ക് മൂല്യങ്ങൾ നൽകുന്നതിന് അസൈൻമെൻ്റ് ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നു, ഉദാഹരണത്തിന്: x:=1; a:=5. 02; b:= 32*a+Sin(x); എസ്:= "ഇവാൻ ഇവാനോവിച്ച്."

കോമ്പൗണ്ട് ഓപ്പറേറ്റർ: ആരംഭിക്കുക<операторы>അവസാനിക്കുന്നു;

മറ്റ് ഓപ്പറേറ്റർമാരെ അതിൻ്റെ ബോഡിയിലേക്ക് എഴുതാൻ ഒരു കോമ്പൗണ്ട് ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നു, അതിൻ്റെ ക്രമം ഈ സാഹചര്യത്തിൽ ഒരു ഓപ്പറേറ്ററായി കണക്കാക്കപ്പെടുന്നു. ഈ പ്രസ്താവന പ്രധാന പ്രോഗ്രാമിൻ്റെ, സബ്റൂട്ടിൻ്റെ അല്ലെങ്കിൽ ഫംഗ്ഷൻ്റെ എക്സിക്യൂഷൻ വിഭാഗം ആരംഭിക്കുകയും അവസാനിപ്പിക്കുകയും ചെയ്യുന്നു. പ്രധാന പ്രോഗ്രാമിൻ്റെ അവസാന END പ്രസ്താവനയ്ക്ക് ശേഷം ഒരു കാലയളവ് ഉണ്ട്.

1. ഡാറ്റ ഇൻപുട്ട്/ഔട്ട്പുട്ട് ഓപ്പറേറ്റർമാർ

I/O പ്രവർത്തനങ്ങൾ നടത്താൻ നാല് ഓപ്പറേറ്റർമാർ ഉപയോഗിക്കുന്നു:

വായിക്കുക, വായിക്കുക, എഴുതുക, എഴുതുക. റീഡ് ഓപ്പറേറ്റർ സംഖ്യാ ഡാറ്റ, പ്രതീകങ്ങൾ, സ്ട്രിംഗുകൾ മുതലായവയുടെ ഇൻപുട്ട് നൽകുന്നു. പ്രോഗ്രാം വഴി അവരുടെ തുടർന്നുള്ള പ്രോസസ്സിംഗിനായി.

ഫോർമാറ്റ്: റീഡ്(X1, X2, .. , Xn), ഇവിടെ X1, X2, .. , Xn സാധുവായ ഡാറ്റാ തരങ്ങളുടെ വേരിയബിളുകളാണ്.

X1, X2, .., Xn എന്നീ മൂല്യങ്ങൾ ഉപയോക്താവ് കീബോർഡിൽ കുറഞ്ഞത് ഒരു ഇടമെങ്കിലും നൽകുകയും സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു. ഭാഷാ വാക്യഘടനയ്ക്ക് അനുസൃതമായി വേരിയബിൾ മൂല്യങ്ങൾ നൽകണം. പ്രോഗ്രാമിന് നിരവധി റീഡ് ഓപ്പറേറ്റർമാരുണ്ടെങ്കിൽ, അവയ്ക്കുള്ള ഡാറ്റ ഒരു സ്ട്രീമിൽ നൽകിയിട്ടുണ്ട്, അതായത്, ഒരു റീഡ് ഓപ്പറേറ്ററിനായുള്ള വേരിയബിൾ മൂല്യങ്ങൾ വായിച്ചതിനുശേഷം, അടുത്ത റീഡ് ഓപ്പറേറ്ററിനായുള്ള ഡാറ്റ മുമ്പത്തേതിൻ്റെ അതേ വരിയിൽ ടൈപ്പ് ചെയ്യുന്നു. വരിയുടെ അവസാനം വരെ, അടുത്ത വരിയിലേക്കുള്ള മാറ്റം സംഭവിക്കുന്നു. ReadLn റീഡ് ഓപ്പറേറ്റർ റീഡ് ഓപ്പറേറ്ററുമായി സാമ്യമുള്ളതാണ്, ഒരേയൊരു വ്യത്യാസം ഒരു ReadLn ഓപ്പറേറ്ററിനായുള്ള ലിസ്റ്റിലെ അവസാന മൂല്യം വായിച്ചതിനുശേഷം, അടുത്ത ReadLn ഓപ്പറേറ്ററിനായുള്ള ഡാറ്റ ഒരു പുതിയ വരിയുടെ തുടക്കം മുതൽ വായിക്കപ്പെടും.

റൈറ്റ് ഓപ്പറേറ്റർ ഡാറ്റ ഔട്ട്പുട്ട് നിർമ്മിക്കുന്നു.

ഫോർമാറ്റ്: എഴുതുക(X1, X2, .. , Xn), ഇവിടെ X1, X2, .. , Xn എന്നത് പൂർണ്ണസംഖ്യ, ബൈറ്റ്, റിയൽ, ചാർ, ബൂളിയൻ മുതലായവ പോലുള്ള പദപ്രയോഗങ്ങളാണ്.

ഉദാഹരണം: എഴുതുക(125); (പ്രകടനം മൂല്യത്താൽ പ്രതിനിധീകരിക്കുന്നു)എഴുതുക(A+B-C); (പ്രകടനത്തിൻ്റെ ഫലം പ്രദർശിപ്പിച്ചിരിക്കുന്നു).

ഇനിപ്പറയുന്ന രീതിയിൽ വേരിയബിൾ മൂല്യങ്ങൾ പ്രദർശിപ്പിക്കാൻ റൈറ്റ് സ്റ്റേറ്റ്മെൻ്റ് നിങ്ങളെ അനുവദിക്കുന്നു.

കഴ്‌സർ പൊസിഷൻ (I) മുതൽ ആരംഭിക്കുന്ന മൂല്യം I യുടെ ദശാംശ പ്രാതിനിധ്യത്തിൻ്റെ ഔട്ട്‌പുട്ട്:

വീതി p (I:p) ഫീൽഡിൻ്റെ വലത് സ്ഥാനങ്ങളിലേക്ക് മൂല്യം I യുടെ ദശാംശ പ്രാതിനിധ്യത്തിൻ്റെ ഔട്ട്പുട്ട്:

എവിടെ ַ ഒരു സ്പേസ് ആണ്.

3. വീതി p ഉള്ള ഫീൽഡിൻ്റെ അങ്ങേയറ്റത്തെ വലത് സ്ഥാനങ്ങളിലേക്ക് മൂല്യം I യുടെ ദശാംശ പ്രാതിനിധ്യത്തിൻ്റെ ഔട്ട്‌പുട്ട്, വീതി q ഉള്ള സംഖ്യയുടെ ഫ്രാക്ഷണൽ ഭാഗം (I:p:q):

WriteLn സ്റ്റേറ്റ്‌മെൻ്റ്, Write Statement-ന് സമാനമാണ്, എന്നാൽ നിലവിലെ WriteLn സ്റ്റേറ്റ്‌മെൻ്റിൻ്റെ ലിസ്റ്റിലെ അവസാന മൂല്യം അച്ചടിച്ച ശേഷം, കഴ്‌സർ അടുത്ത വരിയുടെ തുടക്കത്തിലേക്ക് നീങ്ങുന്നു. പാരാമീറ്ററുകൾ ഇല്ലാതെ എഴുതിയ WriteLn പ്രസ്താവന ഒരു ലൈൻ ഫീഡിന് കാരണമാകുന്നു.

പ്രദർശിപ്പിക്കുന്നതിന് മതിയായ സ്ഥാനങ്ങൾ ഇല്ലെങ്കിൽ, നമ്പറോ വാചകമോ പൂർണ്ണമായി പ്രദർശിപ്പിക്കും, കൂടാതെ സംഖ്യയുടെ ഫ്രാക്ഷണൽ ഭാഗം പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഫോർമാറ്റ് ഒഴികെ ഫോർമാറ്റ് അവഗണിക്കപ്പെടും. ഔട്ട്പുട്ട് ഫോർമാറ്റ് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, പൂർണ്ണസംഖ്യയുടെയും സ്ട്രിംഗ് വേരിയബിളുകളുടെയും മൂല്യങ്ങൾ പൂർണ്ണമായി ഔട്ട്പുട്ട് ചെയ്യുന്നു, കൂടാതെ യഥാർത്ഥമായവ - വേരിയബിളിൻ്റെ തരവുമായി ബന്ധപ്പെട്ട അക്കങ്ങളുടെ എണ്ണം ഉപയോഗിച്ച്, ഉദാഹരണത്തിന്,

a:=5.12345678912345678912345; Writeln("a=", a); സന്ദേശം സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും.

എട്ടാം ക്ലാസ്സിലെ "ലീനിയർ പ്രോഗ്രാമുകൾ ഇൻ പാസ്കലിൽ" (ഇൻപുട്ട്, ഔട്ട്പുട്ട് ഓപ്പറേറ്റർമാർ) ഒരു തുറന്ന പാഠത്തിൻ്റെ സംഗ്രഹം

പാഠ വിഷയം: "പാസ്കലിലെ ലീനിയർ പ്രോഗ്രാമുകൾ" (ഇൻപുട്ട്, ഔട്ട്പുട്ട് പ്രസ്താവനകൾ)

പാഠത്തിൻ്റെ ഉദ്ദേശ്യം: പാസ്കൽ പ്രോഗ്രാമിംഗ് ഭാഷ, വാക്യഘടന, സെമാൻ്റിക്സ് എന്നിവയുടെ അടിസ്ഥാന ഓപ്പറേറ്റർമാരെ പഠിക്കുക, കൂടാതെ പ്രശ്നങ്ങൾ പരിഹരിക്കുമ്പോൾ ഈ ഓപ്പറേറ്റർമാരെ എങ്ങനെ ഉപയോഗിക്കണമെന്ന് വിദ്യാർത്ഥികളെ പഠിപ്പിക്കുക.

പാഠത്തിൻ്റെ ലക്ഷ്യങ്ങൾ:

• വിദ്യാഭ്യാസപരമായ:

• ഓപ്പറേറ്റർമാരെയും അവരുടെ പ്രയോഗ മേഖലകളെയും കുറിച്ചുള്ള വിദ്യാർത്ഥികളുടെ ധാരണ;
• പാസ്കൽ പ്രോഗ്രാമിംഗ് ഭാഷയിൽ പ്രസ്താവനകൾ എഴുതുന്നതിനുള്ള കഴിവുകൾ വികസിപ്പിക്കുക;
• പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് ലീനിയർ അൽഗോരിതങ്ങൾ നടപ്പിലാക്കുന്ന പ്രോഗ്രാമുകൾ എഴുതുന്നതിൽ കഴിവുകൾ വികസിപ്പിക്കുക;

• വികസിപ്പിക്കുന്നു:

• വിദ്യാർത്ഥികളുടെ ലോജിക്കൽ, അൽഗോരിതം ചിന്തയുടെ വികസനം;
• വിദ്യാർത്ഥികളിൽ വൈജ്ഞാനിക പ്രവർത്തനത്തിൻ്റെ വികസനം;
• മെമ്മറിയുടെയും ശ്രദ്ധയുടെയും വികസനം;
• വിദ്യാർത്ഥികളിൽ ആശയവിനിമയ ശേഷി വികസിപ്പിക്കുക;
• വിദ്യാർത്ഥികളുടെ കമ്പ്യൂട്ടർ സാക്ഷരതയും അറിവ് നേടേണ്ടതിൻ്റെ ആവശ്യകതയും വികസിപ്പിക്കുക;

• വിദ്യാഭ്യാസപരമായ:

• സ്വതന്ത്ര ജോലിയുടെ കഴിവുകൾ വിദ്യാർത്ഥികളിൽ വളർത്തുക;
• കമ്പ്യൂട്ടർ സാങ്കേതികവിദ്യയോട് കരുതലുള്ള മനോഭാവം വളർത്തിയെടുക്കുക;
• സഹിഷ്ണുതയുടെ വിദ്യാഭ്യാസം.

പാഠ തരം: പുതിയ മെറ്റീരിയൽ പഠിക്കാനുള്ള പാഠം.

ഫോമുകളും അധ്യാപന രീതികളും:വാക്കാലുള്ള, വിഷ്വൽ, പ്രായോഗിക, പ്രശ്നാധിഷ്ഠിത - ഫ്രണ്ടൽ ചോദ്യം ചെയ്യൽ, കമ്പ്യൂട്ടർ വർക്ക്.

ആകെ സമയം: 45 മിനിറ്റ്.

പാഠ സ്ഥലം:കമ്പ്യൂട്ടർ സയൻസ് റൂം.

പാഠ ഉപകരണങ്ങൾ:കമ്പ്യൂട്ടർ അവതരണം “പാസ്‌കൽ ഭാഷയുടെ അടിസ്ഥാന ഓപ്പറേറ്റർമാർ”, മൾട്ടിമീഡിയ പ്രൊജക്ടർ, ഇൻ്ററാക്ടീവ് ട്രെയിനിംഗ് കോഴ്‌സ് “ഇക്വിലിബ്രിയം” എന്ന പബ്ലിഷിംഗ് ഹൗസിൻ്റെ “ബേസിക്സ് ഓഫ് പ്രോഗ്രാമിംഗ് ഇൻ ടർബോ പാസ്കൽ”, ടർബോ പാസ്കൽ പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്ത കമ്പ്യൂട്ടറുകൾ, സ്പീക്കറുകൾ, ഉപദേശപരമായ ഹാൻഡ്ഔട്ടുകൾ.

പാഠ പദ്ധതി

1. സംഘടനാ നിമിഷം - 1 മിനിറ്റ്.
2. ആമുഖ വാക്ക് - 1 മിനിറ്റ്.
3. വിദ്യാർത്ഥികളുടെ അറിവും കഴിവുകളും അപ്ഡേറ്റ് ചെയ്യുന്നു - 8 മിനിറ്റ്.
4. പുതിയ മെറ്റീരിയൽ പഠിക്കൽ - 15 മിനിറ്റ്.
5. പഠിച്ച മെറ്റീരിയൽ ശക്തിപ്പെടുത്തൽ കമ്പ്യൂട്ടറുകളിൽ പ്രവർത്തിക്കുന്നു - 15 മിനിറ്റ്.
6. ഉപസംഹാരം - 3 മിനിറ്റ്.
7. ഗൃഹപാഠം - 2 മിനിറ്റ്.

ക്ലാസുകൾക്കിടയിൽ

1. ഡ്യൂട്ടി ഓഫീസറുമായുള്ള സംഭാഷണം.ഹലോ.

ആരാണ് ഇന്ന് ഡ്യൂട്ടിയിലുള്ളത്? ഏത് വിദ്യാർത്ഥികളാണ് ക്ലാസിൽ ഇല്ലാത്തത്?

2. ആമുഖ വാക്ക്. ഇന്ന് പാഠത്തിൽ നമുക്ക് പാസ്കൽ പ്രോഗ്രാമിംഗ് ഭാഷയുടെ അടിസ്ഥാന ഓപ്പറേറ്റർമാരെ പരിചയപ്പെടാം. ഏത് സാഹചര്യത്തിലാണ് ഈ ഓപ്പറേറ്റർമാർ ഉപയോഗിക്കുന്നത്, ഈ ഓപ്പറേറ്റർമാരെ റെക്കോർഡുചെയ്യുന്നതിനുള്ള ഫോർമാറ്റ് ഇന്നത്തെ പാഠത്തിൽ നിങ്ങൾ പഠിക്കും.

3. വിദ്യാർത്ഥികളുടെ അറിവും കഴിവുകളും നവീകരിക്കുന്നു.ഒരു മുൻനിര സർവേയ്ക്കിടെ വിദ്യാർത്ഥികളുടെ അറിവും വൈദഗ്ധ്യവും അപ്ഡേറ്റ് ചെയ്യപ്പെടുന്നു, ഈ സമയത്ത് അവർ ഇനിപ്പറയുന്ന ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകേണ്ടിവരും:

1. ഒരു ലീനിയർ അൽഗോരിതം നിർവ്വചിക്കുക.
2. ലീനിയർ അൽഗോരിതത്തിൻ്റെ ഘടന.
3. ലീനിയർ അൽഗോരിതങ്ങളുടെ ഉദാഹരണങ്ങൾ നൽകുക.
4. പ്രോഗ്രാം ഹെഡർ ഫോർമാറ്റ് എഴുതുക.

4. പുതിയ മെറ്റീരിയൽ പഠിക്കുന്നു.

"ടർബോ പാസ്കൽ പ്രോഗ്രാമിംഗ് അടിസ്ഥാനങ്ങൾ" - ടർബോ പാസ്കൽ\ഇൻപുട്ട്, ഔട്ട്പുട്ട് ഓപ്പറേറ്റർമാർക്കുള്ള ആമുഖം" എന്ന സംവേദനാത്മക പരിശീലന കോഴ്‌സ് കേൾക്കാൻ വിദ്യാർത്ഥികളെ ക്ഷണിക്കുന്നു, ഒരു അടിസ്ഥാന രൂപരേഖ തയ്യാറാക്കുക - ഫോർമാറ്റും ഫ്ലോചാർട്ടും ഒരു നോട്ട്ബുക്കിൽ എഴുതി ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുക:

1. ഏത് സാഹചര്യത്തിലാണ് റീഡ് ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നത്, ഏതൊക്കെ സന്ദർഭങ്ങളിൽ Readln ആണ്?
2. റൈറ്റ്, റൈറ്റൽ പ്രസ്താവനകൾ തമ്മിലുള്ള വ്യത്യാസം എന്താണ്?
3. CRT മൊഡ്യൂളിൻ്റെ അടിസ്ഥാന നടപടിക്രമങ്ങളും പ്രവർത്തനങ്ങളും.

ഓപ്പറേറ്റർമാരെ നിർവ്വഹിക്കുന്ന തത്വവും ചില പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിനുള്ള ഉദാഹരണങ്ങളും.

ഒരു ഉദാഹരണ പ്രോഗ്രാം നോക്കി നമുക്ക് ആരംഭിക്കാം:

കീബോർഡിൽ നിന്ന് നൽകിയ 3 പൂർണ്ണസംഖ്യകളുടെ തുകയും ഉൽപ്പന്നവും കണ്ടെത്തുക.

പ്രോഗ്രാം ഇതുപോലെ കാണപ്പെടും:

പ്രോഗ്രാം സംഗ്രഹം (ഇൻപുട്ട്, ഔട്ട്പുട്ട്);

var a,b,c,s,p:integer;

ആരംഭിക്കുന്നു

എഴുതുക ('3 പൂർണ്ണസംഖ്യകൾ നൽകുക');

Readln(a,b,c);

എസ്:=എ+ബി+സി; പി:=എ*ബി*സി;

Writeln (‘നൽകിയ സംഖ്യകളുടെ ആകെത്തുക’,s);

Writeln('നൽകിയ സംഖ്യകളുടെ ഉൽപ്പന്നം',p);

അവസാനിക്കുന്നു.

അനുമാന നടപടിക്രമം രേഖപ്പെടുത്തുന്നതിൻ്റെ വിവിധ രൂപങ്ങളിലേക്ക് ഞങ്ങൾ വിദ്യാർത്ഥികളുടെ ശ്രദ്ധ ആകർഷിക്കുകയും മെറ്റീരിയൽ അവതരിപ്പിക്കുകയും ചെയ്യുന്നു.

നടപടിക്രമങ്ങൾ ഉപയോഗിച്ചാണ് ഡാറ്റാ എൻട്രി നടത്തുന്നത്വായിക്കുകയും വായിക്കുകയും ചെയ്യുക;

റെക്കോർഡിംഗ് ഫോർമാറ്റ്:

വായിക്കുക (വേരിയബിൾ പേരുകൾ); വായിക്കുക (a,b,c);

ഈ നടപടിക്രമം ഉപയോഗിക്കുമ്പോൾ, വേരിയബിൾ മൂല്യങ്ങൾ നൽകിയ ശേഷം, കഴ്സർ അതേ വരിയിൽ തന്നെ തുടരുന്നു, അതായത്, അടുത്ത ഇൻപുട്ട് അല്ലെങ്കിൽ ഔട്ട്പുട്ട് ഒരേ വരിയിൽ ആരംഭിക്കുന്നു.

Readln (വേരിയബിൾ പേരുകൾ); readln(a,b,c);

ഈ നടപടിക്രമം ഉപയോഗിക്കുമ്പോൾ, ഡാറ്റ നൽകിയ ശേഷം, കഴ്സർ ഒരു പുതിയ ലൈനിലേക്ക് നീങ്ങുകയും അടുത്ത ഇൻപുട്ട് അല്ലെങ്കിൽ ഔട്ട്പുട്ട് ഒരു പുതിയ ലൈനിൽ നിന്ന് നിർമ്മിക്കുകയും ചെയ്യും.

നടപടിക്രമങ്ങൾ ഉപയോഗിച്ചാണ് ഔട്ട്പുട്ട് നടത്തുന്നത്എഴുതുക, എഴുതുക.

റെക്കോർഡിംഗ് ഫോർമാറ്റ്:

എഴുതുക ('ടെക്സ്റ്റ്', വേരിയബിൾ പേരുകൾ:m:n);

writeln('ടെക്സ്റ്റ്', വേരിയബിൾ പേരുകൾ:m:n);

ഈ നടപടിക്രമങ്ങൾ ഇൻപുട്ട് നടപടിക്രമങ്ങൾ പോലെ തന്നെ പ്രവർത്തിക്കുന്നു.

m, n പരാമീറ്ററുകൾ ഔട്ട്പുട്ട് ഫോർമാറ്റ് നിർണ്ണയിക്കുന്നു. ഒരു പൂർണ്ണസംഖ്യയുടെ വേരിയബിളുകൾക്കായി, m എന്ന പാരാമീറ്റർ മാത്രമേ വ്യക്തമാക്കിയിട്ടുള്ളൂ; ഒരു യഥാർത്ഥ തരം വേരിയബിളുകൾക്ക്, ആവശ്യമുള്ള ഔട്ട്‌പുട്ട് ഫോർമാറ്റിനെ ആശ്രയിച്ച് രണ്ട് പാരാമീറ്ററുകളും വ്യക്തമാക്കിയേക്കാം; പ്രതീകത്തിനും സ്ട്രിംഗ് വേരിയബിളുകൾക്കും m മാത്രം.

തുടർന്ന് ഞങ്ങൾ മൊഡ്യൂളിൽ ലഭ്യമായ നടപടിക്രമങ്ങളും പ്രവർത്തനങ്ങളും പഠിക്കാൻ പോകുന്നുസി.ആർ.ടി.

മൊഡ്യൂളിൻ്റെ അടിസ്ഥാന നടപടിക്രമങ്ങളും പ്രവർത്തനങ്ങളും ഞങ്ങൾ വിദ്യാർത്ഥികൾക്ക് നൽകുന്നു.

നടപടിക്രമങ്ങൾ:

Clrscr (വ്യക്തമായ സ്ക്രീൻ) - സ്ക്രീൻ ശൂന്യമാക്കുന്നു (ഔട്ട്പുട്ട് വിൻഡോ മായ്ക്കുന്നു).

Gotoxy(m,n) - n എന്ന വരിയുടെ m സ്ഥാനത്ത് കഴ്‌സർ സ്ഥാപിക്കുന്നു.

Trxtbackground(c) - പശ്ചാത്തല നിറം ക്രമീകരിക്കുക; c നിറം നിർണ്ണയിക്കുന്ന ഒരു സ്ഥിരാങ്കമാണ് (സംഖ്യ 0 മുതൽ 7 വരെ).

ടെക്സ്റ്റ് കളർ(സി) - ഫോണ്ട് നിറം ക്രമീകരിക്കുന്നു; c ന് 0 മുതൽ 7 വരെയുള്ള മൂല്യങ്ങൾ എടുക്കാം.

നിർവചിക്കുക - കഴ്‌സർ സ്ഥിതിചെയ്യുന്ന വരി ഇല്ലാതാക്കുന്നു. ഇല്ലാതാക്കിയ വരികൾക്ക് താഴെയുള്ള എല്ലാ വരികളും ഒരു വരി മുകളിലേക്ക് മാറ്റുന്നു.

ഇൻസ്‌ലൈൻ - കഴ്‌സർ സ്ഥാനത്ത് ശൂന്യമായ വരികൾ ചേർക്കുമ്പോൾ, കഴ്‌സറിന് പിന്നിലെ എല്ലാ വരികളും ഒരു വരി താഴേക്ക് മാറ്റുന്നു.

കാലതാമസം(n) - n മില്ലിസെക്കൻഡുകൾക്ക് പ്രോഗ്രാം എക്സിക്യൂഷൻ താൽക്കാലികമായി നിർത്തുക.

ശബ്ദം(n) - n Hz ടോൺ ഫ്രീക്വൻസിയിൽ ശബ്ദ ജനറേറ്ററിൻ്റെ ആരംഭം.

ഒരു ശബ്ദവുമില്ല ശബ്ദ സിഗ്നൽ ഓഫ് ചെയ്യുന്നു.

പ്രവർത്തനങ്ങൾ:

കീ അമർത്തി - ഫംഗ്‌ഷൻ മൂല്യത്തിന് രണ്ട് മൂല്യങ്ങൾ എടുക്കാം: ശരിയോ തെറ്റോ. ക്ലിപ്പ്ബോർഡിൽ അക്ഷരങ്ങൾ ഇല്ലെങ്കിൽ ശരി, അല്ലെങ്കിൽ തെറ്റ്.

റെഡികീ - സ്ക്രീനിൽ പ്രദർശിപ്പിക്കാതെ കീബോർഡിൽ നിന്ന് പ്രതീകങ്ങൾ നൽകുക.

ഈ നടപടിക്രമങ്ങളുടെയും പ്രവർത്തനങ്ങളുടെയും ഉപയോഗത്തിൻ്റെ വിശദീകരണം ഹ്രസ്വമായിരിക്കും. എന്തെല്ലാം നടപടിക്രമങ്ങളും പ്രവർത്തനങ്ങളും നിലവിലുണ്ട്, അവയുടെ ഫോർമാറ്റ് എന്താണെന്നും അവർ എന്താണ് സേവിക്കുന്നതെന്നും വിദ്യാർത്ഥികൾ ഈ കേസിൽ പഠിക്കണം. അവരുമായി കൂടുതൽ പൂർണ്ണമായ പരിചയം ലബോറട്ടറി ജോലികൾക്കിടയിലായിരിക്കും.

5. പഠിച്ച മെറ്റീരിയലിൻ്റെ ഏകീകരണം. കമ്പ്യൂട്ടറുകളിൽ പ്രവർത്തിക്കുന്നുപഠിച്ച മെറ്റീരിയൽ ഏകീകരിക്കുന്നതിന്, ലബോറട്ടറി ജോലികൾ പൂർത്തിയാക്കാൻ വിദ്യാർത്ഥികളോട് ആവശ്യപ്പെടുന്നു.

അധ്യാപകർ വ്യക്തമാക്കിയ ഫയലുകൾ വിദ്യാർത്ഥികൾ സിസ്റ്റം എഡിറ്ററിലേക്ക് ലോഡ് ചെയ്യുകയും പ്രോഗ്രാമിൻ്റെ നിർദ്ദേശങ്ങൾ പാലിച്ച് അതിൻ്റെ ഉള്ളടക്കം വിശകലനം ചെയ്യുകയും ചില നടപടിക്രമങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് മനസിലാക്കുകയും ചെയ്യുന്നു എന്നതാണ് ജോലിയുടെ സാരം.

ഈ ഘട്ടത്തിൽ വിദ്യാർത്ഥികൾ ചെയ്യുന്ന ജോലികൾ:

പ്രശ്നം 1

പ്രോഗ്രാം പെരിം;

Usescrt;

Var a,b,c,d,p:real;

ആരംഭിക്കുന്നു

എഴുതുക (‘ട്രപസോയിഡ് a,b,c,d’ വശങ്ങളുടെ നീളം നൽകുക);

Readln(a,b,c,d);

പി:=എ+ബി+സി+ഡി;

Writeln('perimeter=',p);

Writeln ('എഡിറ്ററിലേക്ക് മടങ്ങാൻ, ഏതെങ്കിലും കീ അമർത്തുക');

keypressrd വരെ ആവർത്തിക്കുക;

അവസാനിക്കുന്നു.

പ്രോഗ്രാം വാചകം പരിശോധിച്ച് അത് എന്താണ് ചെയ്യുന്നതെന്ന് കണ്ടെത്തുക;

നിർവ്വഹണത്തിനായി പ്രോഗ്രാം സമാരംഭിക്കുക;

ഔട്ട്പുട്ട് ഫലം ശ്രദ്ധാപൂർവ്വം നോക്കുക;

എഡിറ്ററിലേക്ക് പുറത്തുകടക്കുക കൂടാതെ:

ആരംഭിച്ചതിന് ശേഷം, നടപടിക്രമം ഗോടോക്സി (25,5) ചേർക്കുക;

സ്‌ക്രീനിൽ ചുറ്റളവ് മൂല്യം പ്രദർശിപ്പിക്കുന്ന റൈറ്റൽൺ നടപടിക്രമത്തിൽ, എൻട്രി p, p:7:2 ആയി മാറ്റുക;

നിർവ്വഹണത്തിനായി ഇത് പ്രവർത്തിപ്പിക്കുക, പ്രോഗ്രാം റോബോട്ടിൽ എന്താണ് മാറിയതെന്ന് കണ്ടെത്തുക.

പ്രശ്നം 2

പ്രോഗ്രാം dvij;

Usescrt,graph;

Var i,j,x:integer;

ആരംഭിക്കുന്നു

ഞാൻ:=കണ്ടെത്തുക; initgraph(i,j,' '); ശബ്ദം (400);

x:=0 മുതൽ 640 വരെ

ആരംഭിക്കുന്നു

സെറ്റ് കളർ (5); സർക്കിൾ(x,100.5); കാലതാമസം (300); സെറ്റ് കളർ (0);

അവസാനിക്കുന്നു;

ഒരു ശബ്ദവുമില്ല

അവസാനിക്കുന്നു.

നിർവ്വഹണത്തിനായി ഓടുക;

നിർവ്വഹണം നിരീക്ഷിക്കുക;

എഡിറ്ററിലേക്ക് മടങ്ങിയ ശേഷം, ശബ്‌ദ നടപടിക്രമത്തിലെ പാരാമീറ്റർ മൂല്യം 400 ൽ നിന്ന് 800 ആയി മാറ്റുക, കാലതാമസം നടപടിക്രമത്തിലെ പാരാമീറ്റർ മൂല്യം 300 ൽ നിന്ന് 1000 ആക്കുക;

പ്രോഗ്രാം പുനരാരംഭിക്കുക;

മാറ്റങ്ങൾ പ്രോഗ്രാമിൻ്റെ പ്രവർത്തനത്തെ എങ്ങനെ ബാധിച്ചുവെന്ന് വിശകലനം ചെയ്യുക.

ക്ലാസ് വേഗത്തിൽ ജോലികൾ പൂർത്തിയാക്കുകയാണെങ്കിൽ, ഈ പ്രോഗ്രാമുകൾ പരീക്ഷിക്കാൻ നിങ്ങൾക്ക് കുട്ടികൾക്ക് അവസരം നൽകാം.

6. ഉപസംഹാരം. പാഠങ്ങൾ സംഗ്രഹിച്ചിരിക്കുന്നു, ഓരോ വിദ്യാർത്ഥിയുടെയും ജോലി വിശകലനം ചെയ്യുകയും വിലയിരുത്തുകയും ചെയ്യുന്നു.

പ്രതിഫലനം:
- ഇന്ന് നിങ്ങൾക്ക് ക്ലാസ്സിൽ സുഖം തോന്നിയോ?
- ഇന്നത്തെ പാഠത്തിൽ നിങ്ങൾ പുതിയതെന്താണ് പഠിച്ചത്?
- നിങ്ങൾ എന്ത് പ്രത്യേക ബുദ്ധിമുട്ടുകൾ നേരിട്ടു?
- നിങ്ങൾക്ക് ലളിതമായി തോന്നിയ ജോലികൾ ഏതാണ്?

7. ഹോംവർക്ക് അസൈൻമെൻ്റ്.

1. പിന്തുണയ്ക്കുന്ന കുറിപ്പുകൾ പഠിക്കുക.
2. ഒരു നിശ്ചിത തുക തുണിയുടെ വില കണ്ടെത്തുക. കീബോർഡിൽ നിന്ന് വിലയും അളവും രേഖപ്പെടുത്തുന്നു. പ്രശ്നം പരിഹരിക്കുന്നതിന് ഒരു ഫ്ലോചാർട്ടും പ്രോഗ്രാമും സൃഷ്ടിക്കുക.
3. വേരിയബിളുകളുടെ മൂല്യങ്ങൾ നൽകിയിരിക്കുന്നു: a=12; b=5. ഇനിപ്പറയുന്ന പ്രോഗ്രാം ശകലം എക്സിക്യൂട്ട് ചെയ്ത ശേഷം ഈ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ എന്തായിരിക്കും:

a) a:=b; ബി:=എ; c:= a+b;

b) f:=y; y:=x; x:=f; c:=a+b.

ഒരു ടെർമിനൽ ഉപകരണത്തിൽ നിന്നുള്ള ഡാറ്റ ഇൻപുട്ട്/ഔട്ട്പുട്ട് എങ്ങനെയാണ് സംഘടിപ്പിക്കുന്നത്? ആരംഭിക്കുന്നതിന് (ആർക്കറിയില്ല), നമുക്ക് ഒരു ടെർമിനൽ ഉപകരണം നിർവചിക്കാം. ടെർമിനൽ ഉപകരണം ഒരു കീബോർഡ് ആണ്, ഡിസ്പ്ലേ, അതായത്. ഉപയോക്താവ് സാധാരണയായി എന്താണ് പ്രവർത്തിക്കുന്നത്. ഏതൊക്കെയാണ് നിലനിൽക്കുന്നത്? പാസ്കൽ ഇൻപുട്ട്/ഔട്ട്പുട്ട് ഓപ്പറേറ്റർമാർ?

പാസ്കൽ ഡാറ്റ ഇൻപുട്ട്:

പാസ്കലിൽ ഡാറ്റ എങ്ങനെ നൽകാം? വളരെ ലളിതവും ലളിതവുമാണ്! പാസ്കലിൽ പ്രാരംഭ ഡാറ്റ ഇൻപുട്ട് ചെയ്യുന്നത് readln നടപടിക്രമം വഴിയാണ്:

readln(b1,b2,...,bk)

ഈ ഉദാഹരണത്തിൽ, readln നടപടിക്രമം ഉറവിട ഡാറ്റയുടെ k മൂല്യങ്ങൾ വായിക്കുകയും ഈ മൂല്യങ്ങൾ ഒരു പുതിയ വരി ഉപയോഗിച്ച് b1, b2,..., bk വേരിയബിളുകൾക്ക് നൽകുകയും ചെയ്യുന്നു (സമാനമായ ഒരു റീഡ് നടപടിക്രമം redln-ൽ നിന്ന് വ്യത്യസ്തമാണ്. അടുത്ത വരിയിലേക്ക് പോകരുത്). ഞങ്ങൾ പാസ്കലിൽ ഡാറ്റ നൽകുമ്പോൾ, ബാഹ്യ രൂപത്തിൻ്റെ ആന്തരിക രൂപത്തിലേക്ക് ഒരു പ്രത്യേക പരിവർത്തനം സംഭവിക്കുന്നു, ഇത് വേരിയബിളുകളുടെ തരം അനുസരിച്ച് നിർണ്ണയിക്കപ്പെടുന്നു.

ഇൻപുട്ട് ലിസ്റ്റിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന വേരിയബിളുകൾ വ്യത്യസ്ത തരങ്ങളാകാം: പൂർണ്ണസംഖ്യ, യഥാർത്ഥം, പ്രതീകം. എന്നിരുന്നാലും, പാസ്കലിൽ ബൂളിയൻ ഡാറ്റ വായിക്കുന്നത് അനുവദനീയമല്ല. ഉറവിട ഡാറ്റ (അതായത്, അവയുടെ മൂല്യങ്ങൾ) എൻ്റർ, ടാബ് കീകൾ, സ്‌പെയ്‌സുകൾ അമർത്തി പരസ്പരം വേർതിരിക്കുന്നു (ഡാറ്റ നൽകുമ്പോൾ, കോമകൾ ഉപയോഗിച്ച് നമ്പറുകൾ വേർതിരിക്കുന്നത് അസ്വീകാര്യമാണ്).

പാസ്കൽ ഡാറ്റ ഔട്ട്പുട്ട്:

ഇനി നമുക്ക് പാസ്കലിലെ ഡാറ്റ ഔട്ട്പുട്ടിനെക്കുറിച്ച് സംസാരിക്കാം. നിങ്ങളുടെ പ്രോഗ്രാമിൻ്റെ ഔട്ട്പുട്ട് സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുന്നതിന്, നിങ്ങൾ സാധാരണയായി രണ്ട് നടപടിക്രമങ്ങൾ ഉപയോഗിക്കുന്നു:

എഴുതുക(b1,b2,...bk)— b1, b2,..., bk എന്നീ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ സ്‌ക്രീൻ ലൈനിലേക്ക് ഔട്ട്‌പുട്ട് ചെയ്യുന്നു.

writeln(b1,b2,..., bk)- സ്‌ക്രീനിൽ ഡാറ്റ ഔട്ട്‌പുട്ടും അടുത്ത വരിയുടെ തുടക്കത്തിലേക്കുള്ള പരിവർത്തനവും നിർമ്മിക്കുന്നു.

പാരാമീറ്ററുകൾ ഇല്ലാതെ തന്നെ റൈറ്റ്ൽൻ നടപടിക്രമം ഉപയോഗിക്കാവുന്നതാണ്, കൂടാതെ യഥാർത്ഥ വരി ഒഴിവാക്കി അടുത്തതിൻ്റെ തുടക്കത്തിലേക്ക് നീങ്ങുകയും ചെയ്യുന്നു. ഔട്ട്പുട്ട് ലിസ്റ്റിൽ, വേരിയബിളുകൾ പല തരത്തിലാകാം: പൂർണ്ണസംഖ്യ, യഥാർത്ഥം, പ്രതീകം അല്ലെങ്കിൽ ബൂളിയൻ. ഔട്ട്പുട്ട് ലിസ്റ്റിലെ ഘടകങ്ങളിൽ എക്സ്പ്രഷനുകളും സ്ട്രിംഗുകളും ഉൾപ്പെടുന്നു. ഔട്ട്പുട്ട് ഫീൽഡിലെ മൂല്യങ്ങളുടെ അവതരണത്തിൻ്റെ രൂപം വേരിയബിളുകളുടെയും എക്സ്പ്രഷനുകളുടെയും തരവുമായി പൊരുത്തപ്പെടുന്നു:

• പൂർണ്ണസംഖ്യ മൂല്യങ്ങൾ പൂർണ്ണ ദശാംശ സംഖ്യകളായി ഔട്ട്പുട്ട് ചെയ്യുന്നു,
• യഥാർത്ഥ തരത്തിലുള്ള മൂല്യങ്ങളെ ദശാംശ ഘാതം ഉപയോഗിച്ച് യഥാർത്ഥ ദശാംശ സംഖ്യകളായി പ്രതിനിധീകരിക്കുന്നു,
• പ്രതീക തരം മൂല്യങ്ങളും സ്ട്രിംഗുകളും പ്രതീകങ്ങളായി ഔട്ട്പുട്ട് ചെയ്യുന്നു,
• ലോജിക്കൽ തരം മൂല്യങ്ങൾ - ശരിയും തെറ്റും (ലോജിക്കൽ സ്ഥിരാങ്കങ്ങൾ) രൂപത്തിൽ.

ഔട്ട്‌പുട്ട് ലിസ്റ്റിലെ ഓരോ ഘടകത്തിനും ഔട്ട്‌പുട്ട് ഫീൽഡിൻ്റെ വീതി സജ്ജീകരിക്കാനുള്ള കഴിവ് ഔട്ട്‌പുട്ട് ഓപ്പറേറ്റർ സൃഷ്‌ടിക്കുന്നു, അത് ഇതുപോലെ കാണപ്പെടും: A:K, ഇവിടെ A ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ എക്സ്പ്രഷൻ ആണ്, K എന്നത് ഒരു എക്സ്പ്രഷൻ അല്ലെങ്കിൽ ഒരു പൂർണ്ണസംഖ്യ സ്ഥിരാങ്കമാണ്. ഈ സാഹചര്യത്തിൽ രണ്ട് സാഹചര്യങ്ങൾ ഉണ്ടാകുന്നു:

1. ഔട്ട്പുട്ട് ഫീൽഡിൽ K എന്നതിനേക്കാൾ കുറച്ച് സ്ഥാനങ്ങൾ ഔട്ട്പുട്ട് മൂല്യം ഉൾക്കൊള്ളുന്നുവെങ്കിൽ, അതിന് മുന്നിൽ സ്പെയ്സുകൾ സ്ഥാപിക്കുന്നു.
2. കെ ഫീൽഡിനുള്ളിൽ മൂല്യം യോജിക്കാത്തപ്പോൾ, ഈ മൂല്യത്തിന് ആവശ്യമായ സ്ഥാനങ്ങളുടെ എണ്ണം അനുവദിക്കും.

ഒരു യഥാർത്ഥ തരത്തിൻ്റെ മൂല്യങ്ങൾക്കായുള്ള ഔട്ട്‌പുട്ട് ലിസ്റ്റ് ഘടകത്തിന് ഫോം ഉണ്ടായിരിക്കാം: A:K:M, ഇവിടെ A എന്നത് ഒരു യഥാർത്ഥ തരത്തിൻ്റെയോ വേരിയബിളിൻ്റെയോ പദപ്രയോഗമാണ്, K എന്നത് ഔട്ട്‌പുട്ട് ഫീൽഡിൻ്റെ വീതിയാണ് (എക്‌സ്‌പ്രഷൻ അല്ലെങ്കിൽ സ്ഥിരാങ്കം), ഔട്ട്പുട്ട് മൂല്യത്തിൻ്റെ (എക്സ്പ്രഷൻ അല്ലെങ്കിൽ സ്ഥിരാങ്കം) ഫ്രാക്ഷണൽ ഭാഗത്തിൻ്റെ അക്കങ്ങളുടെ എണ്ണമാണ് M. ഈ സാഹചര്യത്തിൽ, യഥാർത്ഥ മൂല്യങ്ങൾ ഒരു നിശ്ചിത-പോയിൻ്റ് ദശാംശ സംഖ്യയായി ഔട്ട്പുട്ട് ചെയ്യും. ഔട്ട്‌പുട്ട് സ്റ്റേറ്റ്‌മെൻ്റുകൾ എഴുതുന്നതിനുള്ള ഒരു ഉദാഹരണം നമുക്ക് സങ്കൽപ്പിക്കാം:

നിങ്ങൾ ഓർക്കുന്നുണ്ടെങ്കിൽ, അസൈൻമെൻ്റ് ഓപ്പറേറ്ററുടെ ഒരു ഉദാഹരണം പരിഗണിക്കുമ്പോൾ, പ്രോഗ്രാം എക്സിക്യൂഷൻ്റെ ഫലം കണ്ടെത്തേണ്ടതിൻ്റെ ആവശ്യകത ഞങ്ങൾ അഭിമുഖീകരിച്ചു. വിവരങ്ങൾ എങ്ങനെ സംഭരിക്കാം (വേരിയബിളുകളിൽ), അത് എങ്ങനെ പ്രോസസ്സ് ചെയ്യാം (എക്‌സ്‌പ്രഷനുകൾ ഉപയോഗിച്ച്), എന്നാൽ രണ്ട് അടിസ്ഥാന വിവര പ്രക്രിയകൾ ഞങ്ങളുടെ ശ്രദ്ധയ്ക്ക് പുറത്താണ്: വിവരങ്ങൾ സ്വീകരിക്കുകയും കമ്പ്യൂട്ടറിന് പുറത്തുള്ള ലോകത്തേക്ക് കൈമാറുകയും ചെയ്യുന്നു. ഇതുവരെ, ഞങ്ങളുടെ പ്രോഗ്രാമുകൾക്ക് പ്രോഗ്രാം ടെക്സ്റ്റിൽ നേരിട്ട് സ്ഥിതി ചെയ്യുന്ന വിവരങ്ങൾ മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ. വേരിയബിളുകൾക്ക് നിലവിൽ ഉള്ള മൂല്യങ്ങൾ എന്താണെന്ന് കണ്ടെത്താനും കഴിഞ്ഞില്ല. അത്തരം സാഹചര്യങ്ങളിൽ പ്രോഗ്രാമിംഗ് അർത്ഥശൂന്യമാകും.

ബാഹ്യ പരിതസ്ഥിതിയുമായി (കുറഞ്ഞത് ഉപയോക്താവുമായി) വിവര സംസ്കരണത്തിൻ്റെയും സംഭരണ ​​ഉപകരണങ്ങളുടെയും ഇടപെടൽ തികച്ചും ആവശ്യമാണ്. പാസ്കലിൽ, ഇൻഫർമേഷൻ ഇൻപുട്ട്/ഔട്ട്‌പുട്ട് ഓപ്പറേറ്റർമാർ അത്തരം ഒരു ഇൻ്റർഫേസിന് ഉത്തരവാദികളാണ്. പ്രോഗ്രാം എക്സിക്യൂഷൻ സമയത്ത് ആർഗ്യുമെൻ്റുകളും കണക്കുകൂട്ടൽ പാരാമീറ്ററുകളും നൽകാൻ ഈ നിർദ്ദേശങ്ങൾ നിങ്ങളെ അനുവദിക്കുന്നു (അത് എഴുതുന്ന ഘട്ടത്തിലല്ല), കൂടാതെ കണക്കാക്കിയ ഡാറ്റ മനുഷ്യർക്ക് മനസ്സിലാക്കാവുന്ന രൂപത്തിൽ ഔട്ട്പുട്ട് ചെയ്യുക.

ആദ്യം ഇൻപുട്ട് സ്റ്റേറ്റ്‌മെൻ്റുകൾ (സ്റ്റേറ്റ്‌മെൻ്റ് ഫോർമാറ്റുകൾ):

വായിക്കുക(<Список ввода>);

Readln(<Список ввода>);

ഈ ഫോർമാറ്റിൽ, കീബോർഡിൽ നിന്നുള്ള പ്രോഗ്രാം എക്സിക്യൂഷൻ സമയത്ത് ഡാറ്റയെ വേരിയബിളുകളിലേക്ക് നൽകുന്നതിന് ഈ കമാൻഡുകൾ അനുവദിക്കുന്നു. ഇൻപുട്ട് ലിസ്റ്റിൻ്റെ ഘടകങ്ങൾ വേരിയബിൾ പേരുകളാകാം, അവ കീബോർഡിൽ നിന്ന് നൽകിയ മൂല്യങ്ങൾ കൊണ്ട് പൂരിപ്പിക്കണം.

ഇൻപുട്ട് സ്റ്റേറ്റ്‌മെൻ്റുകളുടെ നിർവ്വഹണം ഇനിപ്പറയുന്ന രീതിയിൽ സംഭവിക്കുന്നു: പ്രോഗ്രാം താൽക്കാലികമായി നിർത്തി, ഒരു കഴ്‌സർ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും, കൂടാതെ ഇൻപുട്ട് ലിസ്റ്റിൽ പേരുകൾ സൂചിപ്പിച്ചിരിക്കുന്ന വേരിയബിളുകൾക്കായി ഉപയോക്താവ് ഒരു കൂട്ടം ഡാറ്റ നൽകുമെന്ന് കമ്പ്യൂട്ടർ പ്രതീക്ഷിക്കുന്നു. ഇൻപുട്ട് ലിസ്റ്റിന് ആവശ്യമുള്ള ക്രമത്തിൽ ഉപയോക്താവ് കീബോർഡിൽ നിന്ന് ആവശ്യമായ മൂല്യങ്ങൾ നൽകുകയും എൻ്റർ അമർത്തുകയും ചെയ്യുന്നു. ഇതിനുശേഷം, ടൈപ്പ് ചെയ്ത ഡാറ്റ അനുബന്ധ വേരിയബിളുകളിലേക്ക് പോകുകയും പ്രോഗ്രാം എക്സിക്യൂഷൻ തുടരുകയും ചെയ്യുന്നു.

ശ്രദ്ധിക്കുക: നൽകിയ ഡാറ്റ സ്‌പെയ്‌സുകളാൽ വേർതിരിച്ചിരിക്കുന്നു.

Read, Readln നടപടിക്രമങ്ങൾ തമ്മിലുള്ള വ്യത്യാസം (റീഡ് ലൈനിൽ നിന്ന്) ഇപ്രകാരമാണ്: Read എക്സിക്യൂട്ട് ചെയ്ത ശേഷം, അടുത്ത ഡാറ്റയുടെ മൂല്യം അതേ വരിയിൽ നിന്നും Readln എക്സിക്യൂട്ട് ചെയ്ത ശേഷം - ഒരു പുതിയ വരിയിൽ നിന്നും വായിക്കുന്നു.

പാസ്കലിൽ വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിന് രണ്ട് കമാൻഡുകൾ ഉണ്ട്:

എഴുതുക(<Список вывода>);

എഴുതിയത്(<Список вывода>);

Write and Writeln ഉപയോഗിക്കുന്ന ഈ ഫോർമാറ്റ് മോണിറ്റർ സ്ക്രീനിൽ ഔട്ട്പുട്ട് ലിസ്റ്റിൽ നിന്നുള്ള ഡാറ്റ പ്രദർശിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഔട്ട്പുട്ട് ലിസ്റ്റിലെ ഘടകങ്ങൾ വേരിയബിൾ പേരുകൾ, എക്സ്പ്രഷനുകൾ, സ്ഥിരാങ്കങ്ങൾ എന്നിവ ആകാം. സ്ക്രീനിൽ എക്സ്പ്രഷനുകളുടെ മൂല്യങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിന് മുമ്പ്, കമ്പ്യൂട്ടർ ആദ്യം അവ കണക്കാക്കും. ഇൻപുട്ട് സ്റ്റേറ്റ്‌മെൻ്റുകളിലേതുപോലെ ലിസ്റ്റ് ഘടകങ്ങൾ കോമകളാൽ വേർതിരിച്ചിരിക്കുന്നു.

രണ്ട് ഔട്ട്‌പുട്ട് ഓപ്പറേറ്റർമാർ തമ്മിലുള്ള വ്യത്യാസം ഇപ്രകാരമാണ്: റൈറ്റ്ൺ ഓപ്പറേറ്റർ (റൈറ്റ് ലൈനിൽ നിന്ന്) എക്‌സിക്യൂട്ട് ചെയ്‌ത ശേഷം, ഒരു പുതിയ ലൈനിലേക്ക് ഒരു മാറ്റം സംഭവിക്കുന്നു, കൂടാതെ റൈറ്റ് നിർദ്ദേശം നടപ്പിലാക്കിയ ശേഷം, ഒരു പുതിയ ലൈനിലേക്കുള്ള മാറ്റം സംഭവിക്കുന്നില്ല, തുടർന്ന് പ്രിൻ്റുചെയ്യുന്നു റൈറ്റ് അല്ലെങ്കിൽ റൈറ്റൽ ഔട്ട്പുട്ട് കമാൻഡുകൾ ഒരേ വരിയിൽ സംഭവിക്കും. പാരാമീറ്ററുകൾ ഇല്ലാതെ Writeln ഓപ്പറേറ്ററെ വിളിക്കുമ്പോൾ, അത് ഒരു പുതിയ ലൈനിലേക്ക് കുതിക്കുന്നു.

ഇൻപുട്ട്, ഔട്ട്പുട്ട് ഓപ്പറേറ്റർമാർ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

പ്രോഗ്രാം ഇൻ്റർഫേസ്;

എഴുതുക ("സർക്കിളിൻ്റെ ആരം നൽകുക"); (ഇൻപുട്ട് ആവശ്യപ്പെട്ട് സ്ക്രീനിൽ പ്രിൻ്റ് ചെയ്യുക)

Readln(R); (കീബോർഡിൽ നിന്ന് R വേരിയബിളിലേക്ക് ഒരു മൂല്യം നൽകുന്നു)

S:=4*ARCTAN(1)*SQR(R); (ഒരു വൃത്തത്തിൻ്റെ വിസ്തീർണ്ണം കണക്കാക്കുന്നു (pR2))

Writeln("റേഡിയസ് ഉള്ള ഒരു വൃത്തത്തിൻ്റെ വിസ്തീർണ്ണം ",R," ആണ് ",S)

ഈ പ്രോഗ്രാം ഉപയോക്താവിനോട് ഒരു സർക്കിളിൻ്റെ ആരം ചോദിക്കുന്നു, അതിൻ്റെ മൂല്യം നൽകാനുള്ള കഴിവ് നൽകുന്നു, ഈ ആരം ഉപയോഗിച്ച് ഒരു സർക്കിളിൻ്റെ വിസ്തീർണ്ണം കണക്കാക്കുകയും പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു. അങ്ങനെ, പ്രോഗ്രാം വാചകത്തിൽ മാറ്റങ്ങൾ വരുത്താതെ, വ്യത്യസ്ത റേഡിയസ് മൂല്യങ്ങൾ നൽകാനും അനുബന്ധ സർക്കിൾ ഏരിയ മൂല്യങ്ങൾ നേടാനും ഇത് സാധ്യമാകും. ഇത് ചെയ്യുന്നതിന്, പ്രോഗ്രാം നിരവധി തവണ പ്രവർത്തിപ്പിക്കുക. ഈ പ്രോഗ്രാം ഇനിപ്പറയുന്ന നിയമവും പ്രകടമാക്കുന്നു: ഫലങ്ങളുടെ ഔട്ട്പുട്ട് അഭിപ്രായമിടണം, അങ്ങനെ അച്ചടിച്ച സംഖ്യകളുടെ അർത്ഥം വ്യക്തമാണ്. തീർച്ചയായും, ഒരാൾക്ക് സ്വയം Writeln(S) ആയി പരിമിതപ്പെടുത്താം, എന്നാൽ ഈ സാഹചര്യത്തിൽ പ്രോഗ്രാമിൻ്റെ സംഖ്യാ ഔട്ട്പുട്ടിൻ്റെ അർത്ഥം പ്രോഗ്രാം എഴുതിയ ആൾക്ക് മാത്രമേ വ്യക്തമാകൂ.

ഇൻപുട്ടും ഔട്ട്പുട്ടും ഓപ്പറേറ്റർമാർ

ഒരു ടെർമിനൽ ഉപകരണത്തിൽ നിന്നുള്ള ഡാറ്റ ഇൻപുട്ടിൻ്റെയും ഔട്ട്പുട്ടിൻ്റെയും ഓർഗനൈസേഷൻ നമുക്ക് പരിഗണിക്കാം. സാധാരണയായി ഒരു സ്‌ക്രീനും (ഡിസ്‌പ്ലേ) കീബോർഡും ഉപയോഗിച്ച് ഉപയോക്താവ് സംവദിക്കുന്ന ഒരു ഉപകരണമാണ് ടെർമിനൽ ഉപകരണം. ഡാറ്റ ഇൻപുട്ട് ചെയ്യുന്നതിനും ഔട്ട്‌പുട്ട് ചെയ്യുന്നതിനും, സ്റ്റാൻഡേർഡ് സീക്വൻഷ്യൽ ഫയലുകളായ INPUT, OUTPUT എന്നിവയ്‌ക്കൊപ്പം പ്രവർത്തിക്കുന്ന സ്റ്റാൻഡേർഡ് ഇൻപുട്ട്, ഔട്ട്‌പുട്ട് നടപടിക്രമങ്ങൾ റീഡ് ആൻഡ് റൈറ്റ് ഉപയോഗിക്കുന്നു.

ഈ ഫയലുകളെ വേരിയബിൾ-ലെംഗ്ത്ത് ലൈനുകളായി തിരിച്ചിരിക്കുന്നു, അവ പരസ്പരം ഒരു ലൈൻ ടെർമിനേറ്റർ ഉപയോഗിച്ച് വേർതിരിച്ചിരിക്കുന്നു. ENTER കീ അമർത്തി വരിയുടെ അവസാനം വ്യക്തമാക്കുന്നു.

ഉറവിട ഡാറ്റ നൽകുന്നതിന്, ഇൻപുട്ട് നടപടിക്രമ ഓപ്പറേറ്റർമാർ ഉപയോഗിക്കുന്നു:

വായിക്കുക(A1,A2,...AK);

ReadLn(A1,A2,...AK);

അവയിൽ ആദ്യത്തേത് ഉറവിട ഡാറ്റയുടെ K മൂല്യങ്ങൾ വായിക്കുകയും ഈ മൂല്യങ്ങൾ A1, A2, ..., AK വേരിയബിളുകൾക്ക് നൽകുകയും ചെയ്യുന്നു. രണ്ടാമത്തെ ഓപ്പറേറ്റർ ഉറവിട ഡാറ്റയുടെ K മൂല്യങ്ങൾ വായിക്കുന്നതും അടുത്ത വരിയുടെ ആരംഭം വരെ ശേഷിക്കുന്ന മൂല്യങ്ങൾ ഒഴിവാക്കുന്നതും A1, A2, ..., AK എന്നീ വേരിയബിളുകൾക്ക് റീഡ് മൂല്യങ്ങൾ നൽകുന്നതും നടപ്പിലാക്കുന്നു. മൂന്നാമത്തെ ഓപ്പറേറ്റർ ഉറവിട ഡാറ്റയുടെ ഒരു വരി ഒഴിവാക്കുന്നത് നടപ്പിലാക്കുന്നു.

ഉറവിട ഡാറ്റ നൽകുമ്പോൾ, പ്രാതിനിധ്യത്തിൻ്റെ ബാഹ്യ രൂപത്തിൽ നിന്ന് ആന്തരിക രൂപത്തിലേക്ക് ഒരു പരിവർത്തനം സംഭവിക്കുന്നു, ഇത് വേരിയബിളുകളുടെ തരം അനുസരിച്ച് നിർണ്ണയിക്കപ്പെടുന്നു. ഇൻപുട്ട് ലിസ്റ്റ് നിർമ്മിക്കുന്ന വേരിയബിളുകൾ ഒന്നുകിൽ പൂർണ്ണസംഖ്യ, യഥാർത്ഥ അല്ലെങ്കിൽ പ്രതീക തരങ്ങൾ ആകാം. പാസ്കലിൽ ബൂളിയൻ ഉറവിട ഡാറ്റ വായിക്കുന്നത് അനുവദനീയമല്ല.

പൂർണ്ണസംഖ്യയുടെയും യഥാർത്ഥ തരം വേരിയബിളുകളുടെയും മൂല്യങ്ങൾ വായിക്കുമ്പോൾ ഇൻപുട്ട് സ്റ്റേറ്റ്‌മെൻ്റുകൾ നമ്പറിന് മുമ്പുള്ള സ്‌പെയ്‌സുകൾ ഒഴിവാക്കുന്നു. അതേ സമയം, ഈ ഓപ്പറേറ്റർമാർ ക്യാരക്ടർ വേരിയബിളുകളുടെ മൂല്യങ്ങൾക്ക് മുമ്പുള്ള സ്‌പെയ്‌സുകൾ ഒഴിവാക്കില്ല, കാരണം സ്‌പെയ്‌സുകൾ സ്ട്രിംഗുകളിൽ തുല്യ പ്രതീകങ്ങളാണ്. ഇൻപുട്ട് പ്രസ്താവനകൾ എഴുതുന്നതിനുള്ള ഒരു ഉദാഹരണം:

var rV, rS: യഥാർത്ഥം;

iW, iJ: പൂർണ്ണസംഖ്യ;

................

വായിക്കുക(rV, rS, iW, iJ);

സ്‌പെയ്‌സുകൾ വഴിയും ടാബ്, എൻ്റർ കീകൾ അമർത്തിയും ഉറവിട ഡാറ്റ മൂല്യങ്ങൾ പരസ്പരം വേർതിരിക്കാനാകും.

പ്രോഗ്രാമിൻ്റെ ഫലങ്ങൾ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുന്നതിന്, ഇനിപ്പറയുന്ന ഓപ്പറേറ്റർമാർ ഉപയോഗിക്കുന്നു:

എഴുതുക(A1,A2,...AK);

WriteLn(A1,A2,...AK);

ഈ ഓപ്പറേറ്റർമാരിൽ ആദ്യത്തേത് A1, A2,...,AK എന്നീ വേരിയബിളുകളുടെ മൂല്യങ്ങളുടെ ഔട്ട്പുട്ട് സ്ക്രീനിൻ്റെ ഒരു വരിയിലേക്ക് നടപ്പിലാക്കുന്നു. രണ്ടാമത്തെ ഓപ്പറേറ്റർ A1, A2, ..., AK എന്നീ വേരിയബിളുകളുടെ മൂല്യങ്ങളുടെ ഔട്ട്പുട്ടും അടുത്ത വരിയുടെ തുടക്കത്തിലേക്കുള്ള പരിവർത്തനവും നടപ്പിലാക്കുന്നു. മൂന്നാമത്തെ ഓപ്പറേറ്റർ ഒരു ലൈൻ ഒഴിവാക്കി അടുത്ത വരിയുടെ തുടക്കത്തിലേക്ക് നീങ്ങുന്നു.

ഔട്ട്പുട്ട് ലിസ്റ്റ് നിർമ്മിക്കുന്ന വേരിയബിളുകൾ പൂർണ്ണസംഖ്യ, യഥാർത്ഥ, പ്രതീകം അല്ലെങ്കിൽ ബൂളിയൻ തരങ്ങൾ ആകാം. വേരിയബിൾ പേരുകൾക്ക് പുറമേ, എക്സ്പ്രഷനുകളും സ്ട്രിംഗുകളും ഔട്ട്പുട്ട് ലിസ്റ്റിൻ്റെ ഒരു ഘടകമായി ഉപയോഗിക്കാം.

ഓരോ മൂല്യവും ഔട്ട്‌പുട്ട് ഫീൽഡിൻ്റെ വീതിക്ക് അനുസൃതമായി സ്‌ക്രീനിൻ്റെ ഒരു വരിയിലേക്ക് ഔട്ട്‌പുട്ട് ചെയ്യുന്നു, ഇത് ഭാഷയുടെ നിർദ്ദിഷ്ട നിർവ്വഹണത്താൽ നിർണ്ണയിക്കപ്പെടുന്നു.

ഔട്ട്‌പുട്ട് ഫീൽഡിലെ മൂല്യങ്ങളുടെ പ്രാതിനിധ്യത്തിൻ്റെ രൂപം വേരിയബിളുകളുടെയും എക്‌സ്‌പ്രഷനുകളുടെയും തരവുമായി പൊരുത്തപ്പെടുന്നു: പൂർണ്ണസംഖ്യ തരത്തിൻ്റെ മൂല്യങ്ങൾ ദശാംശ പൂർണ്ണസംഖ്യകളായി ഔട്ട്‌പുട്ട് ചെയ്യുന്നു, യഥാർത്ഥ തരത്തിൻ്റെ - ദശാംശ ക്രമത്തിലുള്ള യഥാർത്ഥ ദശാംശ സംഖ്യകളായി, പ്രതീകത്തിൻ്റെ ടൈപ്പും സ്ട്രിംഗും - പ്രതീകങ്ങളായി, ലോജിക്കൽ തരത്തിൽ - ലോജിക്കൽ സ്ഥിരാങ്കങ്ങളായി TRUE ഉം FALSE ഉം.

ഔട്ട്പുട്ട് ലിസ്റ്റിലെ ഓരോ ഘടകത്തിനും ഔട്ട്പുട്ട് ഫീൽഡിൻ്റെ വീതി സജ്ജമാക്കാൻ ഔട്ട്പുട്ട് ഓപ്പറേറ്റർ നിങ്ങളെ അനുവദിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ഔട്ട്പുട്ട് ലിസ്റ്റ് ഘടകത്തിന് A:K എന്ന ഫോം ഉണ്ട്, ഇവിടെ A എന്നത് ഒരു എക്സ്പ്രഷൻ അല്ലെങ്കിൽ സ്ട്രിംഗ് ആണ്, K എന്നത് ഒരു എക്സ്പ്രഷൻ അല്ലെങ്കിൽ ഒരു പൂർണ്ണസംഖ്യ സ്ഥിരാങ്കമാണ്. ഔട്ട്‌പുട്ട് ഫീൽഡിൽ K എന്നതിനേക്കാൾ കുറച്ച് സ്ഥാനങ്ങൾ ഔട്ട്‌പുട്ട് മൂല്യം ഉൾക്കൊള്ളുന്നുവെങ്കിൽ, ഈ മൂല്യത്തിന് മുമ്പായി സ്‌പെയ്‌സുകൾ സ്ഥാപിക്കും. പ്രദർശിപ്പിച്ച മൂല്യം K ഫീൽഡിൻ്റെ വീതിയുമായി പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, ഈ മൂല്യത്തിന് ആവശ്യമായ സ്ഥാനങ്ങളുടെ എണ്ണം അനുവദിക്കും. ഒരു യഥാർത്ഥ തരത്തിൻ്റെ മൂല്യങ്ങൾക്കായി, ഔട്ട്‌പുട്ട് ലിസ്റ്റിലെ ഒരു ഘടകത്തിന് A:K:M എന്ന ഫോം ഉണ്ടായിരിക്കാം, ഇവിടെ A എന്നത് ഒരു യഥാർത്ഥ തരത്തിൻ്റെ വേരിയബിളോ എക്‌സ്‌പ്രഷനോ ആണ്, K എന്നത് ഔട്ട്‌പുട്ട് ഫീൽഡിൻ്റെ വീതിയും M എന്നത് സംഖ്യയുമാണ്. ഔട്ട്പുട്ട് മൂല്യത്തിൻ്റെ ഫ്രാക്ഷണൽ ഭാഗത്തിൻ്റെ അക്കങ്ങളുടെ. K, M എന്നിവ ഒരു പൂർണ്ണസംഖ്യയുടെ പദപ്രയോഗങ്ങളോ സ്ഥിരാങ്കങ്ങളോ ആണ്. ഈ സാഹചര്യത്തിൽ, യഥാർത്ഥ മൂല്യങ്ങൾ നിശ്ചിത-പോയിൻ്റ് ദശാംശ രൂപത്തിൽ ഔട്ട്പുട്ട് ചെയ്യുന്നു. ഔട്ട്പുട്ട് പ്രസ്താവനകൾ എഴുതുന്നതിനുള്ള ഒരു ഉദാഹരണം:

. . . . . . . . . . . .

var rA, rB: യഥാർത്ഥം; iP,iQ:Integer;

bR, bS: ബൂളിയൻ; chT, chV, chU, chW: Char;

. . . . . . . . . . . .

WriteLn(rA, rB:10:2);

WriteLn(iP, iQ:8);

WriteLn(bR, bS:8);

WriteLn(chT, chV, chU, chW);

ടാഗുകൾ. ഉപാധികളില്ലാത്ത ജമ്പ് ഓപ്പറേറ്റർ.

തെരുവിലെ ഓരോ വീടിനും അതിൻ്റേതായ നമ്പർ ഉണ്ട്, എല്ലാ ആളുകൾക്കും അവരുടേതായ പേരുകളുണ്ട്, കമ്പ്യൂട്ടർ മെമ്മറി സെല്ലുകൾക്ക് പോലും ഓരോന്നിനും അവരുടേതായ വിലാസമുണ്ട്. നിർവചിക്കപ്പെട്ടിരിക്കുന്ന വസ്തുവിനെ അവ്യക്തമായി സൂചിപ്പിക്കാൻ കഴിയുന്നതിനാണ് ഇതെല്ലാം എടുത്തത്. അതുപോലെ, പ്രോഗ്രാമുകളിലെ പ്രസ്താവനകൾ സൂചിപ്പിക്കാൻ ലേബലുകൾ ഉപയോഗിക്കുന്നു.

പാസ്കൽ ഭാഷാ സ്റ്റാൻഡേർഡിലെ ഒരു ലേബൽ ഒരു നോൺ-നെഗറ്റീവ് പൂർണ്ണസംഖ്യയാണ്. പ്രോഗ്രാമിൽ ഉപയോഗിക്കുന്ന എല്ലാ ലേബലുകളും ലേബൽ വിവരണ വിഭാഗത്തിൽ ലിസ്റ്റ് ചെയ്തിരിക്കണം, സേവന പദമായ ലേബലിൽ നിന്ന് ആരംഭിക്കുന്നു, ഉദാഹരണത്തിന്:

ഒരു ഓപ്പറേറ്ററെ മാത്രമേ ഒരു ലേബൽ കൊണ്ട് അടയാളപ്പെടുത്താൻ കഴിയൂ. അടയാളപ്പെടുത്തിയ പ്രസ്താവനയിൽ നിന്ന് ഒരു കോളൻ ഉപയോഗിച്ച് ലേബൽ വേർതിരിച്ചിരിക്കുന്നു.

6: Writeln(14/2);

മുമ്പത്തെ എല്ലാ പ്രോഗ്രാമുകളിലും, പ്രസ്താവനകൾ ടെക്സ്റ്റിൽ എഴുതിയിരിക്കുന്ന ക്രമത്തിൽ ഒന്നിനുപുറകെ ഒന്നായി നടപ്പിലാക്കി. ഈ അൽഗോരിതം ഘടനയെ നേരിട്ടുള്ള പിന്തുടർച്ച എന്ന് വിളിക്കുന്നു. എന്നിരുന്നാലും, പാസ്കൽ ഭാഷയിൽ തുടക്കത്തിൽ പ്രോഗ്രാമിൻ്റെ ലീനിയർ എക്സിക്യൂഷൻ തടസ്സപ്പെടുത്തുന്ന ഒരു ഓപ്പറേറ്റർ ഉണ്ട്, നിയന്ത്രണം ഒരു ഏകപക്ഷീയമായ പോയിൻ്റിലേക്ക് മാറ്റുന്നു. ഈ നിർദ്ദേശത്തെ നിരുപാധിക ജമ്പ് എന്ന് വിളിക്കുന്നു കൂടാതെ ഇനിപ്പറയുന്ന ഫോർമാറ്റുമുണ്ട്:

ഗോട്ടോ<метка>;

പരിവർത്തനം സംഭവിക്കുന്ന ഓപ്പറേറ്ററെ ഈ ലേബൽ ഉപയോഗിച്ച് അടയാളപ്പെടുത്തിയിരിക്കണം.

തെറ്റായ ഫലങ്ങൾ ലഭിക്കാതിരിക്കാനും പ്രോഗ്രാം പൂർണ്ണമായും ലൂപ്പ് ചെയ്യാതിരിക്കാനും നിരുപാധികമായ ജമ്പ് ഓപ്പറേറ്റർ അതീവ ജാഗ്രതയോടെ ഉപയോഗിക്കണം. പൊതുവേ, പ്രോഗ്രാമർമാർക്കിടയിൽ ഈ കമാൻഡ് ഉപയോഗിക്കുന്നത് മോശം രൂപമായി കണക്കാക്കപ്പെടുന്നു. നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഇത് കൂടാതെ ചെയ്യാൻ എല്ലായ്പ്പോഴും സാധ്യമാണ്.

ഘടനാപരമായ പ്രോഗ്രാമിംഗിൻ്റെ ഘടകങ്ങൾ

ഒരു സ്ട്രക്ചർഡ് പ്രോഗ്രാം (അല്ലെങ്കിൽ ഉപപ്രോഗ്രാം) എന്നത് ഒരു നിശ്ചിത അടിസ്ഥാന ഘടനകൾ ഉൾക്കൊള്ളുന്ന ഒരു പ്രോഗ്രാമാണ്. അൽഗോരിതം സ്കീമുകളിൽ ഈ നിർമ്മാണങ്ങൾ രൂപപ്പെടുത്തുന്നതിനുള്ള അടിസ്ഥാന നിർവചനങ്ങളും രീതികളും നമുക്ക് പരിഗണിക്കാം.

പ്രവർത്തനങ്ങൾ, ഫോർക്കുകൾ, ലയനങ്ങൾ എന്നിവയിൽ നിന്ന് അടിസ്ഥാന ഘടനകൾ നിർമ്മിക്കപ്പെടുന്നു: താഴെ, ശാഖകൾ, ചക്രം. ഈ മൂന്ന് നിർമ്മാണങ്ങൾ മാത്രം ഉപയോഗിച്ച്, ഏത് പ്രശ്നവും പരിഹരിക്കുന്നതിന് നിങ്ങൾക്ക് ഒരു അൽഗോരിതം നടപ്പിലാക്കാൻ കഴിയും.

രണ്ടോ അതിലധികമോ പ്രവർത്തനങ്ങളുടെ തുടർച്ചയായ നിർവ്വഹണത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു നിർമ്മാണത്തെ താഴെ പറയുന്നതായി വിളിക്കുന്നു.

ഒരു ഫോർക്ക്, രണ്ട് ഓപ്പറേഷനുകൾ, ഒരു ലയനം എന്നിവ അടങ്ങുന്ന ഒരു നിർമ്മാണത്തെ ഫോർക്ക് എന്ന് വിളിക്കുന്നു. പ്രവർത്തനങ്ങളിലൊന്ന് നഷ്‌ടമായേക്കാം.

മുമ്പത്തെ പ്രവർത്തനങ്ങളിലേക്കോ ശാഖകളിലേക്കോ നയിക്കുന്ന നിയന്ത്രണ ലൈനുകളുള്ള ഒരു രൂപകൽപ്പനയെ ലൂപ്പ് എന്ന് വിളിക്കുന്നു.

ഇനിപ്പറയുന്ന, ബ്രാഞ്ചിംഗ്, ലൂപ്പിംഗ് കൺസ്ട്രക്‌റ്റുകളെ പ്രവർത്തനങ്ങളായി കണക്കാക്കാം, കാരണം അവയ്ക്ക് ഒരൊറ്റ ഇൻപുട്ടും ഒരൊറ്റ ഔട്ട്‌പുട്ടും ഉണ്ട്. പ്രവർത്തനങ്ങളുടെ അനിയന്ത്രിതമായ ശ്രേണിയെ ഒരു പ്രവർത്തനമായി പ്രതിനിധീകരിക്കാം.

GOTO ട്രാൻസിഷൻ ഓപ്പറേറ്റർ ഒഴികെ, ഏതെങ്കിലും പാസ്കൽ ഭാഷാ ഓപ്പറേറ്റർ (ലളിതമായ അല്ലെങ്കിൽ സംയുക്തം) അല്ലെങ്കിൽ ഒരു കൂട്ടം ഓപ്പറേറ്റർമാർക്ക് ഈ പ്രവർത്തനം നടപ്പിലാക്കാൻ കഴിയും.

പാസ്കൽ ഭാഷയിൽ അടിസ്ഥാന ഘടനകളുടെ എണ്ണം ആറായി വർദ്ധിപ്പിച്ചു, ഇവയാണ്:

പിന്തുടരുന്നു;

ശാഖകൾ;

മുൻകൂർ വ്യവസ്ഥയുള്ള ലൂപ്പ്;

പോസ്റ്റ് കണ്ടീഷൻ ഉള്ള ലൂപ്പ്;

പരാമീറ്റർ ഉള്ള ലൂപ്പ്;

സോപാധിക ഓപ്പറേറ്റർ

പ്രധാന അൽഗോരിതം ഘടനകളിൽ ഒന്ന് ബ്രാഞ്ചിംഗ് (ബദൽ) ആണ്.

വ്യവസ്ഥ പാലിക്കുകയാണെങ്കിൽ, നിർദ്ദേശം "1" നടപ്പിലാക്കും, ഇല്ലെങ്കിൽ, "2" നിർദ്ദേശം നടപ്പിലാക്കും. സർക്യൂട്ടിൽ രണ്ട് പ്രവർത്തനങ്ങൾ ഉണ്ടെങ്കിലും, വ്യവസ്ഥ തെറ്റോ ശരിയോ ആയതിനാൽ ഒരെണ്ണം മാത്രമേ നടപ്പിലാക്കൂ. മൂന്നാമതൊന്നുമില്ല. നിലവിലുള്ള സാഹചര്യങ്ങളെ ആശ്രയിച്ച്, നിങ്ങൾ ഒന്നോ അതിലധികമോ പ്രവർത്തനം നടത്തേണ്ട പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ ഈ സ്കീം നിങ്ങളെ അനുവദിക്കുന്നു. ഇത്തരത്തിലുള്ള പ്രശ്‌നങ്ങളുടെ എണ്ണം വളരെ വലുതാണ് എന്നതിൽ സംശയമില്ല. മാത്രമല്ല, വളരെ പ്രധാനപ്പെട്ട ഒരു ടാസ്‌ക്ക് കൊണ്ടുവരുന്നത് വളരെ ബുദ്ധിമുട്ടാണ്, ഇതിൻ്റെ എക്‌സിക്യൂഷൻ അൽഗോരിതം കമാൻഡുകളുടെ ലളിതമായ നേരിട്ടുള്ള ക്രമം ഉൾക്കൊള്ളുന്നു. ഒരു ഗണിത കോഴ്‌സിൽ നിന്ന് എടുത്ത ഒരു പ്രാകൃത ഉദാഹരണം പോലും, നിങ്ങൾ കാണുന്നത് പോലെ, ബ്രാഞ്ചിംഗ് ഉപയോഗിക്കാതെ പരിഹരിക്കാൻ കഴിയില്ല. അതിനാൽ, y=1/x എന്ന പദപ്രയോഗത്തിൻ്റെ മൂല്യം കണക്കാക്കേണ്ടത് ആവശ്യമാണ്. തന്നിരിക്കുന്ന ഫംഗ്‌ഷന് എല്ലായ്‌പ്പോഴും ഒരു മൂല്യം ഉണ്ടായിരിക്കില്ലെന്ന് നിങ്ങൾക്കറിയാം, അതായത്, എല്ലാ ആർഗ്യുമെൻ്റ് മൂല്യങ്ങൾക്കും ഫലമൂല്യം ഇല്ല. പൂജ്യം ഒരു ആർഗ്യുമെൻ്റായി സ്വീകരിക്കുമ്പോൾ പോലും, എക്സിക്യൂട്ടർ ഒരിക്കലും ഒരു അവസാനഘട്ടത്തിലേക്ക് കടക്കാത്ത വിധത്തിൽ അൽഗോരിതം രചിക്കുക എന്നതാണ് ഞങ്ങളുടെ ചുമതല. സ്വാഭാവിക ഭാഷയിൽ ഇത് രൂപപ്പെടുത്തുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല:

1. x ൻ്റെ മൂല്യം നേടുക.

2. x=0 ആണെങ്കിൽ, പദപ്രയോഗത്തിന് മൂല്യമില്ലെന്ന് റിപ്പോർട്ടുചെയ്യുക, അല്ലാത്തപക്ഷം, y 1/x ആയി കണക്കാക്കുക.

മുകളിലുള്ള അൽഗോരിതം ഘടനയാണ് ഈ രീതിയിൽ ഉപയോഗിക്കുന്നത്. ഇത് ലളിതമായ വാക്കുകളിൽ പ്രകടിപ്പിക്കാം:

എങ്കിൽ<усл.>(നിബന്ധന പാലിക്കുകയാണെങ്കിൽ)

അത്<действие 1>(അപ്പോൾ പ്രവർത്തനം നമ്പർ 1 നടത്തുക)

അല്ലാത്തപക്ഷം<действие 2>(അല്ലെങ്കിൽ - പ്രവർത്തനം നമ്പർ 2 നടത്തുക)

ഇത് പാസ്കലിൽ എങ്ങനെ എഴുതാം? അതെ, അതേ, ഇംഗ്ലീഷിൽ മാത്രം.

പാസ്കലിലെ സോപാധിക ഓപ്പറേറ്ററുടെ ഫോർമാറ്റ്:

എങ്കിൽ<условие>

പിന്നെ<оператор 1>

വേറെ<оператор 2>;

അന്നും മറ്റുമുള്ള ഭാഗങ്ങളിൽ ഒരു പ്രസ്താവന മാത്രമേ ഉള്ളൂ എന്നത് ശ്രദ്ധിക്കുക. എന്നാൽ ഒരു പ്രശ്നം പരിഹരിക്കാൻ എന്തുചെയ്യണം, അതിൽ, ഒരു വ്യവസ്ഥയെ തൃപ്തിപ്പെടുത്തുന്നതിനോ നിറവേറ്റാത്തതിനോ, നിങ്ങൾ ഒന്നല്ല, നിരവധി പ്രവർത്തനങ്ങൾ ചെയ്യേണ്ടതുണ്ട്? ഇവിടെയാണ് നിങ്ങൾക്ക് ഇതിനകം പരിചയമുള്ള കോമ്പൗണ്ട് ഓപ്പറേറ്റർ രക്ഷാപ്രവർത്തനത്തിലേക്ക് വരുന്നത്. നിങ്ങൾക്ക് ഓപ്പറേറ്റർ ബ്രാക്കറ്റിനുള്ളിൽ എത്ര ഓപ്പറേറ്റർമാരെയും ഉൾപ്പെടുത്താം.

ഈ സാഹചര്യത്തിൽ സോപാധിക ഓപ്പറേറ്ററുടെ ഒരു വകഭേദം:

എങ്കിൽ<условие>

അപ്പോൾ ആരംഭിക്കുക<группа операторов 1>അവസാനിക്കുന്നു

അല്ലാത്തത് ആരംഭിക്കുക< группа операторов 2>അവസാനിക്കുന്നു;

Else ഫംഗ്‌ഷൻ പദത്തിന് മുമ്പായി അർദ്ധവിരാമം സ്ഥാപിച്ചിട്ടില്ല, എന്നാൽ ഗ്രൂപ്പുകളിലെ പ്രസ്താവനകൾ സ്വാഭാവികമായും ഈ അർദ്ധവിരാമത്താൽ പരസ്പരം വേർതിരിക്കപ്പെടുന്നു.

ഇനി നമുക്ക് വ്യവസ്ഥകളെക്കുറിച്ച് സംസാരിക്കാം. പാസ്കൽ പ്രോഗ്രാമുകളിൽ, വ്യവസ്ഥകൾ എന്നത് ഒരു ബൂളിയൻ മൂല്യമുള്ള എക്സ്പ്രഷനുകളാണ്. ഇത് നിർദ്ദിഷ്ട തരത്തിലുള്ള ഒരു ലളിതമായ വേരിയബിളോ ലോജിക്കൽ ഓപ്പറേഷനുകളാൽ ബന്ധിപ്പിച്ചിരിക്കുന്ന പ്രസ്താവനകളുടെ ഒരു സങ്കീർണ്ണ ശ്രേണിയോ ആകാം.

ലളിതമായ സാഹചര്യങ്ങളിൽ, താരതമ്യ ഓപ്പറേറ്ററുകൾ ഉപയോഗിക്കാം: >(അതിനേക്കാൾ വലുത്),<(меньше), =(равно), <>(തുല്യമല്ല), >= (കൂടുതൽ അല്ലെങ്കിൽ തുല്യം),<=(меньше или равно).

ലളിതമായ വ്യവസ്ഥകളുടെ ഉദാഹരണങ്ങൾ: A=5 (വേരിയബിളിൻ്റെ മൂല്യം 5 ആണ്)

(C+D3)>=(D1*(45-2)) (ഇടത് വശത്തുള്ള എക്‌സ്‌പ്രെഷൻ്റെ മൂല്യം വലതുവശത്തുള്ള എക്‌സ്‌പ്രഷൻ്റെ മൂല്യത്തേക്കാൾ വലുതോ തുല്യമോ ആണ്)

എസ്<>"ABC" (വേരിയബിൾ S ൻ്റെ മൂല്യം "ABC" എന്ന സ്ട്രിംഗ് സ്ഥിരാങ്കത്തിന് തുല്യമല്ല)

മറ്റൊരു പ്രശ്നം പരിഹരിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം നൽകാം: "രണ്ട് സംഖ്യകളിൽ ഏറ്റവും വലുത് തിരഞ്ഞെടുക്കുക."

ഒറ്റനോട്ടത്തിൽ, പരിഹാരം വ്യക്തമാണ്, പക്ഷേ അത് തോന്നുന്നത്ര നിസ്സാരമല്ല.

പ്രോഗ്രാം ഉദാഹരണം;

Var A,B,C: യഥാർത്ഥം; (എ, ബി - ആർഗ്യുമെൻ്റുകൾ സംഭരിക്കുന്നതിന്, സി - ഫലം)

Writeln("രണ്ട് അക്കങ്ങൾ നൽകുക");

Readln(A,B); (കീബോർഡിൽ നിന്ന് ആർഗ്യുമെൻ്റുകൾ നൽകുക)

A>B ആണെങ്കിൽ C:=A വേറെ C:=B; (A>B ആണെങ്കിൽ, ഫലം A ആണ്, അല്ലാത്തപക്ഷം ഫലം B ആണ്)

WriteIn(C); (ഞങ്ങൾ ഫലം സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുന്നു)

മറ്റൊരു മികച്ച ഉദാഹരണം: "നൽകിയ ഗുണകങ്ങൾ ഉപയോഗിച്ച് ഒരു ക്വാഡ്രാറ്റിക് സമവാക്യം പരിഹരിക്കുക." ഈ ടാസ്ക് കൂടുതൽ സങ്കീർണ്ണമാണ്, അതിനാൽ പ്രോഗ്രാം എഴുതുന്നതിന് മുമ്പ്, നമുക്ക് ഒരു അൽഗോരിതം ഉണ്ടാക്കാം, അത് ഒരു ബ്ലോക്ക് ഡയഗ്രം രൂപത്തിൽ എഴുതുക.ആദ്യം, ഞങ്ങൾ കോഫിഫിഷ്യൻറുകൾ നൽകുക, തുടർന്ന് ഞങ്ങൾ വിവേചനം കണക്കാക്കുന്നു. ഇപ്പോൾ രണ്ട് സാധ്യതകൾ ഉയർന്നുവരുന്നു: ഒന്നുകിൽ ഒരു നിഷേധാത്മക വിവേചനത്തിൻ്റെ കാര്യത്തിൽ യഥാർത്ഥ വേരുകൾ ഇല്ല, അല്ലെങ്കിൽ ഈ വേരുകൾ ഇപ്പോഴും കണക്കാക്കുകയും ഒരു നോൺ-നെഗറ്റീവ് വിവേചനത്തിൻ്റെ കാര്യത്തിൽ പ്രദർശിപ്പിക്കുകയും ചെയ്യാം (വിവേചനക്കാരൻ പൂജ്യത്തിന് തുല്യമായ കാര്യം ഇവിടെ ഉൾപ്പെടുത്തിയിരിക്കുന്നു. , രണ്ട് വേരുകൾ ഉണ്ട്, അവ ഒരേ ജെ).

ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയിൽ ഒരു അൽഗോരിതം എഴുതുമ്പോൾ, "ഇല്ല" എന്ന ശാഖയിൽ ഒരു പ്രവർത്തനമല്ല, മൂന്നെണ്ണം ഉണ്ടെന്ന് നിങ്ങൾ കണക്കിലെടുക്കണം, അതിനാൽ നിങ്ങൾ ഒരു സംയുക്ത ഓപ്പറേറ്റർ ഉപയോഗിക്കണം. പാസ്കൽ ഭാഷയുടെ നിയമങ്ങൾക്കനുസൃതമായി ഗണിത പദപ്രയോഗങ്ങൾ എഴുതാൻ മറക്കരുത്. അല്ലെങ്കിൽ, ഈ പ്രോഗ്രാം മുമ്പത്തേതിനേക്കാൾ സങ്കീർണ്ണമല്ല.

Var A, B, C, D, X1, X2: യഥാർത്ഥം;

Writeln("ക്വാഡ്രാറ്റിക് സമവാക്യത്തിൻ്റെ ഗുണകങ്ങൾ നൽകുക");

എങ്കിൽ ഡി<0 Then Writeln ("Корней нет! ")

X1:=(-B+SQRT(D))/2/A;

X2:=(-B-SQRT(D))/2/A;

ഒരു വ്യവസ്ഥ പാലിക്കപ്പെടുമ്പോഴോ പാലിക്കപ്പെടാതിരിക്കുമ്പോഴോ നടപ്പിലാക്കുന്ന ഒരു ഓപ്പറേറ്ററായി സോപാധിക ഓപ്പറേറ്റർക്ക് പ്രവർത്തിക്കാൻ കഴിയുമെന്നത് രസകരമാണ്. ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ നെസ്റ്റിംഗ് സോപാധിക പ്രസ്താവനകളെക്കുറിച്ച് സംസാരിക്കുന്നു. ഇത്തരത്തിലുള്ള പ്രശ്നങ്ങൾ പരിഹരിക്കുമ്പോൾ, ഒരു നോട്ട്ബുക്കിൽ അൽഗോരിതം ഫ്ലോചാർട്ട് വരയ്ക്കാൻ ഞാൻ ശക്തമായി ശുപാർശ ചെയ്യുന്നു. അതിനുശേഷം മാത്രമേ, പ്രോഗ്രാം രചിക്കുമ്പോൾ, നിങ്ങൾ ചെയ്യേണ്ടത്, ആദ്യം ഭാഗം മുഴുവൻ ശ്രദ്ധാപൂർവ്വം എഴുതുക, തുടർന്ന് മറ്റ് ഭാഗത്തേക്ക് പോകുക. സാധാരണയായി, പാസ്കലിൽ സോപാധികമായ പ്രസ്താവനകൾ എഴുതുമ്പോൾ (പ്രത്യേകിച്ച് ഒന്നിലധികം ബ്രാഞ്ചുകൾക്കൊപ്പം), കമാൻഡുകൾ വലത്തോട്ടും താഴോട്ടും ഇൻഡൻ്റ് ചെയ്താണ് എഴുതുന്നത്. ഇത് ദൃശ്യപരത വർദ്ധിപ്പിക്കുന്നു, എന്നെ വിശ്വസിക്കൂ, ഡീബഗ്ഗിംഗിൽ പാഴായ സമയം കുറയ്ക്കുന്നു.

ചിത്രീകരിക്കുന്നതിന്, നമുക്ക് മറ്റൊരു പ്രശ്നം പരിഹരിക്കാം: "A*x^2 + B*x + C = 0 എന്ന ഫോമിൻ്റെ ഒരു സമവാക്യം പരിഹരിക്കുക." ദയവായി ഒരു ക്വാഡ്രാറ്റിക് സമവാക്യവുമായി അതിനെ ആശയക്കുഴപ്പത്തിലാക്കരുത്, അതിനായി കോഫിഫിഷ്യൻ്റ് എ പൂജ്യത്തിന് തുല്യമല്ലെന്ന് ഞങ്ങൾക്ക് അറിയാമായിരുന്നു. ഇവിടെ ഗുണകങ്ങൾ ഏതെങ്കിലും സംഖ്യകളാകാം. പ്രാഥമിക ഗണിത യുക്തിയെ അടിസ്ഥാനമാക്കി, ഞങ്ങൾ ഇനിപ്പറയുന്ന അൽഗോരിതം നേടുന്നു:

Var A, B, C, D, X, X1, X2: യഥാർത്ഥം;

Writeln("സമവാക്യത്തിൻ്റെ ഗുണകങ്ങൾ നൽകുക (A, B, C)");

C=0 ആണെങ്കിൽ എഴുതുക ("X എന്നത് ഏതെങ്കിലും സംഖ്യയാണ്")

എൽസ് റൈറ്റ്ൺ ("വേരുകളില്ല!")

മറ്റ് ആരംഭം X:=-C/B; Writeln("X=",X:8:3) അവസാനം

എങ്കിൽ ഡി<0 Then Writeln ("Корней нет! ")

X1:=(-B+SQRT(D))/2/A;

X2:=(-B-SQRT(D))/2/A;

Writeln("X1=", X1:8:3, " X2=",X2:8:3)

സൈക്കിൾ. സൈക്കിളുകളുടെ തരങ്ങൾ.

ഒരേ തരത്തിലുള്ള പ്രവർത്തനത്തിൻ്റെ ആവർത്തിച്ചുള്ള ആവർത്തനമാണ് ചക്രം. സൈക്കിളിൻ്റെ ശരീരം പല തവണ ആവർത്തിക്കേണ്ട അതേ പ്രവർത്തനങ്ങളായിരിക്കും.

നിങ്ങൾ മനസ്സിലാക്കുന്നതുപോലെ, നിരുപാധികമായ ജമ്പ് ഓപ്പറേറ്റർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് സമാന പ്രവർത്തനങ്ങൾ ആവർത്തിക്കാം. നിങ്ങൾ പ്രോഗ്രാമിൽ ഈ പ്രവർത്തനങ്ങൾ ഒന്നിനുപുറകെ ഒന്നായി എഴുതുകയാണെങ്കിൽ, അവസാനം ഈ ബ്ലോക്കിൻ്റെ തുടക്കത്തിലേക്ക് ഒരു ജമ്പ് ഓപ്പറേറ്റർ ഇടുക. എന്നിരുന്നാലും, ഈ രീതിയിൽ നിങ്ങൾക്ക് എന്നേക്കും പ്രവർത്തിക്കുന്ന ഒരു പ്രോഗ്രാം മാത്രമേ ലഭിക്കൂ (ലൂപ്പുകൾ). ട്രാൻസിഷൻ ഓപ്പറേറ്ററുമായി ചേർന്ന് ഒരു സോപാധിക ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഇത് ഒഴിവാക്കാനാകും, ഇത് ഒരു നിശ്ചിത വ്യവസ്ഥയുടെ പൂർത്തീകരണത്തെ ആശ്രയിച്ചിരിക്കുന്നു. അങ്ങനെ, ഒരു സോപാധിക ജമ്പിൻ്റെ ഘടനയും അന്തിമ ലൂപ്പ് സംഘടിപ്പിക്കാനുള്ള കഴിവും നമുക്ക് ലഭിക്കും. പൊതുവായി പറഞ്ഞാൽ, ഒരു ചാക്രിക അൽഗോരിതം നടപ്പിലാക്കേണ്ട ഏത് പ്രശ്‌നവും ഈ രീതിയിൽ നമുക്ക് പരിഹരിക്കാനാകും. തീർച്ചയായും, ഒരു മഴു കൊണ്ട് നിങ്ങൾക്ക് ഒരു വീട് നിർമ്മിക്കാൻ കഴിയും. നമുക്ക് ഇനിപ്പറയുന്ന ചോദ്യങ്ങൾ സ്വയം ചോദിക്കാം: "ഈ വീട് മനോഹരമാകുമോ? എല്ലാത്തരം പ്രത്യേക ഉപകരണങ്ങളും ഉപയോഗിച്ച് നിങ്ങൾക്ക് എത്ര സമയവും പരിശ്രമവും ലാഭിക്കാം?" എന്തിനുവേണ്ടി? - സൗകര്യത്തിനും, സംക്ഷിപ്തതയ്ക്കും, പ്രോഗ്രാം വായിക്കാനുള്ള എളുപ്പത്തിനും ഒപ്പം, ഞാൻ അത് പറയാൻ ധൈര്യപ്പെടുന്നു, സൗന്ദര്യം. അതിനാൽ, മൂന്ന് തരം ലൂപ്പുകൾ ഉണ്ട്, അവ എഴുതുന്നതിന് സ്വന്തമായി പാസ്കൽ ഓപ്പറേറ്റർമാരുണ്ട്. ഈ തരങ്ങൾക്ക് അവരുടേതായ പരമ്പരാഗത പേരുകളുണ്ട്: "വേളയിൽ", "മുമ്പ്", "പാരാമീറ്ററിനൊപ്പം". അവ പരസ്പരം അൽപം വ്യത്യസ്തമാണ്, അവ ഓരോന്നും അവരുടേതായ ജോലികൾക്കായി ഉപയോഗിക്കുന്നു.

"ബൈ" സൈക്കിൾ

ഈ ഡയഗ്രം അനുസരിച്ച് "ലൂപ്പ് ബോഡി" എന്ന് വിളിക്കപ്പെടുന്ന ഒരു കൂട്ടം ഓപ്പറേറ്റർമാർ, ലൂപ്പ് അവസ്ഥ ശരിയാകുന്നിടത്തോളം എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. വ്യവസ്ഥ ശരിയല്ലാത്തപ്പോൾ ലൂപ്പ് പുറത്തുകടക്കുന്നു.

തുടക്കത്തിൽ വ്യവസ്ഥ തെറ്റാണെങ്കിൽ, ലൂപ്പിൻ്റെ ബോഡി ഒരിക്കൽ പോലും എക്സിക്യൂട്ട് ചെയ്യില്ല. ഈ അവസ്ഥ ആദ്യം ശരിയാണെങ്കിൽ, ഈ അവസ്ഥയുടെ സത്യത്തെ ബാധിക്കുന്ന പ്രവർത്തനങ്ങളൊന്നും ലൂപ്പ് ബോഡിയിൽ ഇല്ലെങ്കിൽ, ലൂപ്പ് ബോഡി അനന്തമായ തവണ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. ഈ അവസ്ഥയെ "ലൂപ്പിംഗ്" എന്ന് വിളിക്കുന്നു. ഒരു പ്രസ്താവനയിലൂടെ (Ctrl+C അമർത്തിക്കൊണ്ട്) അല്ലെങ്കിൽ പ്രോഗ്രാമിൻ്റെ അടിയന്തര സ്റ്റോപ്പ് വഴി ലൂപ്പിംഗ് പ്രോഗ്രാമിനെ തടസ്സപ്പെടുത്താം, വേരിയബിൾ ഓവർഫ്ലോ, പൂജ്യം കൊണ്ട് വിഭജനം മുതലായവ ഉണ്ടാകുമ്പോൾ, ലൂപ്പ് ഘടന ഉപയോഗിക്കണം. ആവർത്തിച്ചുള്ള നിർവ്വഹണം ചിലപ്പോൾ എപ്പോഴെങ്കിലും അവസാനിക്കുമെന്ന് നന്നായി മനസ്സിലാക്കുക.

പാസ്കലിൽ, while ലൂപ്പിൻ്റെ ഘടന ഇനിപ്പറയുന്ന രീതിയിൽ എഴുതിയിരിക്കുന്നു:

അതേസമയം<условие>ചെയ്യുക<оператор>;

ശരിക്കും, സംക്ഷിപ്തമായി? റഷ്യൻ ഭാഷയിൽ ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ വായിക്കാം: "വ്യവസ്ഥ ശരിയാകുന്നിടത്തോളം, പ്രസ്താവന നടപ്പിലാക്കുക." ഇവിടെ, സോപാധിക പ്രസ്താവന ഫോർമാറ്റിലെന്നപോലെ, ഒരു പ്രസ്താവന മാത്രമേ എക്സിക്യൂട്ട് ചെയ്യാൻ ഉദ്ദേശിച്ചിട്ടുള്ളൂ. ഒന്നിലധികം പ്രവർത്തനങ്ങൾ നടത്തേണ്ടതുണ്ടെങ്കിൽ, ഒരു സംയുക്ത ഓപ്പറേറ്റർ ഉപയോഗിക്കാം. തുടർന്ന് ഓപ്പറേറ്റർ ഫോർമാറ്റ് ഇനിപ്പറയുന്ന ഫോം എടുക്കുന്നു:

അതേസമയം<условие>ചെയ്യുക

<оператор #1>;

<оператор #2>;

<оператор #3>;

സൈക്കിൾ "മുമ്പ്"

ഇത്തരത്തിലുള്ള ലൂപ്പ് മുമ്പത്തേതിൽ നിന്ന് വ്യത്യസ്തമാണ്, പ്രധാനമായും ലൂപ്പ് ബോഡിയുടെ ആവർത്തന അവസ്ഥയ്ക്കുള്ള പരിശോധന അതിന് മുമ്പല്ല, അതിനുശേഷമാണ്. അതിനാൽ, "മുമ്പ്" സൈക്കിളിനെ "പോസ്റ്റ് കണ്ടീഷനോടെ" സൈക്കിൾ എന്നും "വേളയിൽ" "മുൻകൂർ വ്യവസ്ഥയുള്ള" സൈക്കിൾ എന്നും വിളിക്കുന്നു.

ഒരു പുതിയ ആവർത്തനം (ലൂപ്പ് ബോഡിയുടെ റീ-എക്സിക്യൂഷൻ) സംഭവിക്കുന്നത് വ്യവസ്ഥ ശരിയായിരിക്കുമ്പോഴല്ല, മറിച്ച് അത് തെറ്റായിരിക്കുമ്പോഴാണ്. അതുകൊണ്ടാണ് ലൂപ്പിന് അതിൻ്റെ പേര് ലഭിച്ചത് (അനുബന്ധ വ്യവസ്ഥ പാലിക്കുന്നത് വരെ ലൂപ്പിൻ്റെ ബോഡി എക്സിക്യൂട്ട് ചെയ്യുക).

ഡാറ്റ ഇൻപുട്ട്- ഇത് ബാഹ്യ ഉപകരണങ്ങളിൽ നിന്ന് റാമിലേക്ക് വിവരങ്ങൾ കൈമാറുന്നതാണ്. ചട്ടം പോലെ, പരിഹരിക്കപ്പെടുന്ന പ്രശ്നത്തിൻ്റെ പ്രാരംഭ ഡാറ്റ നൽകി. ഉപസംഹാരം- റിവേഴ്സ് പ്രോസസ്സ്, റാമിൽ നിന്ന് ബാഹ്യ മീഡിയയിലേക്ക് ഡാറ്റ കൈമാറ്റം ചെയ്യുമ്പോൾ (പ്രിൻറർ, ഡിസ്പ്ലേ, മാഗ്നറ്റിക് ഉപകരണങ്ങൾ മുതലായവ). ഏത് പ്രശ്‌നവും പരിഹരിക്കുന്നതിൻ്റെ ഫലങ്ങൾ ഈ മീഡിയകളിലൊന്നിൽ പ്രദർശിപ്പിക്കണം.

കീബോർഡും ഡിസ്‌പ്ലേയുമാണ് (മോണിറ്റർ സ്‌ക്രീൻ) ഒരു വ്യക്തിഗത കമ്പ്യൂട്ടറിൻ്റെ പ്രധാന ഇൻപുട്ട്/ഔട്ട്‌പുട്ട് ഉപകരണങ്ങൾ. ഒരു വ്യക്തിയും പിസിയും തമ്മിലുള്ള സംഭാഷണം പ്രധാനമായും നടത്തുന്നത് ഈ ഉപകരണങ്ങളിലൂടെയാണ്.

ഇൻപുട്ട് ഓപ്പറേറ്റർ വായിക്കുക

കീബോർഡ് ഇൻപുട്ട് നടപടിക്രമത്തിന് (സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് വിളിക്കുന്നത്) ഇനിപ്പറയുന്ന ഫോർമാറ്റ് ഉണ്ട്:

വായിക്കുക(<список ввода>)

എവിടെ<список ввода>കോമകളാൽ വേർതിരിച്ചിരിക്കുന്ന വേരിയബിൾ പേരുകളുടെ ഒരു ശ്രേണിയാണ്. ഉറവിട ഡാറ്റ നൽകുമ്പോൾ, പ്രാതിനിധ്യത്തിൻ്റെ ബാഹ്യ രൂപത്തിൽ നിന്ന് ആന്തരിക രൂപത്തിലേക്ക് ഒരു പരിവർത്തനം സംഭവിക്കുന്നു, ഇത് വേരിയബിളുകളുടെ തരം അനുസരിച്ച് നിർണ്ണയിക്കപ്പെടുന്നു. ഇൻപുട്ട് ലിസ്റ്റ് നിർമ്മിക്കുന്ന വേരിയബിളുകൾ ഒന്നുകിൽ പൂർണ്ണസംഖ്യ, യഥാർത്ഥ അല്ലെങ്കിൽ പ്രതീക തരങ്ങൾ ആകാം. ബൂളിയൻ ഉറവിട ഡാറ്റ വായിക്കുന്നത് പാസ്കലിൽ അനുവദനീയമല്ല. സ്‌പെയ്‌സുകൾ വഴിയും ടാബ് കീകൾ അമർത്തിയും ഉറവിട ഡാറ്റ മൂല്യങ്ങൾ പരസ്പരം വേർതിരിക്കാനാകും നൽകുക.

ഒരു പ്രോഗ്രാമിൽ നിരവധി പ്രസ്താവനകൾ ഉണ്ടെങ്കിൽ വായിച്ചു, തുടർന്ന് അവയ്ക്കുള്ള ഡാറ്റ ഒരു സ്ട്രീമിൽ നൽകിയിട്ടുണ്ട്, അതായത്. ഒരു പ്രസ്താവനയ്ക്കുള്ള വേരിയബിൾ മൂല്യങ്ങൾ വായിച്ചതിനുശേഷം വായിച്ചുഅടുത്ത പ്രസ്‌താവനയ്‌ക്കുള്ള ഡാറ്റ സ്‌ക്രീനിലെ അതേ വരിയിൽ നിന്ന് വരിയുടെ അവസാനം വരെ വായിക്കുന്നു, തുടർന്ന് അത് അടുത്ത വരിയിലേക്ക് നീങ്ങുന്നു.

കീബോർഡ് ഇൻപുട്ട് ഓപ്പറേറ്ററിൻ്റെ മറ്റൊരു വകഭേദം ഇതാണ്:

Readln(<список ввода>)

ഈ ഓപ്പറേറ്റർ വ്യത്യസ്തമാണ് വായിച്ചുഒരു ഓപ്പറേറ്റർക്കുള്ള ലിസ്റ്റിലെ അവസാന മൂല്യം വായിച്ചതിനുശേഷം മാത്രം വായിക്കുകഅടുത്ത പ്രസ്താവനയ്ക്കുള്ള ഡാറ്റ പുതിയ വരിയുടെ തുടക്കം മുതൽ വായിക്കും.

ഔട്ട്പുട്ട് ഓപ്പറേറ്റർ എഴുതുക

ഡിസ്പ്ലേ സ്റ്റേറ്റ്മെൻ്റിന് (സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് നടപടിക്രമം എന്ന് വിളിക്കുന്നു) ഇനിപ്പറയുന്ന ഫോർമാറ്റ് ഉണ്ട്:

എഴുതുക(<список вывода>)

ഔട്ട്പുട്ട് ലിസ്റ്റ് നിർമ്മിക്കുന്ന വേരിയബിളുകൾ പൂർണ്ണസംഖ്യ, യഥാർത്ഥ, പ്രതീകം അല്ലെങ്കിൽ ബൂളിയൻ തരങ്ങൾ ആകാം. വേരിയബിൾ പേരുകൾക്ക് പുറമേ, എക്സ്പ്രഷനുകളും സ്ട്രിംഗുകളും ഔട്ട്പുട്ട് ലിസ്റ്റിൻ്റെ ഒരു ഘടകമായി ഉപയോഗിക്കാം. ഒരു വരിയിൽ ഒന്നിലധികം സംഖ്യകൾ പ്രദർശിപ്പിക്കുമ്പോൾ, അവ സ്‌പെയ്‌സുകളാൽ വേർതിരിക്കപ്പെടുന്നില്ല. പ്രോഗ്രാമർ തന്നെ ഈ വിഭജനം ശ്രദ്ധിക്കണം.

സ്ക്രീൻ പ്രദർശിപ്പിക്കുന്നതിനുള്ള രണ്ടാമത്തെ ഓപ്ഷൻ:

എഴുതിയത്(<список вывода>)

അതിൻ്റെ പ്രവർത്തനം ഓപ്പറേറ്ററിൽ നിന്ന് വ്യത്യസ്തമാണ് എഴുതുകഅതിൽ ലിസ്റ്റിലെ അവസാന മൂല്യം പ്രദർശിപ്പിച്ച ശേഷം, കഴ്സർ അടുത്ത വരിയുടെ തുടക്കത്തിലേക്ക് നീങ്ങുന്നു. ഓപ്പറേറ്റർ എഴുത്ത്, പാരാമീറ്ററുകൾ ഇല്ലാതെ എഴുതിയത്, ഒരു ലൈൻ ഫീഡിന് കാരണമാകുന്നു.

ഓരോ മൂല്യവും ഔട്ട്‌പുട്ട് ഫീൽഡിൻ്റെ വീതിക്ക് അനുസൃതമായി സ്‌ക്രീനിൻ്റെ ഒരു വരിയിലേക്ക് ഔട്ട്‌പുട്ട് ചെയ്യുന്നു, ഇത് ഭാഷയുടെ നിർദ്ദിഷ്ട നിർവ്വഹണത്താൽ നിർണ്ണയിക്കപ്പെടുന്നു. ഔട്ട്‌പുട്ട് ഫീൽഡിലെ മൂല്യങ്ങളുടെ പ്രാതിനിധ്യത്തിൻ്റെ രൂപം വേരിയബിളുകളുടെയും എക്‌സ്‌പ്രഷനുകളുടെയും തരവുമായി പൊരുത്തപ്പെടുന്നു: പൂർണ്ണസംഖ്യ തരത്തിൻ്റെ മൂല്യങ്ങൾ പൂർണ്ണ ദശാംശ സംഖ്യകളായി ഔട്ട്‌പുട്ട് ചെയ്യുന്നു, യഥാർത്ഥ തരത്തിൻ്റെ - ദശാംശ ക്രമമുള്ള യഥാർത്ഥ ദശാംശ സംഖ്യകളായി, പ്രതീക തരവും സ്ട്രിംഗും - പ്രതീകങ്ങളുടെ രൂപത്തിൽ, ലോജിക്കൽ തരം - ലോജിക്കൽ സ്ഥിരാങ്കങ്ങളുടെ രൂപത്തിൽ സത്യംഒപ്പം തെറ്റായ.

ഔട്ട്പുട്ട് ലിസ്റ്റിലെ ഓരോ ഘടകത്തിനും ഔട്ട്പുട്ട് ഫീൽഡിൻ്റെ വീതി സജ്ജമാക്കാൻ ഔട്ട്പുട്ട് ഓപ്പറേറ്റർ നിങ്ങളെ അനുവദിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ഔട്ട്പുട്ട് ലിസ്റ്റ് ഘടകത്തിന് A:K എന്ന ഫോം ഉണ്ട്, ഇവിടെ A എന്നത് ഒരു എക്സ്പ്രഷൻ അല്ലെങ്കിൽ സ്ട്രിംഗ് ആണ്, K എന്നത് ഒരു എക്സ്പ്രഷൻ അല്ലെങ്കിൽ ഒരു പൂർണ്ണസംഖ്യ സ്ഥിരാങ്കമാണ്. ഔട്ട്‌പുട്ട് ഫീൽഡിൽ K എന്നതിനേക്കാൾ കുറച്ച് സ്ഥാനങ്ങൾ ഔട്ട്‌പുട്ട് മൂല്യം ഉൾക്കൊള്ളുന്നുവെങ്കിൽ, ഈ മൂല്യത്തിന് മുമ്പായി സ്‌പെയ്‌സുകൾ സ്ഥാപിക്കും. പ്രദർശിപ്പിച്ച മൂല്യം K ഫീൽഡിൻ്റെ വീതിയുമായി പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, ഈ മൂല്യത്തിന് ആവശ്യമായ സ്ഥാനങ്ങളുടെ എണ്ണം അനുവദിക്കും. ഒരു യഥാർത്ഥ തരത്തിൻ്റെ മൂല്യങ്ങൾക്കായി, ഔട്ട്‌പുട്ട് ലിസ്റ്റിലെ ഒരു ഘടകത്തിന് A:K:M എന്ന ഫോം ഉണ്ടായിരിക്കാം, ഇവിടെ A എന്നത് ഒരു യഥാർത്ഥ തരത്തിൻ്റെ വേരിയബിളോ എക്‌സ്‌പ്രഷനോ ആണ്, K എന്നത് ഔട്ട്‌പുട്ട് ഫീൽഡിൻ്റെ വീതിയും M എന്നത് സംഖ്യയുമാണ്. ഔട്ട്പുട്ട് മൂല്യത്തിൻ്റെ ഫ്രാക്ഷണൽ ഭാഗത്തിൻ്റെ അക്കങ്ങളുടെ. K, M എന്നിവ ഒരു പൂർണ്ണസംഖ്യയുടെ പദപ്രയോഗങ്ങളോ സ്ഥിരാങ്കങ്ങളോ ആണ്. ഈ സാഹചര്യത്തിൽ, യഥാർത്ഥ മൂല്യങ്ങൾ നിശ്ചിത-പോയിൻ്റ് ദശാംശ രൂപത്തിൽ ഔട്ട്പുട്ട് ചെയ്യുന്നു.