Ultima actualizare: 31.10.2018

Un alt tip de structuri de control sunt buclele. Buclele vă permit să efectuați o anumită acțiune de mai multe ori, în funcție de anumite condiții. Java are următoarele tipuri de bucle:

pentru buclă

Bucla for are următoarea definiție formală:

Pentru ([inițializați contorul]; [condiția]; [modificați contorul]) ( // acțiuni )

Luați în considerare standardul pentru bucla:

Pentru (int i = 1; i< 9; i++){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }

Prima parte a declarației buclei - int i = 1 creează și inițializează contorul i. Contorul nu trebuie să fie de tip int . Poate fi orice alt tip numeric, de exemplu float. Înainte ca bucla să se execute, valoarea contorului va fi 1. În acest caz, aceasta este la fel cu declararea unei variabile.

A doua parte este condiția în care va fi executată bucla. În acest caz, bucla va rula până când i ajunge la 9.

Și a treia parte este creșterea contorului cu unul. Din nou, nu trebuie neapărat să creștem cu unul. Poți scădea: i-- .

Ca rezultat, blocul buclei va rula de 8 ori până când valoarea lui i devine egală cu 9. Și de fiecare dată această valoare va crește cu 1.

Nu trebuie să specificăm toate condițiile atunci când declarăm o buclă. De exemplu, putem scrie astfel:

Int i = 1; pentru (; ;)( System.out.printf ("Pătratul lui %d este %d \n", i, i * i); )

Definiția unei bucle rămâne aceeași, doar că acum blocurile din definiție sunt goale: for (; ;) . Acum nu există nicio variabilă de contor inițializată, nicio condiție, așa că bucla va rula pentru totdeauna - o buclă infinită.

Sau puteți omite un număr de blocuri:

Int i = 1; pentru(; i<9;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); i++; }

Acest exemplu este echivalent cu primul exemplu: avem și un contor, dar este creat în afara buclei. Avem o condiție de execuție a buclei. Și există o creștere a contorului deja în blocul for în sine.

O buclă for poate defini și manipula mai multe variabile simultan:

Int n = 10; for(int i=0, j = n - 1; i< j; i++, j--){ System.out.println(i * j); }

face bucla

Bucla do execută mai întâi codul buclei și apoi testează condiția din instrucțiunea while. Și atâta timp cât această condiție este adevărată, ciclul se repetă. De exemplu:

Int j = 7; do( System.out.println(j); j--; ) while (j > 0);

În acest caz, codul buclei va rula de 7 ori până când j este egal cu zero. Este important de reținut că bucla do garantează că acțiunea va fi executată cel puțin o dată, chiar dacă condiția din instrucțiunea while nu este adevărată. Deci, putem scrie:

Int j = -1; do( System.out.println(j); j--; ) while (j > 0);

Chiar dacă j este inițial mai mic decât 0, bucla se va executa totuși o dată.

buclă while

Bucla while verifică imediat adevărul unei anumite condiții, iar dacă condiția este adevărată, atunci codul buclei este executat:

Int j = 6; în timp ce (j > 0)( System.out.println(j); j--; )

Continuați și întrerupeți declarațiile

Declarația break vă permite să părăsiți o buclă în orice moment, chiar dacă bucla nu și-a încheiat activitatea:

De exemplu:

< nums.length; i++){ if (nums[i] >10) pauză; System.out.println(nums[i]); )

Deoarece bucla verifică dacă elementul de matrice este mai mare de 10, nu vom vedea ultimele două elemente pe consolă, deoarece atunci când nums[i] este mai mare de 10 (adică egal cu 12), instrucțiunea break va funcționa iar bucla se va termina.

Adevărat, nu vom vedea nici ultimul element, care este mai mic de 10. Acum ne vom asigura că, dacă numărul este mai mare de 10, bucla nu se va încheia, ci pur și simplu trece la următorul element. Pentru a face acest lucru, folosim operatorul continue:

Int nums = new int ( 1, 2, 3, 4, 12, 9 ); pentru (int i = 0; i< nums.length; i++){ if (nums[i] >10) continua; System.out.println(nums[i]); )

