Ultimo aggiornamento: 31.10.2018

Un altro tipo di strutture di controllo sono i loop. I cicli consentono, a seconda di determinate condizioni, di eseguire più volte una determinata azione. Il linguaggio Java ha i seguenti tipi di loop:

per ciclo

Il ciclo for ha la seguente definizione formale:

For ([inizializzazione contatore]; [condizione]; [modifica contatore]) ( // azioni )

Considera uno standard for loop:

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

La prima parte della dichiarazione di ciclo, int i = 1, crea e inizializza il contatore i. Il contatore non deve essere di tipo int . Può essere qualsiasi altro tipo numerico, come float. Prima che il ciclo venga eseguito, il valore del contatore sarà uguale a 1. In questo caso, è lo stesso della dichiarazione della variabile.

La seconda parte è la condizione in cui verrà eseguito il ciclo. In questo caso, il ciclo verrà eseguito fino a quando non raggiunge 9.

E la terza parte sta incrementando il contatore di uno. Ancora una volta, non è necessario aumentare di uno. È possibile diminuire: i-- .

Di conseguenza, il blocco del ciclo verrà eseguito 8 volte fino a quando il valore di i diventa uguale a 9. E ogni volta questo valore aumenterà di 1.

Non è necessario specificare tutte le condizioni quando si dichiara un ciclo. Ad esempio, possiamo scrivere così:

Int i = 1; for (; ;)( System.out.printf("Il quadrato di %d è %d \n", i, i * i); )

La definizione del ciclo rimane la stessa, solo che ora i blocchi nella definizione sono vuoti: for (; ;) . Ora non c'è una variabile contatore inizializzata, nessuna condizione, quindi il ciclo verrà eseguito per sempre - un ciclo infinito.

Oppure puoi omettere un certo numero di blocchi:

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

Questo esempio è equivalente al primo esempio: abbiamo anche un contatore, solo che viene creato al di fuori del ciclo. Abbiamo una condizione di esecuzione del ciclo. E c'è un incremento del contatore già nel blocco for stesso.

Il ciclo for può definire e gestire più variabili contemporaneamente:

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

fare il ciclo

Il ciclo do esegue prima il codice del ciclo e quindi controlla la condizione nell'istruzione while. E mentre questa condizione è vera, il ciclo si ripete. Per esempio:

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

In questo caso, il codice del ciclo verrà eseguito 7 volte finché j non sarà zero. È importante notare che il ciclo do garantisce che le azioni verranno eseguite almeno una volta, anche se la condizione nell'istruzione while non è vera. Quindi, possiamo scrivere:

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

Anche se j è inizialmente minore di 0, il ciclo verrà comunque eseguito una volta.

mentre loop

Il ciclo while verifica immediatamente la verità di alcune condizioni e, se la condizione è vera, viene eseguito il codice del ciclo:

int j = 6; while (j > 0)( System.out.println(j); j--; )

continuare e interrompere le affermazioni

L'istruzione break ti consente di uscire dal ciclo in qualsiasi momento, anche se il ciclo non ha terminato il suo lavoro:

Per esempio:

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

Poiché il ciclo sta verificando se l'elemento dell'array è maggiore di 10, non vedremo gli ultimi due elementi sulla console, perché quando nums[i] è maggiore di 10 (cioè uguale a 12), l'istruzione break funzionerà e il ciclo finirà.

È vero, non vedremo nemmeno l'ultimo elemento, che è inferiore a 10. Ora faremo in modo che se il numero è maggiore di 10, il ciclo non finisce, ma passa semplicemente all'elemento successivo. Per fare ciò, utilizziamo l'istruzione continue:

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

In questo caso, quando l'esecuzione del ciclo raggiunge il numero 12, che non soddisfa la condizione di test, il programma salterà semplicemente questo numero e passerà all'elemento successivo dell'array.

Come quasi tutti i linguaggi di programmazione, Java ha strumenti per ripetere un particolare pezzo di codice più e più volte. Tali strumenti sono chiamati cicli. I loop in Java sono rappresentati da istruzioni come while e for, nonché dalle loro variazioni. I loop vengono in genere utilizzati per scorrere matrici e strutture di dati unidimensionali e multidimensionali per trovare determinati elementi e quindi operare su di essi. Ma questo è tutt'altro che l'unico modo per utilizzare uno strumento come il ciclo Java. Man mano che vengono considerati, verranno forniti esempi di utilizzo.

Ciclo while Java: descrizione ed esempi

While è l'istruzione di ciclo fondamentale in Java. Il frammento di codice racchiuso nel suo corpo verrà ripetuto fino alla condizione dell'espressione racchiusa tra parentesi dopo che soddisfa il valore true. L'operatore while in generale ha la forma seguente: while (condizione)(//corpo del ciclo). Non appena il valore della condizione logica cessa di essere vero, il codice racchiuso nel corpo del ciclo cesserà di essere eseguito. Il controllo sarà trasferito alla linea che segue immediatamente. Se è presente una sola istruzione nel corpo del ciclo, le parentesi graffe possono essere omesse. Tuttavia, è considerata una buona pratica tra i programmatori averli sempre accesi. Facciamo un esempio:

classe pubblica whileDemo(

System.out.println("Stampa numeri da 1 a 10");

mentre (contare<=10) {

System.out.println(conteggio);

Il conteggio della variabile inizialmente dichiarato ha un valore di 1. Successivamente, vediamo un'espressione logica, che è racchiusa tra parentesi dopo il nome dell'operatore. Se il valore è true, il ciclo restituirà true finché il valore della variabile count non è uguale o inferiore a 10. Ad ogni passaggio o iterazione, il valore della variabile aumenterà di 1 e verrà visualizzato sullo schermo della console. Quando il valore della variabile ha raggiunto il valore 11, il ciclo è terminato. Se il valore della variabile count fosse inizialmente 11, la condizione del ciclo sarebbe falsa. Il programma non entrerebbe nemmeno nel corpo. Va notato che la sintassi Java consente di utilizzare un'istruzione While senza un corpo. Considera il seguente esempio. Supponiamo di avere due variabili: i=100 e j=200. Siamo di fronte al compito di calcolare la loro media aritmetica in modo programmatico, a questo scopo puoi usare il ciclo while "vuoto":

Mentre (++i<- — j);

Come risultato di questa operazione, il valore di una qualsiasi di queste due variabili sarà uguale alla media dei loro valori iniziali. Come puoi vedere in questo esempio, il ciclo ha funzionato bene senza un corpo ed ha eseguito tutte le azioni necessarie nell'espressione condizionale.

ciclo continuo

Negli esempi precedenti, se l'espressione della condizione ha restituito false, il programma ha ignorato il corpo del ciclo e ha continuato l'ulteriore esecuzione. Ma a volte si verificano situazioni in cui l'esecuzione del codice contenuto nel corpo del ciclo è obbligatoria almeno una volta, indipendentemente dalla verità dell'espressione della condizione. In altre parole, a volte capita che sia necessario verificare la verità dell'espressione condizionale all'inizio e non alla fine del ciclo. Funzionalità simili possono essere fornite da una sorta di ciclo while con il nome condizionale do-while. Ha la forma seguente: do (// loop body) while (condizione). Come puoi vedere, qui viene prima eseguito il corpo del ciclo, quindi viene verificata la verità della condizione. Questo viene fatto in ogni iterazione. Il codice sopra funzionerà più o meno allo stesso modo del caso di while. Ma se dovessimo impostare la variabile count su 11, il corpo del ciclo verrebbe comunque eseguito una volta prima che l'istruzione possa verificare la verità dell'espressione.

Esempi e descrizione: for - Ciclo Java

Il ciclo for è un modulo linguistico versatile ed efficiente nel linguaggio Java. Fino alla versione 5 di JavaSDK, esisteva solo una forma tradizionale dell'istruzione for. Dopo di esso, ne è apparso uno nuovo: foreach. In questa sezione ci concentreremo sulla forma tradizionale dell'operatore. Il ciclo for in Java è simile a questo:

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

Prima che il controllo venga trasferito al codice alla fine del ciclo, viene inizializzata la variabile i, che funge da contatore. Successivamente, è necessario controllare l'espressione condizionale in cui il contatore è stato confrontato con un valore specifico. Se il programma restituisce true, il corpo del ciclo viene eseguito. In questo caso, il valore del contatore viene modificato di un passo predeterminato e l'espressione condizionale viene nuovamente verificata. Questo continua fino a quando la condizione diventa falsa. Per una migliore comprensione, ecco un esempio di come funziona il ciclo Java for.

classe pubblica ForLoops(

public static void main(String args)(

valore_intenzionale=11;

per [j] = (i+l)*(j+l) ; // usa uno stile per ogni ciclo da visualizzare
// e sommando i valori
for (int x : numeri) (
per(int y: x) (
System.out.println("Il valore è: " + y);
somma += y;
}
}
System.out.println("Somma: " + somma);
}

Questo programma genera il seguente output:

Il valore è: 1
Il valore è: 2
Il valore è: 3
Il valore è: 4
Il valore è: 5
Il valore è: 2
Il valore è: 4
Il valore è: 6
Il valore è: 8
Il valore è: 10
Il valore è: 3
Il valore è: 6
Il valore è: 9
Il valore è: 12
Il valore è: 15
Importo: 9 0

La prossima riga di questo programma merita un'attenzione speciale:

for (int x : numeri) (

Presta attenzione al modo in cui x viene dichiarato. Questa variabile è un riferimento a una matrice unidimensionale di valori interi. Ciò è necessario perché il risultato di ogni iterazione del ciclo for è l'array successivo nell'array nums, a partire dall'array specificato dall'elemento nums. Il ciclo for interno scorre quindi attraverso ciascuno di questi array, visualizzando i valori di ciascuno degli elementi.

Utilizzo del ciclo for migliorato

Poiché ogni stile "for-each" per può scorrere gli elementi di un array solo in sequenza, iniziando dal primo e terminando con l'ultimo, può sembrare che il suo utilizzo sia limitato. Tuttavia, non lo è. Molti algoritmi richiedono l'uso di questo particolare meccanismo. Uno degli algoritmi più comunemente usati è la ricerca. Ad esempio, il programma seguente utilizza un ciclo for per cercare un valore in una matrice non ordinata. La ricerca si interrompe dopo aver trovato il valore desiderato.

// Cerca nell'array usando uno stile for-ogni for loop.
classSearch(
public static void main(String args) (
numeri int = ( 6, 8, 3, 7, 5, 6, 1, 4 );
intervallo=5;
booleano trovato = falso;
// usando un ciclo for nello stile for-each
per (int x: numeri) (
se (x == val) (
trovato = vero;
rompere;
}
}
se trovato)
System.out.println("Valore trovato!");)

In questo caso, la scelta dello stile "for-each" del ciclo for ha perfettamente senso, poiché la ricerca in un array non ordinato implica l'iterazione di ciascun elemento in sequenza. (Naturalmente, se l'array fosse ordinato, potrebbe essere utilizzata la ricerca binaria, che richiederebbe uno stile di ciclo diverso da implementare.) valore minimo o massimo in un set, ricerca di duplicati, ecc.

Hai bisogno di elaborare molti dati dello stesso tipo? Devi calcolare una riga? Necessità di moltiplicare matrici? Tutto questo e molto altro aiuterà a fare un ciclo! 🙂 Tutti i sistemi informatici sono stati originariamente concepiti per facilitare l'elaborazione dei dati. E l'elaborazione di una grande quantità di dati è impossibile anche da immaginare senza cicli.

In generale, i loop nella programmazione sono generalmente divisi in tre gruppi. Il primo gruppo è cicli con un contatore. In essi, il corpo del ciclo viene eseguito un certo numero di volte, inizialmente specificato dal programmatore. Tale ciclo deve essere eseguito un numero specificato di volte. Il secondo gruppo è costituito da cicli con una precondizione. In essi, il corpo del ciclo viene eseguito solo dopo aver verificato alcune condizioni e verrà eseguito finché questa condizione è vera. Tali cicli potrebbero non essere eseguiti nemmeno una volta (se la condizione è inizialmente falsa). E il terzo gruppo di cicli sono cicli con una postcondizione. In essi, viene prima eseguito il corpo del ciclo, quindi viene verificata la condizione. Questo ciclo verrà eseguito almeno una volta.

Iniziamo con un ciclo con un contatore. In Java, questo è il ciclo for; In generale si può scrivere così:

For (condizione iniziale; condizione finale; modifica) ( corpo del ciclo; )

Quindi, se vogliamo eseguire un'azione 10 volte, allora dobbiamo scrivere quanto segue:

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

un tale programma visualizzerà in sequenza numeri da zero a nove. Più in dettaglio, creiamo semplicemente una nuova variabile i e le assegniamo un valore iniziale di 0 (int i = 0;). Quindi specifichiamo che il ciclo deve essere eseguito fino a quando i< 10 и указываем каким образом должно изменяться i после каждой итерации цикла (i++).

Coloro che hanno programmato in Pascal apprezzeranno questa opportunità:

int k = 15; for (float i = 0; i

In questo esempio, il valore della variabile i aumenterà di 1,5 ad ogni iterazione. Puoi controllare:).

Il prossimo ciclo in linea è mentre. Questo è un ciclo con una precondizione e in forma generale può essere scritto in questo modo:

While(espressione booleana) ( azioni )

Bene, se prendiamo un esempio funzionante, sarà simile a questo:

Mentre (a<10) { System.Out.Print(a); a++; }

Quindi, è chiaro che questo ciclo ha senso da usare se non sai esattamente quante iterazioni sono necessarie per raggiungere l'obiettivo, ma conosci esattamente la condizione in cui verrà raggiunto il tuo obiettivo. Una tale costruzione potrebbe non essere mai eseguita (dopotutto, questo è un ciclo con una precondizione)! Quante volte verranno eseguite le azioni nel ciclo dipende dal valore che era originariamente nella variabile un.

E il terzo tipo di cicli sono cicli con una postcondizione. È molto simile a mentre... fai solo se dentro mentre... fai la condizione viene verificata prima dell'esecuzione del corpo del ciclo, qui la condizione viene verificata dopo l'esecuzione del corpo del ciclo. E questo significa che il ciclo verrà eseguito almeno una volta prima che la condizione venga verificata.

Un loop è una parte di un programma che si ripete molte volte.

Ci sono due tipi di loop in Java: il tipo "while" e il tipo "n-times".

Il primo tipo "finché" è progettato per ripetere alcune azioni finché non vengono soddisfatte alcune condizioni. Esempio: aumentare un numero di 5 finché non diventa tre cifre.

Il secondo tipo "n-volte" è progettato per ripetere alcune azioni un numero predeterminato di volte. Esempio: moltiplica un numero per se stesso 4 volte.

While Loop (dichiarazioni while e do...while)

L'istruzione while ripete le azioni specificate fintanto che il suo parametro è true.

Ad esempio, tale ciclo verrà eseguito 4 volte e sullo schermo verrà visualizzato "1 2 3 4":

Int i = 1; mentre io< 5) { System.out.print(i + " "); i++; }

Tale ciclo non verrà mai eseguito e sullo schermo non verrà visualizzato nulla:

Int i = 1; mentre io< 0) { System.out.print(i + " "); i++; }

Tale ciclo verrà eseguito a tempo indeterminato e lo schermo visualizzerà "1 2 3 4 5 6 7 ...":

Int i = 1; while (true) ( ​​System.out.print(i + " "); i++; )

La condizione che determina se il ciclo si ripeterà di nuovo viene verificata prima di ogni passaggio del ciclo, incluso prima del primo. Dicono cosa sta succedendo pre controllo termini.

C'è un ciclo while con post-verifica termini. Per scriverlo, viene utilizzata una costruzione di do ... while.

Tale ciclo verrà eseguito 4 volte e sullo schermo verrà visualizzato "2 3 4 5":

< 5);

Tale ciclo verrà eseguito 1 volta e sullo schermo verrà visualizzato "2":

Int i = 1; do ( i++; System.out.print(i + " "); ) mentre (i< 0);

Il corpo del ciclo do...while viene eseguito almeno una volta. Questo operatore è comodo da usare quando qualche azione nel programma deve essere eseguita almeno una volta, ma in determinate condizioni dovrà essere ripetuta più volte.

Dai un'occhiata al seguente programma (rileva un numero intero casuale da un segmento e chiede all'utente di indovinarlo inserendo le opzioni dalla tastiera, finché l'utente non indovina il numero, il programma gli chiederà più o meno del numero indovinato rispetto a quanto inserito dall'utente):

Importa java.util.Scanner; public class Main ( public static void main(String args) ( // prog - il numero creato dal programma // user - il numero inserito dall'utente int prog, user; // Genera un numero intero casuale da 1 a 10 prog = (int)(Math. random() * 10) + 1; System.out.println("Ho indovinato un numero da 1 a 10, indovinalo."); System.out.print("Inserisci il tuo numero: ") ; Scanner input = new Scanner( System.in); // Controlla se è presente un numero intero nel flusso di input if(input.hasNextInt()) ( do ( // Leggi un numero intero dal flusso di input user = input.nextInt( ); if(user == prog) ( System.out.println("Hai indovinato!"); ) else ( // Controlla se il numero è nell'intervallo if (user > 0 && user<= 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("До свиданья!"); } }

Apporta le seguenti modifiche al programma:

Il programma dovrebbe pensare a un numero non dal segmento , ma a un intero dal segmento da [−10;10], escluso lo zero. Allo stesso tempo, cerca di assicurarti che la distribuzione di numeri casuali generati dal programma sia uniforme (cioè in caso di caduta di uno zero, non può essere semplicemente sostituito da un altro numero, ad esempio da 1, perché allora 1 cadrà con una probabilità doppia rispetto ai numeri rimanenti).

Il programma dovrebbe richiedere all'utente di aver commesso un errore nel segno se il programma ha indovinato un numero positivo e l'utente ne ha inserito uno negativo. E viceversa.

Tipo di ciclo "n-volte" (istruzione per)

L'istruzione for contiene tre parametri. Il primo è chiamato inizializzazione, il secondo è la condizione di ripetizione e il terzo è l'iterazione.

For (inizializzazione; condizione; iterazione) ( // corpo del ciclo, ovvero azioni ripetute ciclicamente)

Nel primo parametro viene solitamente scelta una variabile, con l'aiuto della quale verrà contato il numero di ripetizioni del ciclo. Si chiama contatore. Al contatore viene assegnato un valore iniziale (indicano da quale valore cambierà).

Nel secondo parametro è indicata qualche restrizione sul contatore (indicano a quale valore cambierà).

Il terzo parametro specifica un'espressione che cambia il contatore dopo ogni passaggio del ciclo. Di solito si tratta di un incremento o decremento, ma è possibile utilizzare qualsiasi espressione in cui al contatore verrà assegnato un nuovo valore.

Prima della prima fase del ciclo, al contatore viene assegnato un valore iniziale (viene eseguita l'inizializzazione). Questo accade solo una volta.

Prima di ogni passaggio del ciclo (ma dopo l'inizializzazione), viene verificata la condizione di ripetizione, se è vera, viene eseguito nuovamente il corpo del ciclo. Allo stesso tempo, il corpo del ciclo potrebbe non essere eseguito nemmeno una volta se la condizione è falsa al momento del primo controllo.

Dopo il completamento di ogni passaggio del ciclo e prima dell'inizio del successivo (e, quindi, prima di verificare la condizione di ripetizione), viene eseguita un'iterazione.

Il seguente programma stampa i numeri da 1 a 100 sullo schermo:

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

Il seguente programma stampa i numeri da 10 a −10 sullo schermo:

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

Il programma presentato mostra i numeri dispari da 1 a 33:

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

Il programma presentato calcolerà la somma degli elementi del frammento di sequenza 2, 4, 6, 8, ... 98, 100. Quindi:

somma int = 0; // Qui accumuleremo il risultato per (int j = 2; j

Il programma presentato solleverà un numero da una variabile un a potenza naturale da variabile n:

Doppia a = 2; int n = 10; doppia risoluzione = 1; // Qui accumuleremo il risultato per (int i = 1; i<= n; i++) { res = res * a; } System.out.println(res);

Il programma presentato mostrerà i primi 10 elementi della sequenza 2n+2, dove n=1, 2, 3…:

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

Il programma presentato mostrerà i primi 10 elementi della sequenza 2a n−1 +3, dove a 1 =3:

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

In un ciclo è possibile impostare più contatori contemporaneamente. In questo caso, diverse espressioni nell'iterazione e nell'inizializzazione sono separate da virgole. È possibile specificare solo una condizione di ripetizione, ma può essere un'espressione contenente più contatori contemporaneamente.

Il programma presentato visualizzerà i primi 10 elementi della sequenza 2a n−1 -2, dove a 1 =3:

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

Il programma presentato visualizzerà la seguente sequenza "0 -1 -4 -9 -16 -25":

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

Terminazione anticipata del ciclo (istruzione break)

Sia il ciclo di tipo "while" che il ciclo di tipo "n-volte" possono essere completati prima del previsto se si chiama l'operatore all'interno del corpo del ciclo rompere. In questo caso, si verificherà un'uscita istantanea dal ciclo, anche il passaggio corrente non verrà completato (ovvero, se ci fossero altre istruzioni dopo l'interruzione, non verranno eseguite).

Come risultato del seguente esempio, sullo schermo verranno visualizzati solo i numeri "1 2 3 4 End":

Per (int a=1; a

Quando il programma esegue il ciclo per la quinta volta (entra nel ciclo con un contatore pari a 5), ​​verrà immediatamente verificato e la condizione in cui verrà eseguita l'istruzione break sarà vera. Il resto del corpo del loop (output a schermo) non verrà più prodotto: il programma procederà immediatamente all'esecuzione delle operazioni specificate dopo il loop e oltre.

Con l'aiuto dell'istruzione break, puoi interrompere un ciclo deliberatamente infinito. Esempio (lo schermo visualizzerà “100 50 25 12 6 3 1 0” e successivamente il loop si fermerà):

int s = 100; while (true) ( ​​System.out.print(s + " "); s = s / 2; if(s == 0) ( break; ) )

Ha senso chiamare l'istruzione break solo quando si verifica una condizione, altrimenti il ​​ciclo verrà terminato prima della pianificazione al primo passaggio.

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

Nell'esempio sopra, l'output nel ciclo sullo schermo non avverrà nemmeno una volta e quando la variabile un viene visualizzato sullo schermo dopo il ciclo, risulta che il suo valore non è mai cambiato, ovvero verrà visualizzato “a=25” (e nient'altro).

Si noti inoltre che la variabile è stata dichiarata prima dell'inizio del ciclo. Quando una variabile viene dichiarata nei parametri del ciclo, risulta essere inaccessibile al di fuori di essa, e in questo caso era richiesto diversamente: per scoprire quale valore avrà il contatore dopo la fine del ciclo.

Compiti

Scrivete un programma che visualizzi tutti i numeri a quattro cifre nella sequenza 1000 1003 1006 1009 1012 1015 ….

Scrivete un programma che visualizzi i primi 55 elementi della sequenza 1 3 5 7 9 11 13 15 17 ….

Scrivete un programma che visualizzi tutti gli elementi non negativi della sequenza 90 85 80 75 70 65 60 ….

Scrivete un programma che visualizzi i primi 20 elementi della sequenza 2 4 8 16 32 64 128 ….

Stampa tutti i termini della sequenza 2a n-1 -1, dove a 1 =2, che sono minori di 10000.

Stampa tutti i termini a due cifre della sequenza 2a n-1 +200, dove a 1 = -166.

Scrivere un programma che calcoli il fattoriale di un numero naturale n che l'utente immette dalla tastiera.

Visualizza tutti i divisori positivi di un numero naturale inserito dall'utente dalla tastiera.

Verificare se il numero naturale inserito dall'utente dalla tastiera è primo. Cerca di non compiere azioni non necessarie (ad esempio, dopo aver trovato almeno un divisore non banale, è già chiaro che il numero è composto e non è necessario continuare a controllare). Si noti inoltre che il più piccolo divisore di un numero naturale n, se presente, si trova necessariamente nel segmento.

Scrivete un programma che visualizzi i primi 12 elementi della sequenza 2a n-2 -2, dove a 1 =3 e a 2 =2.

Visualizza i primi 11 termini della sequenza di Fibonacci. Ricordiamo che il primo e il secondo termine della successione sono uguali a uno, e ogni successivo è la somma dei due precedenti.

Per un numero naturale inserito dall'utente da tastiera, calcolare la somma di tutte le sue cifre (non si sa in anticipo quante cifre ci saranno nel numero).

Nella città di N, il viaggio in tram viene effettuato con biglietti a strappo cartacei. Ogni settimana il deposito del tram ordina alla tipografia locale un rotolo di biglietti con i numeri da 000001 a 999999. Un biglietto "fortunato" è quello in cui la somma delle prime tre cifre del numero è uguale alla somma dell'ultimo tre cifre, come ad esempio nei biglietti con i numeri 003102 o 567576. Il deposito del tram ha deciso di regalare un ricordo al proprietario di ogni biglietto fortunato e ora si chiede quanti ricordi saranno necessari. Usando il programma, conta quanti biglietti fortunati ci sono in un rotolo?

City N dispone di un ampio magazzino con 50.000 scaffali diversi. Per comodità dei lavoratori, la direzione del magazzino ha deciso di ordinare una targa con un numero da 00001 a 50000 per ogni scaffale della tipografia locale, ma quando le lastre sono state stampate, si è scoperto che la macchina da stampa non ha stampato il numero 2 a causa di un malfunzionamento, quindi tutte le targhe che ne contenevano una o più due (ad esempio 00002 o 20202) - devono essere ridigitate. Scrivete un programma che conterà quante di queste lastre errate erano in un lotto difettoso.

L'orologio elettronico mostra l'ora nel formato dalle 00:00 alle 23:59. Calcola quante volte al giorno capita che venga mostrata una combinazione simmetrica a sinistra dei due punti per quella a destra dei due punti (ad esempio, 02:20, 11:11 o 15:51).

Nell'esercito americano, il numero 13 è considerato sfortunato e nei giapponesi - 4. Prima delle esercitazioni internazionali, il quartier generale dell'esercito russo ha deciso di escludere i numeri di equipaggiamento militare contenenti i numeri 4 o 13 (ad esempio 40123, 13313, 12345 o 13040) per non mettere in imbarazzo i colleghi stranieri. Se l'esercito ha a sua disposizione 100.000 unità di equipaggiamento militare e ogni veicolo da combattimento ha un numero compreso tra 00001 e 99999, quanti numeri dovranno essere esclusi?

2010, Aleksej Nikolaevič Kostin. Dipartimento di TIDM della Facoltà di Matematica dell'Università Pedagogica Statale di Mosca.