പലതവണ ആവർത്തിക്കുന്ന ഒരു പ്രോഗ്രാമിന്റെ ഒരു ശകലമാണ് സൈക്കിൾ.
ജാവയിൽ രണ്ട് തരം ലൂപ്പുകൾ ഉണ്ട്: "വെയിൽ" ടൈപ്പ്, "എൻ-ടൈം" ടൈപ്പ്.
ആദ്യ തരം "വേളയിൽ" ചില വ്യവസ്ഥകൾ പാലിക്കുന്നിടത്തോളം ചില പ്രവർത്തനങ്ങൾ ആവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. ഉദാഹരണം: മൂന്ന് അക്കങ്ങളിൽ എത്തുന്നതുവരെ ഒരു സംഖ്യ 5 കൊണ്ട് വർദ്ധിപ്പിക്കുക.
രണ്ടാമത്തെ തരം "n-time" ചില പ്രവർത്തനങ്ങൾ മുൻകൂട്ടി നിശ്ചയിച്ചിട്ടുള്ള തവണ ആവർത്തിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്. ഉദാഹരണം: ഒരു സംഖ്യയെ 4 തവണ കൊണ്ട് ഗുണിക്കുക.
ലൂപ്പ് ചെയ്യുമ്പോൾ (വേളയിലും ചെയ്യുമ്പോഴും... പ്രസ്താവനകൾ ചെയ്യുമ്പോൾ)
അതേസമയം സ്റ്റേറ്റ്മെന്റ് അതിന്റെ പരാമീറ്റർ ശരിയാകുന്നിടത്തോളം നിർദ്ദിഷ്ട പ്രവർത്തനങ്ങൾ ആവർത്തിക്കുന്നു.
ഉദാഹരണത്തിന്, അത്തരമൊരു ലൂപ്പ് 4 തവണ എക്സിക്യൂട്ട് ചെയ്യും, കൂടാതെ "1 2 3 4" സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും:
Int i = 1; അതേസമയം (ഐ< 5) { System.out.print(i + " "); i++; }
അത്തരമൊരു ലൂപ്പ് ഒരിക്കൽ പോലും എക്സിക്യൂട്ട് ചെയ്യില്ല, സ്ക്രീനിൽ ഒന്നും പ്രദർശിപ്പിക്കില്ല:
Int i = 1; അതേസമയം (ഐ< 0) { System.out.print(i + " "); i++; }
ഈ ലൂപ്പ് അനന്തമായി പ്രവർത്തിക്കും, കൂടാതെ സ്ക്രീൻ "1 2 3 4 5 6 7..." പ്രദർശിപ്പിക്കും:
Int i = 1; അതേസമയം (ശരി) (System.out.print(i + ""); i++; )
ലൂപ്പ് വീണ്ടും ആവർത്തിക്കുമോ എന്ന് നിർണ്ണയിക്കുന്ന അവസ്ഥ, ആദ്യത്തേത് ഉൾപ്പെടെ, ലൂപ്പിന്റെ ഓരോ ഘട്ടത്തിനും മുമ്പായി പരിശോധിക്കുന്നു. എന്താണ് സംഭവിക്കുന്നതെന്ന് അവർ പറയുന്നു മുൻകൂട്ടി പരിശോധിക്കുകവ്യവസ്ഥകൾ.
കൂടെ "ബൈ" പോലെ ഒരു സൈക്കിൾ ഉണ്ട് പോസ്റ്റ്-ചെക്ക്വ്യവസ്ഥകൾ. ഇത് എഴുതാൻ, ഡു...വെയിൽ സ്റ്റേറ്റ്‌മെന്റുകൾ ഉപയോഗിക്കുന്നു.
ഈ ലൂപ്പ് 4 തവണ എക്സിക്യൂട്ട് ചെയ്യും, കൂടാതെ "2 3 4 5" സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും:
< 5);
ഈ ലൂപ്പ് 1 തവണ എക്സിക്യൂട്ട് ചെയ്യും, കൂടാതെ "2" സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും:
Int i = 1; ചെയ്യുക (i++; System.out.print(i + ""); ) അതേസമയം (i< 0);
ഒരു തവണയെങ്കിലും ലൂപ്പ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടുമ്പോൾ, ഡോയുടെ ബോഡി. പ്രോഗ്രാമിലെ ചില പ്രവർത്തനങ്ങൾ ഒരിക്കലെങ്കിലും നടത്തേണ്ടിവരുമ്പോൾ ഈ ഓപ്പറേറ്റർ ഉപയോഗിക്കാൻ സൗകര്യപ്രദമാണ്, എന്നാൽ ചില വ്യവസ്ഥകളിൽ ഇത് പലതവണ ആവർത്തിക്കേണ്ടിവരും.
ഇനിപ്പറയുന്ന പ്രോഗ്രാം പരിശോധിക്കുക (ഇത് ഒരു സെഗ്‌മെന്റിൽ നിന്ന് ഒരു റാൻഡം പൂർണ്ണസംഖ്യ ഊഹിക്കുകയും കീബോർഡിൽ നിന്ന് ഓപ്‌ഷനുകൾ നൽകി അത് ഊഹിക്കാൻ ഉപയോക്താവിനോട് ആവശ്യപ്പെടുകയും ചെയ്യുന്നു, ഉപയോക്താവ് നമ്പർ ഊഹിക്കുന്നത് വരെ, ഊഹിച്ച നമ്പർ കൂടുതലാണോ എന്ന് പറഞ്ഞുകൊണ്ട് പ്രോഗ്രാം അവനോട് ആവശ്യപ്പെടും. ഉപയോക്താവ് നൽകിയതിനേക്കാൾ കുറവ്):
java.util.Scanner ഇറക്കുമതി ചെയ്യുക; പബ്ലിക് ക്ലാസ് മെയിൻ (പബ്ലിക് സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ (സ്ട്രിംഗ് ആർഗ്സ്) ( // പ്രോഗ് - പ്രോഗ്രാം സൃഷ്ടിച്ച ഒരു നമ്പർ // ഉപയോക്താവ് - ഉപയോക്താവ് ഇൻറ്റ് പ്രോഗ് നൽകിയ ഒരു നമ്പർ, ഉപയോക്താവ്; // 1 മുതൽ 10 പ്രോഗ് വരെ റാൻഡം പൂർണ്ണസംഖ്യ സൃഷ്ടിക്കുക = (int)(Math. random() * 10) + 1; System.out.println("ഞാൻ 1 മുതൽ 10 വരെയുള്ള ഒരു സംഖ്യയെക്കുറിച്ച് ചിന്തിച്ചു, ഊഹിക്കുക."); System.out.print("നിങ്ങളുടെ നമ്പർ നൽകുക: " ); സ്കാനർ ഇൻപുട്ട് = പുതിയ സ്കാനർ ( System.in); // ഇൻപുട്ട് സ്ട്രീമിൽ ഒരു പൂർണ്ണസംഖ്യ ഉണ്ടോ എന്ന് പരിശോധിക്കുക if(input.hasNextInt()) ( ചെയ്യുക ( // ഇൻപുട്ട് സ്ട്രീം ഉപയോക്താവിൽ നിന്ന് ഒരു പൂർണ്ണസംഖ്യ വായിക്കുക = input.nextInt (); if(user == prog) ( System.out.println("നിങ്ങൾ അത് ഊഹിച്ചു!"); ) else ( // എങ്കിൽ (ഉപയോക്താവ് > 0 && ഉപയോക്താവ്) എന്ന വിഭാഗത്തിൽ നമ്പർ ഉൾപ്പെടുത്തിയിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക<= 10) { System.out.print("Вы не угадали! "); // Если число загаданное программой меньше... if(prog < user) { System.out.println("Моё число меньше."); } else { System.out.println("Моё число больше."); } } else { System.out.println("Ваше число вообще не из нужного отрезка!"); } } } while(user != prog); } else { System.out.println("Ошибка. Вы не ввели целое число!"); } System.out.println("До свиданья!"); } }
പ്രോഗ്രാമിൽ ഇനിപ്പറയുന്ന മാറ്റങ്ങൾ വരുത്തുക:
സെഗ്‌മെന്റിൽ നിന്നല്ല, പൂജ്യം ഒഴികെയുള്ള സെഗ്‌മെന്റിൽ നിന്നുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ് പ്രോഗ്രാം ചിന്തിക്കേണ്ടത്. അതേസമയം, പ്രോഗ്രാം സൃഷ്ടിക്കുന്ന ക്രമരഹിത സംഖ്യകളുടെ വിതരണം ഏകീകൃതമാണെന്ന് ഉറപ്പാക്കാൻ ശ്രമിക്കുക (അതായത്, ഒരു പൂജ്യം വീണാൽ, അത് മറ്റേതെങ്കിലും സംഖ്യ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാൻ കഴിയില്ല, ഉദാഹരണത്തിന്, 1 ഉപയോഗിച്ച്, കാരണം 1 ആയിരിക്കും ബാക്കിയുള്ള സംഖ്യകളേക്കാൾ ഇരട്ടി സംഭാവ്യതയോടെ കുറഞ്ഞു).
പ്രോഗ്രാം ഒരു പോസിറ്റീവ് നമ്പർ ഊഹിക്കുകയും ഉപയോക്താവ് നെഗറ്റീവ് ഒരെണ്ണം നൽകുകയും ചെയ്താൽ, ചിഹ്നത്തിൽ തെറ്റ് പറ്റിയെന്ന് പ്രോഗ്രാം ഉപയോക്താവിനോട് ആവശ്യപ്പെടണം. തിരിച്ചും.
N-ടൈം ലൂപ്പ് (പ്രസ്താവനയ്ക്കായി)
ഫോർ സ്റ്റേറ്റ്‌മെന്റിൽ മൂന്ന് പാരാമീറ്ററുകൾ അടങ്ങിയിരിക്കുന്നു. ആദ്യത്തേതിനെ ഇനീഷ്യലൈസേഷൻ എന്നും രണ്ടാമത്തേതിനെ ആവർത്തനാവസ്ഥ എന്നും മൂന്നാമത്തേതിനെ ആവർത്തനം എന്നും വിളിക്കുന്നു.
(ഇനിഷ്യലൈസേഷൻ; അവസ്ഥ; ആവർത്തനം) (//ലൂപ്പ് ബോഡി, അതായത് ചാക്രികമായി ആവർത്തിക്കുന്ന പ്രവർത്തനങ്ങൾ)
ആദ്യ പാരാമീറ്ററിൽ, ലൂപ്പിന്റെ ആവർത്തനങ്ങളുടെ എണ്ണം കണക്കാക്കാൻ ഉപയോഗിക്കുന്ന ചില വേരിയബിൾ നിങ്ങൾ സാധാരണയായി തിരഞ്ഞെടുക്കുന്നു. അതിനെ ഒരു കൗണ്ടർ എന്ന് വിളിക്കുന്നു. കൌണ്ടറിന് ചില പ്രാരംഭ മൂല്യം നൽകിയിരിക്കുന്നു (അത് ഏത് മൂല്യത്തിൽ നിന്ന് മാറുമെന്ന് അവർ സൂചിപ്പിക്കുന്നു).
രണ്ടാമത്തെ പാരാമീറ്റർ കൌണ്ടറിലെ ചില പരിമിതികളെ സൂചിപ്പിക്കുന്നു (അത് ഏത് മൂല്യത്തിലേക്ക് മാറുമെന്ന് സൂചിപ്പിക്കുക).
മൂന്നാമത്തെ പാരാമീറ്റർ ഓരോ ലൂപ്പ് ഘട്ടത്തിനും ശേഷം കൌണ്ടർ മാറ്റുന്ന ഒരു എക്സ്പ്രഷൻ വ്യക്തമാക്കുന്നു. സാധാരണയായി ഇതൊരു ഇൻക്രിമെന്റോ ഡിക്രിമെന്റോ ആണ്, എന്നാൽ കൗണ്ടറിന് കുറച്ച് പുതിയ മൂല്യം നൽകുന്ന ഏത് എക്സ്പ്രഷനും നിങ്ങൾക്ക് ഉപയോഗിക്കാം.
ലൂപ്പിന്റെ ആദ്യ ഘട്ടത്തിന് മുമ്പ്, കൌണ്ടറിന് ഒരു പ്രാരംഭ മൂല്യം നൽകിയിരിക്കുന്നു (ഇനിഷ്യലൈസേഷൻ നടപ്പിലാക്കുന്നു). ഇത് ഒരിക്കൽ മാത്രം സംഭവിക്കുന്നു.
ലൂപ്പിന്റെ ഓരോ ഘട്ടത്തിനും മുമ്പായി (എന്നാൽ സമാരംഭിച്ചതിന് ശേഷം), ആവർത്തന അവസ്ഥ പരിശോധിക്കുന്നു; അത് ശരിയാണെങ്കിൽ, ലൂപ്പിന്റെ ബോഡി വീണ്ടും എക്സിക്യൂട്ട് ചെയ്യുന്നു. അതേ സമയം, ആദ്യ പരിശോധനയുടെ സമയത്ത് വ്യവസ്ഥ തെറ്റാണെങ്കിൽ ലൂപ്പിന്റെ ബോഡി ഒരിക്കൽ പോലും എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയില്ല.
ലൂപ്പിന്റെ ഓരോ ഘട്ടവും പൂർത്തിയാക്കിയ ശേഷം അടുത്തത് ആരംഭിക്കുന്നതിന് മുമ്പ് (അതിനാൽ ആവർത്തന അവസ്ഥ പരിശോധിക്കുന്നതിന് മുമ്പ്), ഒരു ആവർത്തനം നടത്തുന്നു.
ഇനിപ്പറയുന്ന പ്രോഗ്രാം 1 മുതൽ 100 വരെയുള്ള നമ്പറുകൾ പ്രദർശിപ്പിക്കുന്നു:
ഇതിനായി (int i = 1; i<= 100; i++) { System.out.print(i + " "); }
ഇനിപ്പറയുന്ന പ്രോഗ്രാം 10 മുതൽ −10 വരെയുള്ള നമ്പറുകൾ പ്രദർശിപ്പിക്കുന്നു:
ഇതിനായി (int s = 10; s > -11; s--) ( System.out.print(s + ""); )
അവതരിപ്പിച്ച പ്രോഗ്രാം 1 മുതൽ 33 വരെയുള്ള ഒറ്റ സംഖ്യകൾ പ്രദർശിപ്പിക്കുന്നു:
ഇതിനായി (int i = 1; i<= 33; i = i + 2) { System.out.print(i + " "); }
അവതരിപ്പിച്ച പ്രോഗ്രാം 2, 4, 6, 8,... 98, 100 എന്ന ശ്രേണിയുടെ ഒരു ശകലത്തിന്റെ മൂലകങ്ങളുടെ ആകെത്തുക കണക്കാക്കും.
Int sum = 0; // (int j = 2; j. എന്നതിനായി ഞങ്ങൾ ഇവിടെ ഫലം ശേഖരിക്കും
അവതരിപ്പിച്ച പ്രോഗ്രാം ഒരു വേരിയബിളിൽ നിന്ന് ഒരു സംഖ്യ ഉയർത്തും എവേരിയബിളിൽ നിന്ന് സ്വാഭാവിക ഡിഗ്രിയിലേക്ക് എൻ:
ഇരട്ട a = 2; int n = 10; ഇരട്ട റെസ് = 1; // (int i = 1; i. എന്നതിനായി ഞങ്ങൾ ഇവിടെ ഫലം ശേഖരിക്കും<= n; i++) { res = res * a; } System.out.println(res);
അവതരിപ്പിച്ച പ്രോഗ്രാം 2n+2 ശ്രേണിയിലെ ആദ്യ 10 ഘടകങ്ങൾ പ്രദർശിപ്പിക്കും, ഇവിടെ n=1, 2, 3...:
ഇതിനായി (int i = 1; i< 11; i++) { System.out.print(2*i + 2 + " "); }
അവതരിപ്പിച്ച പ്രോഗ്രാം 2a n−1 +3 എന്ന ശ്രേണിയുടെ ആദ്യ 10 ഘടകങ്ങൾ പ്രദർശിപ്പിക്കും, ഇവിടെ a 1 =3:
Int a = 3; (i=1; i<=10;i++) { System.out.print(a + " "); a = 2*a + 3; }
ഒരു സൈക്കിളിൽ, നിങ്ങൾക്ക് ഒരേസമയം നിരവധി കൗണ്ടറുകൾ സജ്ജമാക്കാൻ കഴിയും. ഈ സാഹചര്യത്തിൽ, ആവർത്തനത്തിലും സമാരംഭത്തിലും നിരവധി പദപ്രയോഗങ്ങൾ കോമകളാൽ വേർതിരിച്ചിരിക്കുന്നു. ഒരു ആവർത്തന വ്യവസ്ഥ മാത്രമേ വ്യക്തമാക്കാൻ കഴിയൂ, എന്നാൽ ഇത് ഒരേസമയം നിരവധി കൗണ്ടറുകൾ അടങ്ങിയ ഒരു പദപ്രയോഗമാകാം.
അവതരിപ്പിച്ച പ്രോഗ്രാം 2a n−1 -2 എന്ന ശ്രേണിയുടെ ആദ്യ 10 ഘടകങ്ങൾ പ്രദർശിപ്പിക്കും, ഇവിടെ a 1 =3:
ഇതിനായി (int a=3, i=1; i<=10; a=2*a-2, i++) { System.out.print(a + " "); }
അവതരിപ്പിച്ച പ്രോഗ്രാം ഇനിപ്പറയുന്ന ശ്രേണി "0 -1 -4 -9 -16 -25" പ്രദർശിപ്പിക്കും:
ഇതിനായി (int a=0, b=0; a-b<=10; a++, b--) { System.out.print(a*b + " "); }
ഒരു ലൂപ്പ് നേരത്തെ അവസാനിപ്പിക്കുന്നു (ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റ്)
നിങ്ങൾ ലൂപ്പ് ബോഡിക്കുള്ളിലെ ഓപ്പറേറ്ററെ വിളിക്കുകയാണെങ്കിൽ "വെയിൽ" ടൈപ്പ് ലൂപ്പും "എൻ-ടൈം" ടൈപ്പ് ലൂപ്പും നേരത്തെ അവസാനിപ്പിക്കാൻ കഴിയും. ബ്രേക്ക്. ഈ സാഹചര്യത്തിൽ, ലൂപ്പ് ഉടനടി പുറത്തുകടക്കും; നിലവിലെ ഘട്ടം പോലും പൂർത്തിയാകില്ല (അതായത്, ഇടവേളയ്ക്ക് ശേഷം മറ്റെന്തെങ്കിലും പ്രസ്താവനകൾ ഉണ്ടെങ്കിൽ, അവ എക്സിക്യൂട്ട് ചെയ്യില്ല).
ഇനിപ്പറയുന്ന ഉദാഹരണത്തിന്റെ ഫലമായി, "1 2 3 4 എൻഡ്" അക്കങ്ങൾ മാത്രമേ സ്ക്രീനിൽ ദൃശ്യമാകൂ:
ഇതിനായി (int a=1; a
പ്രോഗ്രാം അഞ്ചാം തവണയും ലൂപ്പ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ (5 ന് തുല്യമായ ഒരു കൗണ്ടറുള്ള ഒരു ലൂപ്പിലേക്ക് പ്രവേശിക്കുന്നു), ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റ് എക്സിക്യൂട്ട് ചെയ്യുന്ന അവസ്ഥ ഉടനടി പരിശോധിച്ച് ശരിയാണെന്ന് കണ്ടെത്തും. ലൂപ്പ് ബോഡിയുടെ ശേഷിക്കുന്ന ഭാഗം (സ്ക്രീനിലേക്കുള്ള ഔട്ട്പുട്ട്) നിർമ്മിക്കപ്പെടില്ല: ലൂപ്പിനും അതിനുശേഷവും വ്യക്തമാക്കിയ പ്രവർത്തനങ്ങൾ നടത്താൻ പ്രോഗ്രാം ഉടൻ തന്നെ തുടരും.
ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിച്ച്, നിങ്ങൾക്ക് വ്യക്തമായും അനന്തമായ ലൂപ്പിനെ തടസ്സപ്പെടുത്താം. ഉദാഹരണം (സ്ക്രീൻ "100 50 25 12 6 3 1 0" പ്രദർശിപ്പിക്കും, അതിനുശേഷം ലൂപ്പ് നിർത്തും):
Int s = 100; അതേസമയം (ശരി) (System.out.print(s + ""); s = s / 2; if(s == 0) (break; ) )
ചില അവസ്ഥകൾ ഉണ്ടാകുമ്പോൾ മാത്രം ബ്രേക്ക് ഓപ്പറേറ്ററെ വിളിക്കുന്നതിൽ അർത്ഥമുണ്ട്, അല്ലാത്തപക്ഷം ലൂപ്പ് അതിന്റെ ആദ്യ ഘട്ടത്തിൽ തന്നെ ഷെഡ്യൂളിന് മുമ്പായി പൂർത്തിയാകും.
Int a; (a=25; a>0; a--) (break; System.out.print(a + ""); ) System.out.print("a=" + a);
മുകളിലെ ഉദാഹരണത്തിൽ, ഒരു ലൂപ്പിലെ സ്ക്രീനിലേക്കുള്ള ഔട്ട്പുട്ട് ഒരിക്കൽ പോലും സംഭവിക്കില്ല, വേരിയബിൾ എപ്പോൾ എലൂപ്പിന് ശേഷം സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുന്നു, അതിന്റെ മൂല്യം ഒരിക്കലും മാറിയിട്ടില്ലെന്ന് മാറുന്നു, അതായത് "a=25" പ്രദർശിപ്പിക്കും (കൂടുതൽ ഒന്നുമില്ല).
ലൂപ്പ് ആരംഭിക്കുന്നതിന് മുമ്പ് വേരിയബിൾ പ്രഖ്യാപിച്ചിരുന്നു എന്നതും ശ്രദ്ധിക്കുക. ഒരു ലൂപ്പിന്റെ പാരാമീറ്ററുകളിൽ ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കുമ്പോൾ, അതിന് പുറത്ത് അത് ആക്സസ് ചെയ്യാൻ കഴിയാത്തതായി മാറുന്നു, എന്നാൽ ഈ സാഹചര്യത്തിൽ മറ്റെന്തെങ്കിലും ആവശ്യമാണ് - ലൂപ്പ് അവസാനിച്ചതിന് ശേഷം കൗണ്ടറിന് എന്ത് മൂല്യമുണ്ടെന്ന് കണ്ടെത്താൻ.
ചുമതലകൾ
1000 1003 1006 1009 1012 1015….
1 3 5 7 9 11 13 15 17 ….
90 85 80 75 70 65 60 ….
2 4 8 16 32 64 128 ….
2a n-1 -1 എന്ന ക്രമത്തിന്റെ എല്ലാ നിബന്ധനകളും പ്രദർശിപ്പിക്കുക, ഇവിടെ 1 =2, 10000-ൽ താഴെ.
2a n-1 +200 എന്ന ക്രമത്തിന്റെ എല്ലാ രണ്ടക്ക നിബന്ധനകളും പ്രദർശിപ്പിക്കുക, ഇവിടെ a 1 = -166.
കീബോർഡിൽ നിന്ന് ഉപയോക്താവ് നൽകുന്ന ഒരു സ്വാഭാവിക സംഖ്യയുടെ ഫാക്‌ടോറിയൽ കണക്കാക്കുന്ന ഒരു പ്രോഗ്രാം സൃഷ്ടിക്കുക.
കീബോർഡിൽ നിന്ന് ഉപയോക്താവ് നൽകിയ സ്വാഭാവിക സംഖ്യയുടെ എല്ലാ പോസിറ്റീവ് ഡിവൈസറുകളും പ്രദർശിപ്പിക്കുക.
കീബോർഡിൽ നിന്ന് ഉപയോക്താവ് നൽകിയ സ്വാഭാവിക നമ്പർ പ്രൈം ആണോ എന്ന് പരിശോധിക്കുക. അനാവശ്യമായ പ്രവർത്തനങ്ങൾ നടത്താതിരിക്കാൻ ശ്രമിക്കുക (ഉദാഹരണത്തിന്, നിങ്ങൾ കുറഞ്ഞത് ഒരു നോൺ-ട്രിവിയൽ ഡിവൈസർ കണ്ടെത്തിയതിന് ശേഷം, സംഖ്യ സംയോജിതമാണെന്നും പരിശോധന തുടരേണ്ട ആവശ്യമില്ലെന്നും ഇതിനകം വ്യക്തമാണ്). ഒരു സ്വാഭാവിക സംഖ്യ n ന്റെ ഏറ്റവും ചെറിയ ഹരിക്കൽ, അത് നിലവിലുണ്ടെങ്കിൽ, സെഗ്‌മെന്റിൽ സ്ഥിതിചെയ്യണം.
2a n-2 -2 എന്ന ശ്രേണിയിലെ ആദ്യത്തെ 12 ഘടകങ്ങൾ പ്രദർശിപ്പിക്കുന്ന ഒരു പ്രോഗ്രാം എഴുതുക, ഇവിടെ a 1 =3, a 2 =2.
ഫിബൊനാച്ചി ശ്രേണിയുടെ ആദ്യ 11 നിബന്ധനകൾ പ്രദർശിപ്പിക്കുക. ക്രമത്തിലെ ഒന്നാമത്തെയും രണ്ടാമത്തെയും നിബന്ധനകൾ ഒന്നിന് തുല്യമാണെന്നും അടുത്ത ഓരോന്നും മുമ്പത്തെ രണ്ടിന്റെയും ആകെത്തുകയാണെന്നും ഞങ്ങൾ നിങ്ങളെ ഓർമ്മിപ്പിക്കുന്നു.
കീബോർഡിൽ നിന്ന് ഉപയോക്താവ് നൽകിയ ഒരു സ്വാഭാവിക സംഖ്യയ്ക്ക്, അതിന്റെ എല്ലാ അക്കങ്ങളുടെയും ആകെത്തുക കണക്കാക്കുക (എത്ര അക്കങ്ങൾ നമ്പറിൽ ഉണ്ടായിരിക്കുമെന്ന് മുൻകൂട്ടി അറിയില്ല).
N നഗരത്തിൽ, പേപ്പർ ടിയർ-ഓഫ് ടിക്കറ്റുകൾ ഉപയോഗിച്ചാണ് ട്രാം യാത്ര നടത്തുന്നത്. എല്ലാ ആഴ്‌ചയും, ട്രാം ഡിപ്പോ 000001 മുതൽ 999999 വരെയുള്ള നമ്പറുകളുള്ള ടിക്കറ്റുകളുടെ ഒരു റോൾ ലോക്കൽ പ്രിന്റിംഗ് ഹൗസിൽ നിന്ന് ഓർഡർ ചെയ്യുന്നു. നമ്പറിന്റെ ആദ്യ മൂന്ന് അക്കങ്ങളുടെ ആകെത്തുക അവസാന മൂന്നിന്റെ ആകെത്തുകയ്ക്ക് തുല്യമാണെങ്കിൽ ഒരു ടിക്കറ്റ് "ഭാഗ്യം" ആയി കണക്കാക്കപ്പെടുന്നു. അക്കങ്ങൾ, ഉദാഹരണത്തിന്, 003102 അല്ലെങ്കിൽ 567576 നമ്പറുകളുള്ള ടിക്കറ്റുകളിൽ. ഓരോ ഭാഗ്യ ടിക്കറ്റിന്റെയും വിജയിക്ക് ഒരു സുവനീർ നൽകാൻ ട്രാം ഡിപ്പോ തീരുമാനിച്ചു, ഇപ്പോൾ എത്ര സുവനീറുകൾ വേണ്ടിവരുമെന്ന് ആശ്ചര്യപ്പെടുന്നു. പ്രോഗ്രാം ഉപയോഗിച്ച്, ഒരു റോളിൽ എത്ര ഭാഗ്യ ടിക്കറ്റുകൾ ഉണ്ടെന്ന് കണക്കാക്കുക?
N നഗരത്തിൽ 50,000 വ്യത്യസ്ത ഷെൽഫുകൾ ഉള്ള ഒരു വലിയ വെയർഹൗസ് ഉണ്ട്. തൊഴിലാളികളുടെ സൗകര്യാർത്ഥം, ഒരു പ്രാദേശിക പ്രിന്റിംഗ് ഹൗസിൽ നിന്ന് ഓരോ ഷെൽഫിനും 00001 മുതൽ 50000 വരെ നമ്പറുള്ള ഒരു പ്ലേറ്റ് ഓർഡർ ചെയ്യാൻ വെയർഹൗസ് മാനേജ്മെന്റ് തീരുമാനിച്ചു, എന്നാൽ പ്ലേറ്റുകൾ അച്ചടിച്ചപ്പോൾ, ഒരു തകരാർ കാരണം പ്രിന്റിംഗ് പ്രസ്, നമ്പർ 2 അച്ചടിച്ചില്ല, അതിനാൽ ഒന്നോ അതിലധികമോ അക്കങ്ങൾ അടങ്ങിയ എല്ലാ പ്ലേറ്റുകളും (ഉദാഹരണത്തിന്, 00002 അല്ലെങ്കിൽ 20202) - നിങ്ങൾ അത് വീണ്ടും ടൈപ്പ് ചെയ്യേണ്ടതുണ്ട്. വികലമായ ബാച്ചിൽ ഈ തെറ്റായ പ്ലേറ്റുകൾ എത്രയുണ്ടെന്ന് കണക്കാക്കുന്ന ഒരു പ്രോഗ്രാം എഴുതുക.
ഇലക്ട്രോണിക് ക്ലോക്ക് 00:00 മുതൽ 23:59 വരെയുള്ള ഫോർമാറ്റിൽ സമയം പ്രദർശിപ്പിക്കുന്നു. വൻകുടലിന്റെ വലതുവശത്തുള്ള കോലണിന്റെ ഇടതുവശത്ത് ഒരു സമമിതി സംയോജനം കാണിക്കുന്നത് ദിവസത്തിൽ എത്ര തവണയാണെന്ന് കണക്കാക്കുക (ഉദാഹരണത്തിന്, 02:20, 11:11 അല്ലെങ്കിൽ 15:51).
അമേരിക്കൻ സൈന്യത്തിൽ, 13 നമ്പർ നിർഭാഗ്യകരമാണെന്ന് കണക്കാക്കപ്പെടുന്നു, ജാപ്പനീസ് - 4. അന്താരാഷ്ട്ര അഭ്യാസങ്ങൾക്ക് മുമ്പ്, റഷ്യൻ സൈന്യത്തിന്റെ ആസ്ഥാനം 4 അല്ലെങ്കിൽ 13 നമ്പറുകൾ അടങ്ങിയ സൈനിക ഉപകരണങ്ങളുടെ എണ്ണം ഒഴിവാക്കാൻ തീരുമാനിച്ചു (ഉദാഹരണത്തിന്, 40123, 13313, 12345 അല്ലെങ്കിൽ 13040) വിദേശ സഹപ്രവർത്തകരെ ആശയക്കുഴപ്പത്തിലാക്കാതിരിക്കാൻ. സൈന്യത്തിന്റെ കൈവശം 100,000,000 യൂണിറ്റ് സൈനിക ഉപകരണങ്ങൾ ഉണ്ടെങ്കിൽ, ഓരോ യുദ്ധവാഹനത്തിനും 00001 മുതൽ 99999 വരെയുള്ള നമ്പർ ഉണ്ടെങ്കിൽ, എത്ര നമ്പറുകൾ ഒഴിവാക്കേണ്ടിവരും?
2010, അലക്സി നിക്കോളാവിച്ച് കോസ്റ്റിൻ. ടിഐഡിഎം വിഭാഗം, മാത്തമാറ്റിക്സ് ഫാക്കൽറ്റി, മോസ്കോ സ്റ്റേറ്റ് പെഡഗോഗിക്കൽ യൂണിവേഴ്സിറ്റി.
08/12/17 1.9Kഒരേ കോഡ് ഒന്നിലധികം തവണ പ്രവർത്തിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പ്രസ്താവനയാണ് ജാവ വൈൽ ഡു ലൂപ്പ്. വ്യവസ്ഥകൾ പാലിക്കുമ്പോൾ പ്രവർത്തനങ്ങൾ ആവർത്തിക്കാൻ ഈ ലൂപ്പ് ഉപയോഗിക്കാം.
ലൂപ്പ് സമയത്ത്
ജാവ ഭാഷയിൽ നിർമ്മിക്കാൻ ഏറ്റവും ലളിതമാണ് while ലൂപ്പ്. ഇതിൽ അൽപ്പസമയം കീ, ഒരു ലൂപ്പ് അവസ്ഥ, ഒരു ലൂപ്പ് ബോഡി എന്നിവ അടങ്ങിയിരിക്കുന്നു:
അതേസമയം (അവസ്ഥ) (// ലൂപ്പ് ബോഡി)
ലൂപ്പ് ബോഡിയുടെ ഓരോ പ്രത്യേക ഓട്ടവും ഒരു ആവർത്തനമായി കണക്കാക്കപ്പെടുന്നു. ഓരോ ആവർത്തനത്തിനും മുമ്പ്, ലൂപ്പ് അവസ്ഥകൾ വിലയിരുത്തപ്പെടുന്നു. ലൂപ്പ് അവസ്ഥ ശരിയാണെന്ന് വിലയിരുത്തിയാൽ മാത്രമേ അതിന്റെ ബോഡി എക്സിക്യൂട്ട് ചെയ്യപ്പെടുകയുള്ളൂ.
ലൂപ്പിന്റെ ആവർത്തനങ്ങൾ എന്തെങ്കിലും മാറ്റുന്നു, ഒരു നിശ്ചിത ഘട്ടത്തിൽ അവസ്ഥ വിലയിരുത്തൽ തെറ്റായി നൽകുന്നു , ആ ഘട്ടത്തിൽ ലൂപ്പ് അവസാനിക്കുന്നു. ഒരു ലൂപ്പ്, അതിന്റെ അവസ്ഥ ഒരിക്കലും തെറ്റായി നൽകില്ല, അനന്തമായ തവണ എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു. അത്തരം ചക്രങ്ങളെ അനന്തമായി വിളിക്കുന്നു.
ഉദാഹരണം
int num = 0; അതേസമയം (സംഖ്യ< 10) { System.out.println(num); num++; }
ഈ ഉദാഹരണം 0 മുതൽ 9 വരെയുള്ള സംഖ്യകൾ പ്രിന്റ് ചെയ്യുന്നു. നമുക്ക് കോഡ് ഘട്ടം ഘട്ടമായി പോകാം. ആദ്യം നമ്മൾ 0 എന്ന മൂല്യമുള്ള സംഖ്യ വേരിയബിൾ ആരംഭിക്കുന്നു. ഇത് ലൂപ്പ് കൗണ്ടറായിരിക്കും. പ്രോഗ്രാം സമയത്ത് എത്തുമ്പോൾ, ലൂപ്പിന്റെ അവസ്ഥകൾ വിലയിരുത്തപ്പെടുന്നു. ഞങ്ങളുടെ കാര്യത്തിൽ 0< 10 возвращает значение true и исполняется тело цикла. Внутри цикла выводится переменная num , а затем увеличивается на 1 . На этом завершается первая итерация.
ആദ്യത്തെ "റൺ" കഴിഞ്ഞ്, Java while ലൂപ്പ് അവസ്ഥ രണ്ടാം തവണയും വിലയിരുത്തപ്പെടുന്നു. 1< 10 по-прежнему возвращает true , после чего запускается следующая итерация цикла. Один и тот же процесс повторяется несколько раз.
സംഖ്യയുടെ മൂല്യം 9 ന് തുല്യമാകുമ്പോൾ അവസാന ആവർത്തനം ആരംഭിക്കുന്നു. ലൂപ്പ് കൌണ്ടർ അവസാനമായി ഒരു തവണ പ്രദർശിപ്പിക്കുകയും മൂല്യം 10 ആയി വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു. ഇത്തവണ, ഒരു പുതിയ ആവർത്തനം ആരംഭിക്കാൻ കഴിയില്ല, കാരണം ലൂപ്പ് അവസ്ഥ തെറ്റായി കണക്കാക്കുന്നു. 10 എന്നത് 10 ൽ കുറയാത്തതിനാൽ.
അങ്ങനെ, ലൂപ്പ് അവസ്ഥ തൃപ്തികരമാകുന്നിടത്തോളം ലൂപ്പ് പ്രവർത്തിക്കുന്നു. ഈ അറിവ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് കൂടുതൽ സങ്കീർണ്ണവും പ്രവർത്തനപരവുമായ ലൂപ്പുകൾ സൃഷ്ടിക്കാൻ കഴിയും. നമുക്ക് അറേയിലൂടെ ആവർത്തിക്കാം:
സ്ട്രിംഗ് പേരുകൾ = ("ഡോക്", "ഡോപ്പി", "ബഷ്ഫുൾ", "ഗ്രമ്പി", "സ്നീസി", "സ്ലീപ്പി", "ഹാപ്പി"); int സൂചിക = 0; അതേസമയം (സൂചിക< names.length) { System.out.println(names); index++; }
ഈ ഉദാഹരണത്തിന്റെ ആശയം മുമ്പത്തേതിന് സമാനമാണ്. എല്ലാ ഘടകങ്ങളും അച്ചടിക്കുന്നതുവരെ ഞങ്ങൾ ലൂപ്പ് കൗണ്ടർ ആരംഭിക്കുകയും അറേയിലൂടെ ആവർത്തിക്കുകയും ചെയ്യുന്നു. തൽഫലമായി, അറേകളിൽ ആവർത്തിക്കുന്നത് വളരെ സാധാരണമായ ഒരു കാര്യമാണ്, കൂടാതെ ജാവയ്ക്ക് ഇതിനുള്ള മികച്ച നിർമ്മാണമുണ്ട്: ഫോർ ലൂപ്പ്.
do-while ലൂപ്പ്
Java while do loop, while ന് സമാനമാണ്, എന്നാൽ കാര്യമായ വ്യത്യാസമുണ്ട്: while പോലെയല്ല, ഓരോ ആവർത്തനത്തിന്റെയും അവസാനം അവസ്ഥ പരിശോധിക്കുന്നു. ഇതിനർത്ഥം do-while ലൂപ്പ് എല്ലായ്പ്പോഴും ഒരിക്കലെങ്കിലും എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു എന്നാണ്:
do ( // loop body ) while (condition);
ഉദാഹരണം
do-while ആദ്യം ലൂപ്പിന്റെ ബോഡി എക്സിക്യൂട്ട് ചെയ്യുകയും തുടർന്ന് അതിന്റെ അവസ്ഥകൾ വിലയിരുത്തുകയും ചെയ്യുന്നു. ലഭിച്ച ഫലത്തെ ആശ്രയിച്ച്, ലൂപ്പ് നിർത്തുന്നു അല്ലെങ്കിൽ അടുത്ത ആവർത്തനം ആരംഭിക്കുന്നു. നമുക്ക് ഒരു ലളിതമായ ഗെയിം നോക്കാം "പേര് ഊഹിക്കുക":
സ്കാനർ സ്കാനർ = പുതിയ സ്കാനർ(System.in); സ്ട്രിംഗ് ഊഹം; ചെയ്യുക ( System.out.print("പേര് ഊഹിക്കുക: "); ഊഹിക്കുക = scanner.nextLine(); ) while (!"Daffy Duck".equals(guess)); System.out.println("അഭിനന്ദനങ്ങൾ! നിങ്ങൾ എന്റെ പേര് ഊഹിച്ചു!");
ജാവ ഉദാഹരണം system.ini ൽ നിന്നുള്ള ഇൻപുട്ട് പാഴ്‌സ് ചെയ്യുന്നതിന് സ്കാനർ ഉപയോഗിക്കുന്നു. മിക്ക കേസുകളിലും കീബോർഡുമായി സംവദിക്കുന്ന സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് ചാനലാണിത്. ലളിതമായി പറഞ്ഞാൽ, കളിക്കാരൻ നൽകുന്ന വാചകം ഞങ്ങൾ വായിക്കുന്നു.
ഗെയിമിൽ, നിങ്ങൾ ഉപയോക്താവിനോട് ഒരിക്കലെങ്കിലും ചോദിക്കണം, കൂടാതെ കളിക്കാരൻ ശരിയായ ഉത്തരങ്ങൾ നൽകുന്നിടത്തോളം ഇത് ചെയ്യണം. അത്തരം സന്ദർഭങ്ങളിൽ do-while ലൂപ്പ് അനുയോജ്യമാണ്. ലൂപ്പിന്റെ ബോഡിയിൽ, നമുക്ക് ഉപയോക്തൃ മൂല്യം ലഭിക്കും, തുടർന്ന് ഉത്തരത്തിന്റെ കൃത്യത പരിശോധിക്കുക. ഉപയോക്തൃ ഇൻപുട്ട് മൂല്യം ഡാഫി ഡക്കിന് തുല്യമാകുന്നതുവരെ ലൂപ്പ് പ്രവർത്തിക്കണം. ശരിയായ ഉത്തരം ലഭിച്ചാൽ, ലൂപ്പ് നിർത്തുകയും കളിക്കാരന്റെ വിജയത്തിൽ ഞങ്ങൾ അഭിനന്ദിക്കുകയും ചെയ്യുന്നു.
ഉപസംഹാരമായി
Java's while true loops നിങ്ങളെ ഒന്നിലധികം തവണ കോഡ് കഷണങ്ങൾ വീണ്ടും ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു. ഇന്ന് നമുക്ക് Java while and do-while ലൂപ്പുകൾ പരിചയപ്പെടുത്തി. അവ സമാനമാണ്, അവ അവസ്ഥകൾ പരിശോധിക്കുകയും വ്യവസ്ഥ ശരിയാണെന്ന് വിലയിരുത്തുകയാണെങ്കിൽ ലൂപ്പിന്റെ ബോഡി എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നു. എന്നാൽ അതേ സമയം, അവയ്‌ക്ക് കാര്യമായ വ്യത്യാസമുണ്ട്: ആവർത്തനത്തിന് മുമ്പ് while ലൂപ്പിന്റെ അവസ്ഥ പരിശോധിക്കുന്നു, കൂടാതെ ഓരോ ആവർത്തനത്തിന്റെയും അവസാനം do-while ലൂപ്പിന്റെ അവസ്ഥ പരിശോധിക്കുന്നു. ഇതിനർത്ഥം do-while loop എല്ലായ്പ്പോഴും ഒരിക്കലെങ്കിലും എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു എന്നാണ്.ഈ പ്രസിദ്ധീകരണം "" എന്ന ലേഖനത്തിന്റെ വിവർത്തനമാണ് അഞ്ച് മിനിറ്റിനുള്ളിൽ ജാവയുടെ വെയിലും ഡു-വിലും ലൂപ്പുകൾ", സൗഹൃദ പദ്ധതി സംഘം തയ്യാറാക്കിയത്
ഈ ട്യൂട്ടോറിയലിൽ, വിവിധ തരത്തിലുള്ള ലൂപ്പുകൾ നോക്കി നിയന്ത്രിത രീതിയിൽ ഞങ്ങളുടെ കോഡിന്റെ ഭാഗങ്ങൾ എങ്ങനെ വീണ്ടും എക്സിക്യൂട്ട് ചെയ്യാമെന്ന് ഞങ്ങൾ പഠിക്കും. ജാവ. നമുക്ക് സൈക്കിളുകൾ സൂക്ഷ്മമായി പരിശോധിക്കാം: സമയത്ത്, ചെയ്യുക-സമയത്ത്, വേണ്ടി. ഏത് സാഹചര്യത്തിലാണ് ഏത് സൈക്കിൾ ഉപയോഗത്തിന് ഏറ്റവും അനുയോജ്യമെന്ന് നിർണ്ണയിക്കാൻ ഞങ്ങൾ ശ്രമിക്കും.
തുടർന്ന് ഞങ്ങൾ റാൻഡം നമ്പറുകളുടെ വിഷയം ഹ്രസ്വമായി നോക്കാം ( ക്രമരഹിതമായസംഖ്യകൾ). നമുക്ക് നോക്കാം ജാവ- ക്ലാസ് ക്രമരഹിതംഞങ്ങളുടെ ഗെയിമിൽ അത് ഞങ്ങളെ എങ്ങനെ സഹായിക്കും.
ഒരു ലൂപ്പ്, പേര് സൂചിപ്പിക്കുന്നത് പോലെ, ഒരേ കോഡ് ആവശ്യമുള്ളത്ര തവണ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുള്ള ഒരു മാർഗമാണ് (ലൂപ്പിൽ കോഡ് എക്സിക്യൂട്ട് ചെയ്തതിന്റെ ഫലം ആവർത്തിക്കാതെ). സൈക്കിളിന്റെ ആവർത്തനങ്ങളുടെ എണ്ണം ഒന്നുകിൽ മുൻകൂട്ടി നിശ്ചയിക്കാം അല്ലെങ്കിൽ പ്രോഗ്രാമർക്ക് തന്നെ അജ്ഞാതമായിരിക്കും. ഭാഷ ഞങ്ങൾക്ക് ഉപയോഗിക്കാൻ വാഗ്ദാനം ചെയ്യുന്ന പ്രധാന തരം ലൂപ്പുകൾ ഞങ്ങൾ നോക്കും. ജാവ.എന്നിട്ട് അവയിൽ ചിലത് ഞങ്ങളുടെ ഗെയിമിൽ അവതരിപ്പിക്കുകയും അതുവഴി അത് മെച്ചപ്പെടുത്തുകയും ചെയ്യും.
ലൂപ്പ് സമയത്ത്
സൈക്കിൾ സമയത്ത്ഏറ്റവും ലളിതമായ വാക്യഘടനയുണ്ട്. ഓർക്കുക എങ്കിൽ- ഞങ്ങൾ കുറച്ച് മുമ്പ് പഠിച്ച നിർദ്ദേശങ്ങൾ. ഓപ്പറേറ്ററുടെ സോപാധികമായ പ്രകടനത്തിലേക്ക് എങ്കിൽ(വാക്കിന് ശേഷം ബ്രാക്കറ്റിൽ എന്താണ് ഉൾപ്പെടുത്തിയിരിക്കുന്നത് എങ്കിൽ) നിങ്ങൾക്ക് മിക്കവാറും ഏത് ഓപ്പറേറ്റർമാരുടെയും വേരിയബിളുകളുടെയും സംയോജനം നൽകാം. പ്രയോഗം ശരിയാണെങ്കിൽ ( സത്യം), തുടർന്ന് ബ്ലോക്കിന്റെ ബോഡിയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന കോഡ് എങ്കിൽപൂർത്തിയാകും. അതുപോലെ ലൂപ്പിലും സമയത്ത്വിലയിരുത്താൻ കഴിയുന്ന ഒരു പദപ്രയോഗം ഞങ്ങൾ ഇട്ടു സത്യംഅഥവാ തെറ്റായഈ കോഡിൽ കാണിച്ചിരിക്കുന്നത് പോലെ:
Int x = 10; while(x > 0)( x--; //x ലൂപ്പിന്റെ ഓരോ പാസും കുറയുന്നു)
എന്താണ് ഇവിടെ നടക്കുന്നത്? ലൂപ്പിന് പുറത്തുള്ള ആദ്യ കാര്യം സമയത്ത്ഞങ്ങൾ ഒരു വേരിയബിൾ പ്രഖ്യാപിച്ചു xതരം intഈ വേരിയബിളിന് "10" എന്ന മൂല്യം നൽകി. അപ്പോൾ ചക്രം ആരംഭിക്കുന്നു സമയത്ത്, അത് എഴുതിയിരിക്കുന്ന വ്യവസ്ഥകളിൽ “ x > 0"- ഇതിനർത്ഥം ലൂപ്പിന്റെ ബോഡിയിൽ എഴുതിയിരിക്കുന്ന കോഡ് എന്നാണ് സമയത്ത്വേരിയബിൾ ഉള്ളിടത്തോളം എക്സിക്യൂട്ട് ചെയ്യും xകൂടുതൽ 0 കൂടാതെ വ്യവസ്ഥ മൂല്യത്തിൽ എത്തുകയില്ല തെറ്റായ. അതിനാൽ, കോഡ് 10 തവണ എക്സിക്യൂട്ട് ചെയ്യും(x=10,x>0; x=9,x>0; x=8,x>0; x=7,x>0; x=6,x>0; x=5 ,x>0; x=4,x>0; x=3,x>0; x=2,x>0; x=1,x>0). സൈക്കിളിന്റെ ആദ്യ പാസിൽ x = 10, രണ്ടാമത്തേതിൽ ഇതിനകം 9 , മൂന്നാമത്തേതിൽ 8 തുടങ്ങിയവ. പിന്നെ എപ്പോൾ xതുല്യമായിരിക്കും 0 , അപ്പോൾ ലൂപ്പിൽ പ്രവേശിക്കുന്നതിനുള്ള വ്യവസ്ഥ തൃപ്തികരമാകില്ല, ലൂപ്പ് അവസാനിച്ചതിന് ശേഷം അടുത്ത വരിയിൽ നിന്ന് പ്രോഗ്രാം തുടരും.
ഓപ്പറേറ്റർ പോലെ തന്നെ എങ്കിൽ, ലൂപ്പ് ഒരിക്കൽ പോലും എക്സിക്യൂട്ട് ചെയ്യപ്പെടാത്ത ഒരു സാഹചര്യം സാധ്യമാണ്. ഇനിപ്പറയുന്ന ഉദാഹരണം നോക്കുക:
Int x = 10; while(x > 10)( //ചില കോഡ് //എന്നാൽ x 10 നേക്കാൾ വലുതായിരിക്കുമ്പോൾ അത് ഒരിക്കലും എക്സിക്യൂട്ട് ചെയ്യില്ല)
കൂടാതെ, കൺഡിഷൻ എക്സ്പ്രഷന്റെ സങ്കീർണ്ണതയ്‌ക്കോ ലൂപ്പിന്റെ ബോഡിയിൽ എഴുതാവുന്ന കോഡിന്റെ അളവിനോ പരിധിയില്ല:
Int playerLives = 3; int alienSships = 10; while(playerLives >0 && alienShips >0)( //എല്ലാ ഗെയിം കോഡും ഇവിടെയുണ്ട് //... //... // etc. ) //PlayerLives അല്ലെങ്കിൽ alienShips = 0 ആയിരിക്കുമ്പോൾ പ്രോഗ്രാം ഇവിടെ തുടരും
ഒന്നുകിൽ വേരിയബിൾ വരെ ഈ ലൂപ്പ് പ്രവർത്തിക്കും കളിക്കാരൻ ലൈവ്സ്, അഥവാ അന്യഗ്രഹ കപ്പലുകൾപൂജ്യത്തിന് തുല്യമോ അതിൽ കുറവോ ആയിരിക്കില്ല. ഈ അവസ്ഥകളിലൊന്ന് സംഭവിക്കുമ്പോൾ, അവസ്ഥയിലെ പദപ്രയോഗം മൂല്യം എടുക്കും തെറ്റായലൂപ്പ് പൂർത്തിയായതിന് ശേഷം അടുത്ത വരിയിൽ നിന്ന് പ്രോഗ്രാം തുടരും.
പ്രോഗ്രാം ലൂപ്പിന്റെ ബോഡിയിൽ പ്രവേശിച്ചുകഴിഞ്ഞാൽ, ലൂപ്പ് അവസ്ഥയായാലും അത് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. തെറ്റായ, ലൂപ്പിന്റെ ശരീരത്തിൽ എവിടെയോ, കാരണം പ്രവേശനത്തിന് ശേഷം മാത്രമേ അവസ്ഥ പരിശോധിക്കൂ:
Int x = 1; while(x > 0)( x--; //x ഇപ്പോൾ 0 ന് തുല്യമാണ്, അടുത്ത തവണ വ്യവസ്ഥ തെറ്റായിരിക്കും //എന്നാൽ ഈ വരി എക്സിക്യൂട്ട് ചെയ്യും //ഇത് //ഇത് പോലും)
മുകളിലുള്ള ഉദാഹരണത്തിൽ, ലൂപ്പിന്റെ ബോഡി ഒരിക്കൽ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. കൂടാതെ, ലൂപ്പ് എന്നെന്നേക്കുമായി പ്രവർത്തിക്കും - ഇത് വിളിക്കപ്പെടുന്ന ഒരു വ്യവസ്ഥ നിങ്ങൾക്ക് സജ്ജമാക്കാൻ കഴിയും അനന്തമായ ചക്രം.ഒരു ഉദാഹരണം ഇതാ:
Int x = 0; അതേസമയം(ശരി)( x++; //ഞാൻ വളരെ വലുതാകും!)
അവരുടെ ചക്രത്തിന്റെ ഔട്ട്പുട്ട്. കീവേഡ് ബ്രേക്ക്
നമുക്ക് ശരിക്കും ഒരു അനന്തമായ ലൂപ്പ് ഉപയോഗിക്കേണ്ടതുണ്ടെങ്കിൽ എന്തുചെയ്യും, എന്നാൽ ഏത് ഘട്ടത്തിൽ അതിൽ നിന്ന് പുറത്തുകടക്കണമെന്ന് നമുക്ക് തീരുമാനിക്കാൻ കഴിയുന്ന തരത്തിൽ. ഈ ആവശ്യത്തിനായി ഇൻ ജാവഒരു കീവേഡ് ഉണ്ട് ബ്രേക്ക്. നമുക്ക് ഉപയോഗിക്കാം ബ്രേക്ക്നമുക്ക് ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കേണ്ടിവരുമ്പോൾ:
Int x = 0; അതേസമയം(ശരി)( x++; //ഞാൻ വളരെ വലുതാകും! തകരും; //ഇല്ല, നിങ്ങൾ ചെയ്യില്ല! //ഇവിടെയുള്ള കോഡ് എത്തില്ല)
പോലുള്ള വിവിധ തീരുമാനമെടുക്കൽ ഉപകരണങ്ങൾ സംയോജിപ്പിക്കാൻ കഴിയുമെന്ന് നിങ്ങൾ ഇതിനകം ഊഹിച്ചിട്ടുണ്ടാകും എങ്കിൽ,വേറെ,സ്വിച്ച്ഞങ്ങളുടെ ലൂപ്പിനുള്ളിൽ സമയത്ത്മറ്റ് സൈക്കിളുകളും, ഞങ്ങൾ താഴെ പരിഗണിക്കും. ഉദാ:
Int x = 0; int tooBig = 10; അതേസമയം(ശരി)( x++; //ഞാൻ വളരെ വലുതാകും! എങ്കിൽ(x == വളരെ വലുത്)( ബ്രേക്ക്; //ഇല്ല, നിങ്ങൾ ചെയ്യില്ല. ) //x എന്നത് 10 ന് തുല്യമാകുന്നതുവരെ ഇവിടെ കോഡ് ലഭ്യമാകും)
നമുക്ക് കൂടുതൽ വ്യത്യസ്തമായ വ്യതിയാനങ്ങൾ എഴുതാം, എന്നാൽ ഞങ്ങൾക്ക് ഈ അറിവിന്റെ പ്രായോഗിക പ്രയോഗം കൂടുതൽ പ്രധാനമാണ്, അതിനാൽ ഞങ്ങൾ ഇപ്പോൾ കൂടുതൽ ആഴത്തിൽ പോകില്ല. ഒരു ലൂപ്പിൽ കൃത്രിമം കാണിക്കാൻ കഴിയുന്ന മറ്റൊരു ആശയം നോക്കാം.
കീവേഡ് തുടരുക
തുടരുകഏതാണ്ട് സമാനമായി പ്രവർത്തിക്കുന്നു ബ്രേക്ക്. കീവേഡ് തുടരുകനിങ്ങളെ ലൂപ്പ് ബോഡിയിൽ നിന്ന് പുറത്താക്കും, എന്നാൽ ലൂപ്പിന്റെ ക്ലോസിംഗ് ചുരുണ്ട ബ്രേസിൽ നിന്ന് തുടരുന്നതിന് പകരം അവസ്ഥ എക്സ്പ്രഷൻ പരീക്ഷിക്കുക. ബ്രേക്ക്. ഇനിപ്പറയുന്ന ഉദാഹരണം ഉപയോഗം കാണിക്കുന്നു തുടരുക:
Int x = 0; int tooBig = 10; int toBigToPrint = 5; അതേസമയം(ശരി)( x++; //ഞാൻ വളരെ വലുതായിരിക്കും! എങ്കിൽ(x == വളരെ വലുത്)( ബ്രേക്ക്; ) //ഇല്ല, നിങ്ങൾ ചെയ്യില്ല. //ഇവിടെയുള്ള കോഡ് x എന്നത് 10 ന് തുല്യമാകുന്നത് വരെ മാത്രമേ ലഭ്യമാകൂ if(x > = tooBigToPrint)( //ഇനി സ്ക്രീനിൽ പ്രിന്റ് ചെയ്യില്ല, പക്ഷേ ലൂപ്പ് തുടരും; ) //സ്ക്രീനിലേക്ക് x പ്രിന്റ് ചെയ്യാനുള്ള x 5 //കോഡിന് തുല്യമാകുന്നതുവരെ ഇവിടെ കോഡ് ലഭ്യമാകും. )
വിശദീകരണം: ഞങ്ങൾ വേരിയബിളുകൾ പ്രഖ്യാപിക്കുകയും സമാരംഭിക്കുകയും ചെയ്യുന്നു. ഞങ്ങൾ ലൂപ്പിലേക്ക് പോയി വേരിയബിളിന്റെ മൂല്യത്തിലേക്ക് ചേർക്കുക xയൂണിറ്റ് (ഇപ്പോൾ x= 1). "1 എന്നത് 10 ന് തുല്യമാണോ?" — തെറ്റായ- ആദ്യ ഓപ്പറേറ്റർ എങ്കിൽനടപ്പിലാക്കിയിട്ടില്ല. അടുത്ത പരിശോധന "1 എന്നത് 5-നേക്കാൾ വലുതാണോ അതോ തുല്യമാണോ?" — തെറ്റായ- രണ്ടാമത്തെ ഓപ്പറേറ്റർ എങ്കിൽനടപ്പിലാക്കിയിട്ടില്ല. ഞങ്ങൾ ഔട്ട്പുട്ട് ചെയ്യുന്നു xസ്ക്രീനിലേക്ക്.
എപ്പോൾ ഓപ്ഷൻ പരിഗണിക്കാം xലൂപ്പിൽ പ്രവേശിക്കുമ്പോൾ മൂല്യം 5 എടുക്കും. ഞങ്ങൾ ലൂപ്പിലേക്ക് പോയി വേരിയബിളിന്റെ മൂല്യത്തിലേക്ക് ചേർക്കുക xയൂണിറ്റ് (ഇപ്പോൾ x= 6). "6 സമം 10?" പരിശോധിക്കുന്നു — തെറ്റായ- ആദ്യ ഓപ്പറേറ്റർ എങ്കിൽനടപ്പിലാക്കിയിട്ടില്ല. അടുത്ത പരിശോധന "6 ആണോ 5-നേക്കാൾ വലുതോ തുല്യമോ?" — സത്യം- ഞങ്ങൾ ശരീരത്തിലേക്ക് പോകുന്നു എങ്കിൽ — തുടരുക, ലൂപ്പിൽ നിന്ന് പുറത്തുകടന്ന് ലൂപ്പിൽ പ്രവേശിക്കുന്നതിനുള്ള അവസ്ഥ പരിശോധിക്കുക.
എപ്പോൾ എന്നതാണ് ഇപ്പോൾ ഓപ്ഷൻ xലൂപ്പിൽ പ്രവേശിക്കുമ്പോൾ മൂല്യം 9 എടുക്കും. ഞങ്ങൾ ലൂപ്പിലേക്ക് പോയി വേരിയബിളിന്റെ മൂല്യത്തിലേക്ക് ചേർക്കുക xയൂണിറ്റ് (ഇപ്പോൾ x= 10). "10 എന്നത് 10 ന് തുല്യമാണോ?" — സത്യം- ഞങ്ങൾ ശരീരത്തിലേക്ക് പോകുന്നു എങ്കിൽ — ബ്രേക്ക്, ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കുക, ലൂപ്പിന്റെ ക്ലോസിംഗ് ചുരുണ്ട ബ്രേസിനപ്പുറം കോഡ് തുടരും സമയത്ത്.
do-while ലൂപ്പ്
ഒരു സവിശേഷത ഒഴികെയുള്ള മുൻ ലൂപ്പിന് ഏതാണ്ട് സമാനമാണ് - ലൂപ്പ് ബോഡിക്ക് ശേഷം സോപാധിക എക്സ്പ്രഷൻ എക്സിക്യൂഷൻ ചെക്ക് സംഭവിക്കും. ഇതിനർത്ഥം ചക്രം എന്നാണ് ചെയ്യുക-സമയത്ത്എല്ലായ്‌പ്പോഴും ഒരിക്കലെങ്കിലും നിർവ്വഹിക്കും. ഉദാഹരണം നോക്കുക:
Int x = 0; ചെയ്യുക (x++; ) സമയത്ത്(x< 10); //x теперь = 10
കീവേഡുകൾ ബ്രേക്ക്,തുടരുക
ലൂപ്പിനായി
സൈക്കിൾ വേണ്ടിഎന്നതിനേക്കാൾ സങ്കീർണ്ണമായ വാക്യഘടനയുണ്ട് സമയത്ത്ഒപ്പം ചെയ്യുക-സമയത്ത്, ആരംഭിക്കുന്നതിന് കുറച്ച് കൃത്രിമത്വം ആവശ്യമായതിനാൽ. നമുക്ക് ആദ്യം അത് നോക്കാം, എന്നിട്ട് അത് വേർപെടുത്തുക:
ഫോർ(int i = 0; i< 10; i++){ //Что-то, что должно произойти 10 раз будет записано здесь }
കംപൈലർ ഇത് എങ്ങനെ കാണുന്നു? ഇതുപോലെ:
ഇതിനായി (പ്രഖ്യാപനവും സമാരംഭവും; വ്യവസ്ഥ; ഓരോ ലൂപ്പ് പാസിനുശേഷവും മാറ്റം)( // ലൂപ്പിന്റെ ബോഡി)
- പ്രഖ്യാപനവും സമാരംഭവും- ഞങ്ങൾ തരം ഒരു പുതിയ വേരിയബിൾ സൃഷ്ടിച്ചു intപേരിനൊപ്പം ഐഅതിന് ഒരു മൂല്യം നൽകുകയും ചെയ്തു 0 ;
- അവസ്ഥ- നേരത്തെ ചർച്ച ചെയ്ത മറ്റ് സൈക്കിളുകൾ പോലെ, സൈക്കിളിൽ പ്രവേശിക്കുന്നതിനുള്ള വ്യവസ്ഥ ഞങ്ങൾ ഇവിടെ പരിശോധിക്കുന്നു. മൂല്യം കണക്കാക്കിയാൽ സത്യം, പിന്നെ നമ്മൾ ലൂപ്പിന്റെ ശരീരത്തിൽ പ്രവേശിക്കുന്നു;
- മാറ്റുക ഓരോ സൈക്കിളിനു ശേഷവും- മുകളിലുള്ള ഉദാഹരണത്തിൽ ഐ++ അതായത് ലൂപ്പിന്റെ അടുത്ത പാസിന് ശേഷം നമുക്ക് വേരിയബിളിന്റെ മൂല്യം ലഭിക്കും ഐഒന്ന് (1) ചേർക്കുക. മാത്രമല്ല, നമുക്ക് വേരിയബിൾ മാറ്റുന്നതിലൂടെയും എഴുതാം ഐ— ഒന്ന് കുറയ്ക്കാൻ, ഉദാഹരണത്തിന്:
കീവേഡുകൾ ബ്രേക്ക്,തുടരുകഈ സൈക്കിളിലും ഉപയോഗിക്കാം.
സൈക്കിൾ വേണ്ടിസമാരംഭം, അവസ്ഥ പരിശോധന, വേരിയബിൾ മോഡിഫിക്കേഷൻ എന്നിവയുടെ നിയന്ത്രണം ഏറ്റെടുക്കുന്നു. പരിചയപ്പെട്ട ഉടൻ തന്നെ ഞങ്ങളുടെ ആപ്ലിക്കേഷനിൽ ഈ സൈക്കിൾ പ്രായോഗികമായി പരീക്ഷിക്കാം ക്രമരഹിത സംഖ്യകൾഒപ്പം രീതികൾ.
ഏതൊരു പ്രോഗ്രാമിംഗ് ഭാഷയും പോലെ, ഒരു പ്രത്യേക കോഡ് വീണ്ടും വീണ്ടും ആവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്ത ടൂളുകൾ ജാവയിലുണ്ട്. അത്തരം ഉപകരണങ്ങളെ സാധാരണയായി സൈക്കിളുകൾ എന്ന് വിളിക്കുന്നു. ജാവയിൽ, ലൂപ്പുകളെ പ്രതിനിധീകരിക്കുന്നത് സമയത്ത്, ഫോർ, അവയുടെ വ്യതിയാനങ്ങൾ എന്നിങ്ങനെയുള്ള പ്രസ്താവനകളാണ്. പ്രത്യേക ഘടകങ്ങൾ കണ്ടെത്തുന്നതിനും അവയിൽ തുടർ പ്രവർത്തനങ്ങൾ നടത്തുന്നതിനുമായി ഒറ്റ, മൾട്ടി-ഡൈമൻഷണൽ അറേകളും ഡാറ്റാ ഘടനകളും സഞ്ചരിക്കാൻ ലൂപ്പുകൾ സാധാരണയായി ഉപയോഗിക്കുന്നു. എന്നാൽ ജാവ ലൂപ്പ് പോലുള്ള ഒരു ടൂൾ ഉപയോഗിക്കുന്നതിനുള്ള ഒരേയൊരു മാർഗ്ഗത്തിൽ നിന്ന് ഇത് വളരെ അകലെയാണ്. ഞങ്ങൾ അവലോകനം ചെയ്യുമ്പോൾ ഉപയോഗത്തിന്റെ ഉദാഹരണങ്ങൾ നൽകും.
Java while loop: വിവരണവും ഉദാഹരണങ്ങളും
ജാവയിലെ അടിസ്ഥാന ലൂപ്പ് ഓപ്പറേറ്ററാണ്. യഥാർത്ഥ മൂല്യം തൃപ്തിപ്പെടുത്തുന്നതിന് ശേഷം പരാൻതീസിസിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പദപ്രയോഗത്തിന്റെ അവസ്ഥ വരെ അതിന്റെ ശരീരത്തിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന കോഡ് ശകലം ആവർത്തിക്കും. while ഓപ്പറേറ്റർക്ക് പൊതുവായി ഇനിപ്പറയുന്ന ഫോം ഉണ്ട്: while (കണ്ടീഷൻ)(//ലൂപ്പ് ബോഡി). ബൂളിയൻ വ്യവസ്ഥ ശരിയല്ലെങ്കിൽ, ലൂപ്പ് ബോഡിയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന കോഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നത് നിർത്തും. തൊട്ടുപിന്നാലെ വരുന്ന ലൈനിലേക്ക് നിയന്ത്രണം മാറ്റും. ലൂപ്പിന്റെ ബോഡിയിൽ ഒരു പ്രസ്താവന മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ എങ്കിൽ, നിങ്ങൾക്ക് ചുരുണ്ട ബ്രേസുകൾ ഒഴിവാക്കാം. എന്നിരുന്നാലും, പ്രോഗ്രാമർമാർക്കിടയിൽ അവ എല്ലായ്പ്പോഴും സജ്ജീകരിക്കുന്നത് നല്ല രൂപമായി കണക്കാക്കപ്പെടുന്നു. നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം:
പൊതു ക്ലാസ് സമയത്ത് ഡെമോ (
System.out.println ("1 മുതൽ 10 വരെയുള്ള നമ്പറുകൾ അച്ചടിക്കുക");
അതേസമയം (എണ്ണം<=10) {
System.out.println(count);
തുടക്കത്തിൽ പ്രഖ്യാപിച്ച വേരിയബിൾ കൗണ്ടിന് മൂല്യം 1 ഉണ്ട്. അടുത്തതായി നമ്മൾ ഒരു ലോജിക്കൽ എക്സ്പ്രഷൻ കാണുന്നു, അത് ഓപ്പറേറ്ററുടെ പേരിന് ശേഷം പരാൻതീസിസിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നു. മൂല്യം ശരിയാണെങ്കിൽ, കൗണ്ട് വേരിയബിളിന്റെ മൂല്യം 10-ന് തുല്യമോ അതിൽ കുറവോ ആകുന്നതുവരെ ലൂപ്പ് ശരിയായി തിരികെ നൽകും. ഓരോ പാസ് അല്ലെങ്കിൽ ആവർത്തനത്തിലും, വേരിയബിളിന്റെ മൂല്യം 1 കൊണ്ട് വർദ്ധിപ്പിക്കുകയും കൺസോൾ സ്ക്രീനിൽ പ്രിന്റ് ചെയ്യുകയും ചെയ്യും. വേരിയബിളിന്റെ മൂല്യം 11-ൽ എത്തിയപ്പോൾ, ലൂപ്പ് അവസാനിച്ചു. കൗണ്ട് വേരിയബിളിന്റെ മൂല്യം തുടക്കത്തിൽ 11 ന് തുല്യമായിരുന്നെങ്കിൽ, ലൂപ്പ് അവസ്ഥ തെറ്റായിരിക്കും. പ്രോഗ്രാം ശരീരത്തിൽ പോലും പ്രവേശിക്കില്ല. ഒരു ബോഡി ഇല്ലാതെ ഒരു സമയത്ത് സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കാൻ Java വാക്യഘടന നിങ്ങളെ അനുവദിക്കുന്നു എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഇനിപ്പറയുന്ന ഉദാഹരണം പരിഗണിക്കുക. നിങ്ങൾക്ക് രണ്ട് വേരിയബിളുകൾ ഉണ്ടെന്ന് പറയാം: i=100, j=200. അവരുടെ ഗണിത ശരാശരി പ്രോഗ്രമാറ്റിക്കായി കണക്കാക്കാനുള്ള ചുമതലയാണ് ഞങ്ങൾ നേരിടുന്നത്; ഈ ആവശ്യത്തിനായി നമുക്ക് ഒരു "പൊള്ളയായ" സമയത്ത് ലൂപ്പ് ഉപയോഗിക്കാം:
അതേസമയം(++i<- — j);
ഈ പ്രവർത്തനത്തിന്റെ ഫലമായി, ഈ രണ്ട് വേരിയബിളുകളിൽ ഏതെങ്കിലും ഒന്നിന്റെ മൂല്യം അവയുടെ പ്രാരംഭ മൂല്യങ്ങളുടെ ശരാശരിക്ക് തുല്യമായിരിക്കും. ഈ ഉദാഹരണത്തിൽ നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ലൂപ്പ് ഒരു ബോഡി ഇല്ലാതെ നന്നായി പ്രവർത്തിക്കുകയും സോപാധിക എക്സ്പ്രഷനിൽ ആവശ്യമായ എല്ലാ പ്രവർത്തനങ്ങളും നടത്തുകയും ചെയ്തു.
do-while ലൂപ്പ്
മുമ്പത്തെ ഉദാഹരണങ്ങളിൽ, കണ്ടീഷൻ എക്സ്പ്രഷൻ തെറ്റായി നൽകിയാൽ, പ്രോഗ്രാം ലൂപ്പിന്റെ ബോഡി അവഗണിക്കുകയും തുടർന്നുള്ള നിർവ്വഹണം തുടരുകയും ചെയ്തു. എന്നാൽ ലൂപ്പിന്റെ ബോഡിയിൽ അടങ്ങിയിരിക്കുന്ന കോഡ് ഒരു തവണയെങ്കിലും എക്സിക്യൂട്ട് ചെയ്യേണ്ട സാഹചര്യങ്ങൾ ഉണ്ടാകാറുണ്ട്, വ്യവസ്ഥാ പദപ്രയോഗത്തിന്റെ സത്യാവസ്ഥ പരിഗണിക്കാതെ തന്നെ. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ലൂപ്പിന്റെ അവസാനത്തിലല്ല, തുടക്കത്തിൽ തന്നെ ഒരു സോപാധിക പദപ്രയോഗത്തിന്റെ സത്യം നിങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്. do-while എന്ന കോഡ്-നാമമുള്ള while ലൂപ്പിന്റെ ഒരു വ്യതിയാനത്തിന് സമാനമായ പ്രവർത്തനക്ഷമത നൽകാൻ കഴിയും. ഇതിന് ഇനിപ്പറയുന്ന രൂപമുണ്ട്: do (//loop body) while (condition). നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ആദ്യം ലൂപ്പിന്റെ ബോഡി ഇവിടെ എക്സിക്യൂട്ട് ചെയ്യുന്നു, തുടർന്ന് അവസ്ഥയുടെ സത്യാവസ്ഥ പരിശോധിക്കുന്നു. ഓരോ ആവർത്തനത്തിലും ഇത് ചെയ്യപ്പെടുന്നു. മുകളിൽ പറഞ്ഞിരിക്കുന്ന കോഡ് ഏകദേശം ഒരേ സമയത്തെ പോലെ തന്നെ പ്രവർത്തിക്കും. എന്നാൽ ഞങ്ങൾ എണ്ണം 11 ആയി സജ്ജീകരിക്കുകയാണെങ്കിൽ, പ്രസ്താവനയുടെ സത്യാവസ്ഥ പരിശോധിക്കുന്നതിന് മുമ്പ് ലൂപ്പിന്റെ ബോഡി ഒരു തവണ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും.
ഉദാഹരണങ്ങളും വിവരണവും: ഇതിനായി – ജാവ ലൂപ്പ്
ജാവ ഭാഷയിലെ സാർവത്രികവും കാര്യക്ഷമവുമായ ഭാഷാ രൂപമാണ് ഫോർ ലൂപ്പ്. JavaSDK-യുടെ പതിപ്പ് 5 വരെ, ഫോർ സ്റ്റേറ്റ്മെന്റിന്റെ ഒരു പരമ്പരാഗത രൂപം മാത്രമേ ഉണ്ടായിരുന്നുള്ളൂ. അതിനുശേഷം, പുതിയൊരെണ്ണം പ്രത്യക്ഷപ്പെട്ടു - ഫോറെച്ച്. ഈ വിഭാഗം ഓപ്പറേറ്ററുടെ പരമ്പരാഗത രൂപത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും. ജാവയിലെ ഫോർ ലൂപ്പ് ഇതുപോലെ കാണപ്പെടുന്നു:
വേണ്ടി (inti=0; i<10; i++) {//Loop statements to be executed
ലൂപ്പിന്റെ അറ്റത്തുള്ള കോഡിലേക്ക് നിയന്ത്രണം കൈമാറ്റം ചെയ്യുന്നതിനുമുമ്പ്, വേരിയബിൾ i ആരംഭിക്കുന്നു, അത് ഒരു കൗണ്ടറായി പ്രവർത്തിക്കുന്നു. അടുത്തതായി, ഒരു പ്രത്യേക മൂല്യവുമായി കൌണ്ടർ താരതമ്യം ചെയ്ത സോപാധിക എക്സ്പ്രഷൻ നിങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്. പ്രോഗ്രാം ശരിയാണെങ്കിൽ, ലൂപ്പിന്റെ ബോഡി എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. ഈ സാഹചര്യത്തിൽ, മുൻകൂട്ടി നിശ്ചയിച്ച ഘട്ടത്തിലൂടെ കൌണ്ടർ മൂല്യം മാറുകയും സോപാധിക എക്സ്പ്രഷൻ വീണ്ടും പരിശോധിക്കുകയും ചെയ്യുന്നു. വ്യവസ്ഥ തെറ്റാകുന്നതുവരെ ഇത് സംഭവിക്കുന്നു. നന്നായി മനസ്സിലാക്കുന്നതിന്, ലൂപ്പിനുള്ള ജാവ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഒരു ഉദാഹരണം ഇതാ.
പൊതു ക്ലാസ് ഫോർ ലൂപ്പുകൾ (
പൊതു സ്റ്റാറ്റിക് ശൂന്യ പ്രധാനം (സ്ട്രിംഗ് ആർഗ്സ്) (
ഉദ്ദേശിക്കുന്ന_മൂല്യം =11;
വേണ്ടി )