În acest caz, când bucla ajunge la numărul 12, care nu satisface condiția de testare, programul va sări peste acest număr și va trece la următorul element al matricei.

Ca aproape orice limbaj de programare, Java are instrumente concepute pentru a repeta o anumită bucată de cod din nou și din nou. Astfel de instrumente sunt de obicei numite cicluri. În Java, buclele sunt reprezentate de instrucțiuni precum while și for și variațiile acestora. Buclele sunt de obicei folosite pentru a parcurge matrice unidimensionale și multidimensionale și structuri de date pentru a găsi elemente specifice și a efectua operațiuni suplimentare asupra acestora. Dar aceasta este departe de a fi singura modalitate de a utiliza un instrument precum bucla Java. Pe măsură ce le examinăm, vor fi oferite exemple de utilizare.

Bucla while Java: descriere și exemple

While este operatorul de buclă fundamental în Java. Fragmentul de cod inclus în corpul său se va repeta până când condiția expresiei cuprinsă în paranteze după ce satisface valoarea adevărată. Operatorul while are în general următoarea formă: while (condiție)(//corp buclă). Odată ce condiția booleană nu mai este adevărată, codul inclus în corpul buclei se va opri din executare. Controlul va fi transferat pe linia care vine imediat după aceasta. Dacă corpul buclei conține o singură declarație, atunci puteți omite acoladele. Cu toate acestea, printre programatori este considerată o formă bună de a le seta întotdeauna. Să ne uităm la un exemplu:

Clasă publică whileDemo (

System.out.println („Tipărirea numerelor de la 1 la 10”);

în timp ce (număr<=10) {

System.out.println(număr);

Numărul de variabile declarate inițial are valoarea 1. În continuare vedem o expresie logică, care este inclusă în paranteze după numele operatorului. Dacă valoarea este adevărată, bucla va returna adevărată până când valoarea variabilei de numărare este egală sau mai mică de 10. La fiecare trecere sau iterație, valoarea variabilei va fi incrementată cu 1 și imprimată pe ecranul consolei. Când valoarea variabilei a atins valoarea 11, bucla sa încheiat. Dacă valoarea variabilei de numărare a fost inițial egală cu 11, atunci condiția buclei ar fi falsă. Programul nici nu ar intra în corp. Trebuie remarcat faptul că sintaxa Java vă permite să utilizați o instrucțiune While fără un corp. Luați în considerare următorul exemplu. Să presupunem că aveți două variabile: i=100 și j=200. Ne confruntăm cu sarcina de a calcula media lor aritmetică în mod programatic; în acest scop putem folosi o buclă while „hollow”:

În timp ce(++i<- — j);

Ca rezultat al acestei operațiuni, valoarea oricăreia dintre aceste două variabile va fi egală cu media valorilor lor inițiale. După cum puteți vedea în acest exemplu, bucla a funcționat bine fără corp și a efectuat toate acțiunile necesare în expresia condiționată.

bucla do-while

În exemplele anterioare, dacă expresia condiției a returnat fals, programul a ignorat corpul buclei și a continuat execuția ulterioară. Dar uneori apar situații când codul conținut în corpul buclei trebuie executat cel puțin o dată, indiferent de adevărul expresiei condiției. Cu alte cuvinte, uneori se întâmplă că trebuie să verificați adevărul unei expresii condiționate la început, mai degrabă decât la sfârșitul buclei. O variație a buclei while, denumită de cod do-while, poate oferi funcționalități similare. Are următoarea formă: do (//loop body) while (condiție). După cum puteți vedea, mai întâi corpul buclei este executat aici, iar apoi este verificat adevărul condiției. Acest lucru se face la fiecare iterație. Codul de mai sus va funcționa aproximativ la fel ca și în cazul while. Dar dacă setăm numărul la 11, corpul buclei ar fi încă executat o dată înainte ca instrucțiunea să testeze adevărul expresiei.

Exemple și descriere: for – bucla Java

Bucla for este o formă de limbaj universală și eficientă în limbajul Java. Până la versiunea 5 a JavaSDK, a existat o singură formă tradițională a declarației for. După aceasta, a apărut unul nou - foreach. Această secțiune se va concentra pe forma tradițională a operatorului. Bucla for din Java arată astfel:

pentru (inti=0; i<10; i++) {//Loop statements to be executed

Înainte ca controlul să fie transferat în codul de la sfârșitul buclei, variabila i este inițializată, care acționează ca un numărător. Apoi, trebuie să verificați expresia condiționată în care contorul a fost comparat cu o anumită valoare. Dacă programul returnează true, corpul buclei este executat. În acest caz, valoarea contorului se modifică cu un pas predeterminat și expresia condiționată este verificată din nou. Acest lucru se întâmplă până când condiția devine falsă. Pentru o mai bună înțelegere, iată un exemplu despre cum funcționează o buclă Java for.

clasa publica ForLoops (

public static void main (Argumente șir) (

valoare_intențială =11;

pentru [j] = (i+l)*(j+l) ; // folosiți un stil for-each pentru a afișa bucla
// și însumând valorile
pentru (int x : nums) (
pentru(int y: x) (
System.out.println("Valoarea este: " + y);
suma += y;
}
}
System.out.println("Suma: " + suma);
}

Acest program generează următoarele rezultate:

Valoarea este: 1
Valoarea este: 2
Valoarea este: 3
Valoarea este: 4
Valoarea este: 5
Valoarea este: 2
Valoarea este: 4
Valoarea este: 6
Valoarea este: 8
Valoarea este: 10
Valoarea este: 3
Valoarea este: 6
Valoarea este: 9
Valoarea este: 12
Valoarea este: 15
Suma: 90

Următoarea linie a acestui program merită o atenție specială:

pentru (int x : numere) (

Atenție la modul în care este declarată variabila x. Această variabilă este o referință la o matrice unidimensională de valori întregi. Acest lucru este necesar deoarece rezultatul fiecărei iterații a buclei for este următorul tablou din matricea nums, începând cu matricea specificată de elementul nums. Bucla internă pentru apoi iterează prin fiecare dintre aceste matrice, afișând valorile fiecărui element.

Utilizarea unei bucle For îmbunătățite

Deoarece fiecare stil for-each for poate parcurge numai secvențial elementele unui tablou, începând cu primul și terminând cu ultimul, poate părea a fi de utilizare limitată. Cu toate acestea, nu este. Mulți algoritmi necesită utilizarea acestui mecanism special. Unul dintre algoritmii cei mai des folosiți este căutarea. De exemplu, următorul program folosește o buclă for pentru a căuta o valoare într-o matrice neordonată. Căutarea se oprește când este găsită valoarea de căutare.

// Căutați în matrice folosind un stil for-each for bucla.
Căutare clasă (
public static void main(Argumente șir) (
int nums = ( 6, 8, 3, 7, 5, 6, 1, 4 );
int val =5;
boolean găsit = fals;
// folosiți bucla for în stilul for-each
pentru (int x: numere) (
dacă (x == val) (
găsit = adevărat;
pauză;
}
}
daca este gasit)
System.out.println(„Valoarea găsită!”);)

În acest caz, alegerea stilului „for-each” pentru bucla for este complet justificată, deoarece căutarea printr-o matrice neordonată implică căutarea secvenţială prin fiecare element. (Desigur, dacă matricea ar fi ordonată, ar putea fi utilizată căutarea binară, ceea ce ar necesita un stil de buclă diferit pentru implementare.) Alte tipuri de aplicații care beneficiază de bucle pentru fiecare includ medierea, găsirea valorii minime sau maxime într-un set, caută duplicate etc.

Trebuie să procesați multe de același tip de date? Trebuie să calculați o serie? Trebuie să înmulțiți matrice? Toate acestea și multe altele vă vor ajuta să finalizați ciclul! 🙂 Toate sistemele de calcul au fost proiectate inițial pentru a facilita prelucrarea datelor. Și este imposibil chiar să ne imaginăm procesarea unei cantități mari de date fără bucle.

În general, buclele din programare sunt de obicei împărțite în trei grupuri. Primul grup este ciclurile cu contor. În ele, corpul buclei este executat de un anumit număr de ori, specificat inițial de programator. O astfel de buclă va fi în mod necesar executată de un număr specificat de ori. Al doilea grup este ciclurile cu o precondiție. În ele, corpul buclei este executat numai după verificarea unei anumite condiții și va fi executat atâta timp cât această condiție este adevărată. Este posibil ca astfel de bucle să nu fie executate nici măcar o dată (dacă condiția este inițial falsă). Iar al treilea grup de cicluri sunt cicluri cu o postcondiție. În ele, corpul buclei este mai întâi executat, apoi este verificată condiția. Această buclă va fi executată cel puțin o dată.

Să începem cu o buclă cu un contor. În Java, aceasta este o buclă for; În general, se poate scrie după cum urmează:

Pentru (condiție de pornire; condiție de final; modificare) (corp buclă; )

Astfel, dacă vrem să facem o acțiune de 10 ori, atunci trebuie să scriem următoarele:

Pentru (int i = 0; i<10; i++) { System.out.println(i); }

un astfel de program va afișa secvenţial numere de la zero la nouă. Mai detaliat, pur și simplu creăm o nouă variabilă i și îi atribuim valoarea inițială 0 (int i = 0;). Apoi precizăm că bucla ar trebui să fie executată până la i< 10 и указываем каким образом должно изменяться i после каждой итерации цикла (i++).

Cei care au programat în Pascal vor fi încântați de această oportunitate:

Int k = 15; pentru (float i = 0; i

În acest exemplu, valoarea variabilei i va crește cu 1,5 cu fiecare iterație. Poti sa verifici:).

Următorul ciclu în linie - in timp ce. Aceasta este o buclă cu o precondiție și, în formă generală, poate fi scrisă astfel:

While (expresie logică) ( acțiuni )

Ei bine, dacă luăm un exemplu de lucru, va arăta cam așa:

In timp ce<10) { System.Out.Print(a); a++; }

Deci, este clar că această buclă are sens să o folosești dacă nu știi exact de câte iterații sunt necesare pentru a atinge obiectivul, dar știi exact condiția în care obiectivul tău va fi atins. O astfel de construcție nu poate fi executată nici măcar o dată (la urma urmei, aceasta este o buclă cu o precondiție)! De câte ori sunt executate acțiunile din buclă depinde de valoarea care a fost inițial în variabilă A.

Iar al treilea tip de cicluri sunt ciclurile cu o postcondiție. El este foarte asemănător cu în timp ce... face numai dacă în în timp ce... face condiția este verificată înainte de a executa corpul buclei, aici condiția este verificată după ce este executat corpul buclei. Aceasta înseamnă că bucla va fi executată cel puțin o dată înainte ca condiția să fie verificată.

Un ciclu este un fragment dintr-un program care se repetă de multe ori.

Există două tipuri de bucle în java: tipul „while” și tipul „n-time”.

Primul tip de „în timp” este conceput pentru a repeta o anumită acțiune atâta timp cât o anumită condiție este îndeplinită. Exemplu: măriți un număr cu 5 până când ajunge la trei cifre.

Al doilea tip „n-time” este destinat repetării unor acțiuni de un număr prestabilit de ori. Exemplu: înmulțiți un număr cu el însuși de 4 ori.

buclă while (instrucțiuni while și do...while)

Instrucțiunea while repetă acțiunile specificate atâta timp cât parametrul său este adevărat.

De exemplu, o astfel de buclă va fi executată de 4 ori, iar „1 2 3 4” va fi afișat pe ecran:

Int i = 1; in timp ce eu< 5) { System.out.print(i + " "); i++; }

O astfel de buclă nu va fi executată nici măcar o dată și nimic nu va fi afișat pe ecran:

Int i = 1; in timp ce eu< 0) { System.out.print(i + " "); i++; }

Această buclă va rula la nesfârșit, iar ecranul va afișa „1 2 3 4 5 6 7...”:

Int i = 1; în timp ce (adevărat) ( ​​System.out.print(i + " "); i++; )

Condiția care determină dacă bucla se va repeta din nou este verificată înainte de fiecare pas al buclei, inclusiv primul. Ei spun ce se întâmplă preverificare conditii.

Există un ciclu ca „pa” cu post-verificare conditii. Pentru a-l scrie, se folosește o construcție a lui do...while statements.

Această buclă va fi executată de 4 ori, iar „2 3 4 5” va fi afișat pe ecran:

< 5);

Această buclă va fi executată 1 dată, iar „2” va fi afișat pe ecran:

Int i = 1; do ( i++; System.out.print(i + " "); ) în timp ce (i< 0);

Corpul buclei do...while este executat cel puțin o dată. Acest operator este convenabil de utilizat atunci când o anumită acțiune din program trebuie efectuată cel puțin o dată, dar în anumite condiții va trebui repetat de mai multe ori.

Verificați următorul program (ghicește un număr întreg aleatoriu dintr-un segment și cere utilizatorului să-l ghicească introducând opțiuni de la tastatură, până când utilizatorul ghicește numărul, programul îl va cere, spunându-i dacă numărul ghicit este mai mare sau mai puțin decât a introdus utilizatorul):

Import java.util.Scanner; public class Main ( public static void main(String args) ( // prog - un număr creat de program // user - un număr introdus de utilizator int prog, user; // Generați un număr întreg aleatoriu de la 1 la 10 prog = (int)(Math. random() * 10) + 1; System.out.println(„M-am gândit la un număr de la 1 la 10, ghiciți-l.”); System.out.print(„Introduceți numărul dvs.: „ ); Scanner input = new Scanner( System.in); // Verificați dacă există un număr întreg în fluxul de intrare if(input.hasNextInt()) ( do ( // Citiți un întreg din fluxul de intrare user = input.nextInt) (); if(user == prog) ( System.out.println("Ați ghicit!"); ) else ( // Verificați dacă numărul este inclus în segment dacă (utilizator > 0 && utilizator)<= 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("До свиданья!"); } }

Faceți următoarele modificări în program:

Programul ar trebui să se gândească la un număr nu din segmentul , ci un număr întreg din segmentul din [−10;10], excluzând zero. În același timp, încercați să vă asigurați că distribuția numerelor aleatoare generate de program este uniformă (adică, dacă un zero cade, nu poate fi pur și simplu înlocuit cu un alt număr, de exemplu, cu 1, deoarece atunci 1 va fi a scăzut cu o probabilitate de două ori mai mare decât restul numerelor).

Programul ar trebui să informeze utilizatorul că a făcut o greșeală în semn dacă programul a ghicit un număr pozitiv și utilizatorul a introdus unul negativ. Si invers.

buclă de N timp (pentru declarație)

Declarația for conține trei parametri. Prima se numește inițializare, a doua se numește condiție de repetiție, iar a treia se numește iterație.

Pentru (inițializare; condiție; iterație) ( //corp buclă, adică acțiuni repetate ciclic)

În primul parametru, de obicei selectați o variabilă care va fi folosită pentru a număra numărul de repetări ale buclei. Se numește contor. Contorului i se dă o valoare inițială (acestea indică de la ce valoare se va schimba).

Al doilea parametru indică o anumită limitare a contorului (indicați la ce valoare se va modifica).

Al treilea parametru specifică o expresie care schimbă contorul după fiecare pas de buclă. De obicei, aceasta este o creștere sau o scădere, dar puteți utiliza orice expresie în care contorului i se va atribui o nouă valoare.

Înainte de primul pas al buclei, contorului i se atribuie o valoare inițială (se efectuează inițializarea). Acest lucru se întâmplă o singură dată.

Înainte de fiecare pas al buclei (dar după inițializare), se verifică condiția de repetiție; dacă este adevărată, atunci corpul buclei este executat din nou. În același timp, corpul buclei poate să nu fie executat nici măcar o dată dacă condiția este falsă la momentul primei verificări.

După parcurgerea fiecărui pas al buclei și înainte de a începe următorul (și deci înainte de verificarea condiției de repetare), se efectuează o iterație.

Următorul program afișează numere de la 1 la 100:

Pentru (int i = 1; i<= 100; i++) { System.out.print(i + " "); }

Următorul program afișează numere de la 10 la -10:

Pentru (int s = 10; s > -11; s--) ( System.out.print(s + " "); )

Programul prezentat afișează numere impare de la 1 la 33:

Pentru (int i = 1; i<= 33; i = i + 2) { System.out.print(i + " "); }

Programul prezentat va calcula suma elementelor unui fragment din secvența 2, 4, 6, 8,... 98, 100. Deci:

Int suma = 0; // Vom acumula rezultatul aici pentru (int j = 2; j

Programul prezentat va ridica un număr dintr-o variabilă A la grad natural de la variabil n:

Dublu a = 2; int n = 10; dublu res = 1; // Vom acumula rezultatul aici pentru (int i = 1; i<= n; i++) { res = res * a; } System.out.println(res);

Programul prezentat va afișa primele 10 elemente ale secvenței 2n+2, unde n=1, 2, 3…:

Pentru (int i = 1; i< 11; i++) { System.out.print(2*i + 2 + " "); }

Programul prezentat va afișa primele 10 elemente ale secvenței 2a n−1 +3, unde a 1 =3:

Int a = 3; pentru (i=1; i<=10;i++) { System.out.print(a + " "); a = 2*a + 3; }

Într-un ciclu, puteți seta mai multe contoare simultan. În acest caz, mai multe expresii în iterație și în inițializare sunt separate prin virgule. Poate fi specificată o singură condiție de repetiție, dar poate fi o expresie care conține mai multe contoare simultan.

Programul prezentat va afișa primele 10 elemente ale secvenței 2a n−1 -2, unde a 1 =3:

Pentru (int a=3, i=1; i<=10; a=2*a-2, i++) { System.out.print(a + " "); }

Programul prezentat va afișa următoarea secvență „0 -1 -4 -9 -16 -25”:

Pentru (int a=0, b=0; a-b<=10; a++, b--) { System.out.print(a*b + " "); }

Încheierea devreme a unei bucle (instrucțiune de întrerupere)

Atât bucla de tip „while”, cât și bucla de tip „n-time” pot fi încheiate mai devreme dacă apelați operatorul în interiorul corpului buclei pauză. În acest caz, bucla se va ieși imediat; nici măcar pasul curent nu va fi finalizat (adică, dacă au existat alte instrucțiuni după pauză, acestea nu vor fi executate).

Ca rezultat al următorului exemplu, pe ecran vor fi afișate doar numerele „1 2 3 4 End”:

Pentru (int a=1; a

Când programul execută bucla pentru a cincea oară (intră într-o buclă cu un numărător egal cu 5), condiția în care va fi executată instrucțiunea break va fi imediat verificată și găsită a fi adevărată. Partea rămasă a corpului buclei (ieșire pe ecran) nu va fi produsă: programul va continua imediat să efectueze operațiunile specificate după buclă și mai departe.

Folosind instrucțiunea break, puteți întrerupe o buclă evident infinită. Exemplu (ecranul va afișa „100 50 25 12 6 3 1 0” și după aceea bucla se va opri):

Int s = 100; în timp ce (adevărat) ( ​​System.out.print(s + " "); s = s / 2; if(s == 0) ( break; ) )

Este logic să apelați operatorul de pauză numai atunci când apare o anumită condiție, altfel bucla va fi finalizată înainte de program la primul pas.

Int a; pentru (a=25; a>0; a--) ( break; System.out.print(a + " "); ) System.out.print("a=" + a);

În exemplul de mai sus, ieșirea pe ecran într-o buclă nu va apărea nici măcar o dată și când variabila A este afișat pe ecran după buclă, se dovedește că valoarea sa nu s-a schimbat niciodată, adică va fi afișat „a=25” (și nimic mai mult).

De asemenea, rețineți că variabila a fost declarată înainte de începerea buclei. Când o variabilă este declarată în parametrii unei bucle, se dovedește a fi inaccesibilă în afara acesteia, dar în acest caz a fost nevoie de altceva - pentru a afla ce valoare va avea contorul după terminarea buclei.

Sarcini

Creați un program care să afișeze toate numerele din patru cifre în secvența 1000 1003 1006 1009 1012 1015….

Scrieți un program care să afișeze primele 55 de elemente ale secvenței 1 3 5 7 9 11 13 15 17 ….

Scrieți un program care să afișeze toate elementele nenegative ale secvenței 90 85 80 75 70 65 60….

Scrieți un program care să afișeze primele 20 de elemente ale secvenței 2 4 8 16 32 64 128 ….

Afișați toți termenii secvenței 2a n-1 -1, unde a 1 =2, care sunt mai mici de 10000.

Afișați toți termenii din două cifre ai secvenței 2a n-1 +200, unde a 1 = -166.

Creați un program care calculează factorialul unui număr natural n pe care utilizatorul îl introduce de la tastatură.

Afișează toți divizorii pozitivi ai unui număr natural introdus de utilizator de la tastatură.

Verificați dacă numărul natural introdus de utilizator de la tastatură este prim. Încercați să nu efectuați acțiuni inutile (de exemplu, după ce ați găsit cel puțin un divizor non-trivial, este deja clar că numărul este compus și nu este nevoie să continuați verificarea). De asemenea, rețineți că cel mai mic divizor al unui număr natural n, dacă există, trebuie să fie situat în segment.

Scrieți un program care să afișeze primele 12 elemente ale secvenței 2a n-2 -2, unde a 1 =3 și a 2 =2.

Afișați primii 11 termeni ai șirului Fibonacci. Vă reamintim că primul și al doilea termen al șirului sunt egali cu unii, iar fiecare următor este suma celor doi anteriori.

Pentru un număr natural introdus de utilizator de la tastatură, calculați suma tuturor cifrelor acestuia (nu se știe dinainte câte cifre vor fi în număr).

În orașul N, călătoria cu tramvaiul se efectuează folosind tichete de rupere de hârtie. În fiecare săptămână, depoul de tramvaie comandă o rolă de bilete de la tipografia locală cu numere de la 000001 la 999999. Un bilet este considerat „norocos” dacă suma primelor trei cifre ale numărului este egală cu suma ultimelor trei. cifre, ca, de exemplu, în biletele cu numerele 003102 sau 567576. Depoul de tramvai a decis să ofere un suvenir câștigătorului fiecărui bilet norocos și acum se întreabă de câte suveniruri vor fi necesare. Folosind programul, numărați câte bilete norocoase sunt într-o singură rolă?

În orașul N există un depozit mare în care sunt 50.000 de rafturi diferite. Pentru comoditatea lucrătorilor, conducerea depozitului a decis să comande o placă cu un număr de la 00001 la 50000 pentru fiecare raft de la o tipografie locală, dar atunci când plăcile au fost tipărite, s-a dovedit că tipografia, din cauza unei defecțiuni, nu a tipărit numărul 2, deci toate plăcile ale căror numere au conținut unul sau mai multe două (de exemplu, 00002 sau 20202) - trebuie să le reintroduceți. Scrieți un program care va număra câte dintre aceste plăci eronate au fost în lotul defect.

Ceasul electronic afișează ora în formatul de la 00:00 la 23:59. Numărați de câte ori pe zi se întâmplă ca în stânga colonului să fie afișată o combinație simetrică pentru cea din dreapta colonului (de exemplu, 02:20, 11:11 sau 15:51).

În armata americană, numărul 13 este considerat ghinionist, iar în japoneză - 4. Înainte de exercițiile internaționale, cartierul general al armatei ruse a decis să excludă un număr de echipamente militare care conțin numerele 4 sau 13 (de exemplu, 40123, 13313, 12345 sau 13040) pentru a nu deruta colegii străini. Dacă armata are la dispoziție 100 de mii de unități de echipament militar și fiecare vehicul de luptă are un număr de la 00001 la 99999, atunci câte numere vor trebui excluse?

2010, Alexey Nikolaevich Kostin. Departamentul TIDM, Facultatea de Matematică, Universitatea Pedagogică de Stat din Moscova.