Esercizi di programmazione

Questa pagina contiene esercizi utili per esercitarsi a programmare, utilizzando un qualsiasi linguaggio di programmazione.

Classificazione degli esercizi

Tipo di esercizio Esercizi
Base 01, 02, 08, 20, 21, 22, 106, 128, 142
Selezione 03, 04, 05, 06, 07, 09, 23, 29, 30, 39, 40, 93, 94, 141
Iterazione 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 41, 42, 43, 44, 45, 46, 47, 53, 54, 55
Vettori 31, 65, 66, 67, 68, 69, 70, 71, 143A, 143B, 144, 145
Funzioni 24, 25, 26, 27, 28, 32, 63, 64, 88, 91, 92, 112A, 112B, 113
Vettori e funzioni 33, 34, 35, 36, 37, 38, 152
Funzioni ricorsive 271, 341, 351, 361, 48, 49, 50, 51, 52, 59, 61, 62
Matrici 56, 57
Matrici e funzioni 58, 60
Stringhe 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87
Stringhe e funzoni 89, 90, 126, 127
Valori casuali e funzioni 95, 96, 97, 98, 99, 100, 101, 102, 103, 107
Valori casuali 146, 147, 148, 149, 150, 151
Struct, enum, typedef 104, 105
Set 112C, 117, 118, 124
Dizionari 112D, 119, 120, 121, 122, 123, 125, 130, 131, 132, 133, 138, 140
Tuple 129, 137, 140
Gestione dei file 134, 135, 136, 139

Esercizio 01

Scrivi un algoritmo che, letti in input tre numeri interi, restituisce come output la loro media aritmetica.

Esercizio 02

Scrivi un algoritmo che, letti in input due numeri reali, restituisce come output la loro somma.

Esercizio 03

Scrivi un algoritmo che, letto in input un numero intero, restituisce come output il doppio di quel numero se esso è positivo, altrimenti restituisce come output la sua metà.

Esercizio 04

Un’equazione di primo grado nell’incognita x può essere scritta così:

a x + b = 0

Dove a, b sono dei numeri, detti coefficienti.

Scrivi un algoritmo che, letti in input i valori dei coefficienti a, b, restituisce come output il risultato dell’equazione. I coefficienti possono essere numeri reali qualsiasi.

Esercizio 05

Scrivi un algoritmo che, letto in input un numero reale, il quale rappresenta il prezzo di un prodotto, applica uno sconto del 20% se tale prezzo supera 100€.

L’algoritmo restituisce come output il prezzo finale, eventualmente scontato.

Esercizio 06

Scrivi un algoritmo che, letto in input un anno, restituisce in output “anno bisestile” se esso è, appunto, un anno bisestile, altrimenti non restituisce nulla.

Un anno è bisestile se è divisibile per 400, oppure se è divisibile per 4 ma non per 100.

Ad esempio:

Esercizio 07

Un’equazione di secondo grado nell’incognita x può essere scritta così:

a x2 + b x + c = 0

Dove a, b, c sono dei numeri, detti coefficienti.

Scrivi un algoritmo che, letti in input i valori dei coefficienti a, b, c, restituisce come output il risultato dell’equazione. I coefficienti possono essere numeri reali qualsiasi.

Esercizio 08

Scrivi un algoritmo che, date le coordinate cartesiane di due punti, calcola la loro distanza. Ad esempio, acquisite le coordinate dei punti A = (1,2) e B = (4,6), l’algoritmo restituisce la distanza d = 5.

Esercizio 09

Scrivi un algoritmo che restituisce il risultato di una sfida a Carta Forbice Sasso.

L’algoritmo legge in input la scelta del primo giocatore, poi legge in input la scelta del secondo giocatore. Infine, restituisce in output “Vittoria giocatore 1” oppure “Vittoria giocatore 2” oppure “Pareggio”.

Esercizio 10

Scrivi un algoritmo che stampa i primi 25 numeri pari, partendo dal numero 2.

Esercizio 11

Scrivi un algoritmo che stampa i primi 15 numeri dispari, partendo dal numero 1.

Esercizio 12

Scrivi un algoritmo che, letto in input un numero naturale, restituisce i suoi primi dieci multipli, partendo da se stesso.

Ad esempio, letto in input il numero naturale 8, l’algoritmo dovrà restituire i numeri 8, 16, 24, 32, 40, 48, 56, 64, 72, 80.

Esercizio 13

Scrivi un algoritmo che stampa il quadrato di tutti i numeri naturali da 1 a N, dove N è un numero inserito in input dall’utente.

Esercizio 14

Scrivi un algoritmo che restituisce la somma di tutti i numeri da 1 a N, dove N è un numero intero chiesto in input all’utente.

Nota bene: per questo esercizio bisogna utilizzare:

Esercizio 15

Scrivi un algoritmo che, letto in input un numero naturale, restituisce i suoi divisori interi. Ad esempio, letto in input il numero naturale 10, l’algoritmo dovrà restituire i numeri 1, 2, 5, 10.

Nota bene: un numero N è divisibile per un numero d se e solo se il resto della divisione N / d è uguale a zero. Per ottenere il resto di una divisione, in programmazione si usa il simbolo %.

Ad esempio:

Esercizio 16

Scrivi un algoritmo che, letto in input un numero naturale, restituisce il fattoriale di quel numero.

Il fattoriale di un numero naturale N è il prodotto dei numeri interi positivi minori o uguali a tale numero. Ad esempio:

Per definizione, 0! = 1.

Nota bene: per questo esercizio bisogna utilizzare:

Esercizio 17

Scrivi un algoritmo che, letto in input un numero intero positivo, restituisce “Vero” se tale numero è primo, altrimenti “Falso”.

Un numero intero positivo è primo quando è divisibile soltanto per 1 e per se stesso.

Esercizio 18

La successione di Fibonacci è una successione di numeri interi in cui ciascun numero è la somma dei due precedenti, eccetto i primi due che sono, per definizione, 0 e 1. I primi numeri della successione sono: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55…

Scrivi un algoritmo che restituisce i primi N numeri della successione di Fibonacci. N è una variabile da chiedere in input all’utente.

Esercizio 19

Scrivi un algoritmo che, letti in input un numero intero b e un numero intero positivo e, restituisce la potenza e-esima di b.

Ad esempio, se b = -2 ed e = 3, l’algoritmo restituirà -8, ovvero il risultato di (-2)3.

Esercizio 20

Scrivi un algoritmo che chieda all’utente di immettere un numero a due cifre e, successivamente, stampi il numero con le cifre invertite. Una sessione del programma deve presentarsi come segue:

Inserisci un numero di due cifre: 28
Il contrario è: 82

Esercizio 21

Scrivi un algoritmo che accetti la data dall’utente nella forma mm/gg/aaaa per poi stamparla nella forma aaaammgg, ad esempio:

Inserisci una data (mm/gg/aaaa): 2/17/2023
Hai inserito la data 20230217

Esercizio 22

Scrivi un algoritmo che, letta in input una temperatura espressa in gradi Fahrenheit, restituisca come output la stessa temperatura, ma espressa in gradi Celsius.

Se F è la temperatura in Fahrenheit, la temperatura C espressa in Celsius si calcola così:

C=59(F−32)

Esercizio 23

Scrivi un algoritmo che, letti in input due numeri interi, restituisce come output il massimo tra i due. Se essi sono uguali, mostra il messaggio: “Uguale valore!”

Esercizio 24

Scrivi una funzione in grado di risolvere un’equazione di primo grado.

La segnatura della funzione deve essere:

float solve(float a, float b);

def solve(a: float, b: float) -> float | str

Dove a e b rappresentano i coefficienti dell’equazione di primo grado. Per maggiori dettagli, vedi l’Esercizio 04.

La funzione Python restituisce il risultato dell’equazione, oppure le stringhe Equazione impossibile o Equazione indeterminata.

Esercizio 25

Scrivi una funzione la quale restituisce true se un dato anno è bisestile, altrimenti false.

La segnatura della funzione deve essere:

bool is_leap_year(int year);

def is_leap_year(year: int) -> bool

Dove year è l’anno di cui devi valutare la bisestilità. Per maggiori dettagli, vedi l’Esercizio 06.

Esercizio 26

Scrivi una funzione la quale restituisce una lista contenente i primi dieci multipli di un numero N.

La segnatura della funzione deve essere:

def multiples(n: int) -> list[int]

Dove n è il numero di cui bisogna ottenere i primi dieci multipli. Per maggiori dettagli, vedi l’Esercizio 12.

Esercizio 27

Scrivi una funzione la quale restituisce il fattoriale di un numero N.

La segnatura della funzione deve essere:

long int factorial(int N);

Dove N è il numero di cui bisogna ottenere il fattoriale. Per maggiori dettagli, vedi l’Esercizio 16.

Esercizio 28

Scrivi una funzione la quale restituisce la temperatura espressa in gradi Celsius, data la temperatura espressa in Fahrenheit.

La segnatura della funzione deve essere:

float to_celsius(float F);

def to_celsius(fahrenheit: float) -> float

Dove F è la temperatura espressa in gradi Fahrenheit. Per maggiori dettagli, vedi l’Esercizio 22.

Esercizio 29

Scrivi un algoritmo che, letto in input il valore di uno scambio di azioni, restituisce come output le commissioni da pagare al broker per quello scambio.

Quando delle azioni sono vendute o comprate attraverso un broker finanziario, la commissione del broker viene calcolata utilizzando una scala mobile che dipende dal valore delle azioni scambiate. Diciamo che le commissioni di un broker corrispondano a quelle illustrate nella seguente tabella:

Dimensione della transazione (in $) Commissione
[0, 2.500) 30$ + 1,7%
[2.500, 6.250) 56$ + 0,66%
[6.250, 20.000) 76$ + 0,34%
[20.000, 50.000) 100$ + 0,22%
[50.000, 500.000) 155$ + 0,11%
[500.000, +∞) 255$ + 0,09%

La commissione minima è di 39$.

Ecco un esempio:

Inserisci il valore dello scambio: 30000
Commissioni: $166.00

Esercizio 30

Scrivi un algoritmo che legge in input una data, scritta nel formato mm/gg/aaaa, e restituisce come output la stessa data nel formato “legale” inglese. Ad esempio:

Enter a date (mm/dd/yyyy): 7/19/2014
Legal format: 19th day of July, 2014.

Oppure:

Enter a date (mm/dd/yyy): 10/2/2023
Legal format: 2nd day of October, 2023.

Presta attenzione alle desinenze inglesi ‘st’, ‘nd’, ‘rd’, ‘th’ davanti al numero del giorno.

Esercizio 31

Scrivi un algoritmo che chiede all’utente di inserire dieci numeri interi, su una stessa riga, separati da uno spazio.

Dopodiché, l’algoritmo mostra come output quegli stessi numeri, ma riscritti in ordine inverso. Ad esempio:

Inserisci 10 numeri:    34 82 49 102 -7 94 23 -11 50 31
In ordine inverso:      31 50 -11 23 94 -7 102 49 82 34

Esercizio 32

Scrivi una funzione la quale, ricevuto come parametro un numero intero, mostra in output le singole cifre di quel numero, al contrario, una per riga, e non restituisce nulla.

La segnatura della funzione deve essere:

void digits(int n);

Ad esempio: digits(4321) –>
1
2
3
4

Consiglio: usa un ciclo while nel quale, all’inizio ogni iterazione, ottieni la cifra più a destra con n % 10. Alla fine di ogni iterazione, dividi n per 10: n = n / 10.

Esercizio 33

Scrivi una funzione la quale, ricevuto come parametro un numero intero, restituisce true se il numero presenta delle cifre ripetute, altrimenti false.

La segnatura della funzione deve essere:

bool repeated_digit(int n);

Consiglio: per risolvere l’esercizio, puoi costruire un vettore di 10 elementi, chiamato ad esempio seen, con tutti gli elementi inizialmente uguali a false. Con un ciclo for, percorri le cifre del numero n (come fare?). Se una cifra c è incontrata per la prima volta (ovvero se seen[c] == false), nel vettore seen poni seen[c] = true. Se la cifra c è già stata incontata (ovvero se seen[c] == true), allora hai incontrato una cifra ripetuta: fai in modo che la tua funzione termini subito, restituendo il valore true.

Ricorda che per usare true e false devi includere nel tuo file la libreria stdbool.h.

Ad esempio:

Esercizio 34

Scrivi una funzione la quale, ricevuto come parametro un vettore di interi, restituisce la somma di tutti gli elementi del vettore.

La segnatura della funzione deve essere:

int sum(int nums[], int LEN);

Dove LEN è la lunghezza del vettore.

Ad esempio: sum({33, 19, -4, 101, 21}, 5) –> 170

Esercizio 35

Scrivi una funzione la quale, ricevuto come parametro un vettore di interi, restituisce il massimo tra tutti gli elementi del vettore.

La segnatura della funzione deve essere:

int max(int nums[], int LEN);

Dove LEN è la lunghezza del vettore.

Ad esempio: max({33, 19, -4, 101, 21}, 5) –> 101

Esercizio 36

Scrivi una funzione la quale, ricevuto come parametro un vettore di interi, restituisce il minimo tra tutti gli elementi del vettore.

La segnatura della funzione deve essere:

int min(int nums[], int LEN);

Dove LEN è la lunghezza del vettore.

Ad esempio: min({33, 19, -4, 101, 21}, 5) –> -4

Esercizio 37

Scrivi una funzione la quale, ricevuti come parametri due vettori di interi, restituisce true se i due vettori sono uguali, altrimenti false.

Due vettori sono uguali se e solo se:

La segnatura della funzione deve essere:

bool equal(int v1[], int l1, int v2[], int l2);

Dove l1, l2 sono le lunghezze dei vettori.

Ad esempio:

equal({1, 2}, 2, {1, 2}, 2) –> true
equal({1, 2}, 2, {1, 2, 3}, 3) –> false
equal({1, 2}, 2, {2, 1}, 2) –> false

Esercizio 38

Scrivi una funzione la quale, ricevuto come parametro un vettore di interi e un numero intero value, restituisce quante volte il value è ripetuto nel vettore.

La segnatura della funzione deve essere:

int count(int v[], int len, int value);

Dove len è la lunghezza del vettore.

Ad esempio:

count({1, 1, 4}, 3, 1) –> 2
count({-1, -6, -9, 0}, 4, 10) –> 0

Esercizio 39

Scrivi un algoritmo che, letti in input tre numeri interi, mostra in output il massimo e il minimo tra di essi.

Esercizio 40

Scrivi un algoritmo che, lette in input le lunghezze dei tre lati di uno stesso triangolo, controlla che sia rispettata la disuguaglianza triangolare.

In matematica, la disuguaglianza triangolare afferma che, in un triangolo non degenere, la somma delle lunghezze di due lati è maggiore della lunghezza del terzo.

Se la disuguaglianza triangolare è rispettata, l’algoritmo mostra in output la scritta: “Triangolo valido!”. Altrimenti, non mostra nulla.

Esercizio 41

Scrivi un algoritmo che, letto in input un numero intero positivo N, restituisce come output la prima potenza del 2 maggiore o uguale a quel numero.

Ecco degli esempi di output attesi, dati dei valori per il parametro N:

N Output atteso
0 1
9 16
121 128
64 64

Esercizio 42

Scrivi un algoritmo che, letto in input un numero intero positivo N, restituisce come output tutti i numeri interi, da N a 0 (estremi esclusi).

Esercizio 43

Scrivi un algoritmo che, letto in input un numero intero positivo N, restituisce come output la tavola dei quadrati dei numeri da 1 a N. Ad esempio, se N valesse 10:

N = 10
         1         1
         2         4
         3         9
         4        16
         5        25
         6        36
         7        49
         8        64
         9        81
        10       100

Nota bene: fai in modo che i numeri siano perfettamente allineati, come nell’esempio qui sopra.

Esercizio 44

Scrivi un algoritmo che legge in input dei numeri interi inseriti dall’utente. Quando l’utente inserisce il numero 0, l’algoritmo smette di leggere l’input.

L’algoritmo deve restituire la somma dei numeri immessi in input dall’utente.

Un esempio:

Numeri (0 per terminare):
8
23
71
5
0

Somma = 107

Esercizio 45

Scrivi un algoritmo che, letto in input un numero intero non negativo N, restituisce come output il numero di cifre di quel numero.

Esercizio 46

Qual è l’output del seguente frammento di programma?

int i = 1;

while (i <= 128)
{
    printf("%d", i);
    i *= 2;
}

Controlla la tua ipotesi eseguendo il codice C.

Esercizio 47

Qual è l’output del seguente frammento di programma?

int i = 9384;

do
{
    printf("%d ", i);
    i /= 10;
} while(i > 0);

Controlla la tua ipotesi eseguendo il codice C.

Esercizio 48

Scrivi una funzione la quale, ricevuti come parametri due vettori di interi di uguale lunghezza, restituisce true se i due vettori sono uguali, altrimenti false.

Due vettori di uguale lunghezza sono uguali se e solo se in ogni posizione conservano lo stesso valore.

La segnatura della funzione deve essere:

bool equal(int v1[], int v2[], int l);

Dove l è la lunghezza dei due vettori.

Ad esempio:

equal({1, 2}, {1, 2}, 2) –> true
equal({3, 1, 2}, {1, 2, 3}, 3) –> false
equal({1, 2}, {2, 1}, 2) –> false

Esercizio 49

Scrivi una funzione la quale, ricevuto come parametro un numero intero positivo N, restituisce l’N-esimo numero della sequenza di Fibonacci.

La segnatura della funzione deve essere:

int fibonacci(int n);

Al suo interno, la funzione fibonacci deve sfuttare una funzione ricorsiva, fibonacci_rec, con la seguente segnatura:

int fibonacci_rec(int n, int a, int b);

Ecco alcuni esempi di input e di output atteso:

n fibonacci(n)
0 1
1 1
5 8
7 21
10 89

Esercizio 50

Scrivi una funzione che riceve come parametri due numeri naturali, m ed n, la quale mostra i primi m multipli di n, partendo dal più grande (n * m) e arrivando al più piccolo n.

La segnatura della funzione deve essere:

void multipli(int n, int m);

Ecco alcuni esempi di input e output attesi:

n m multipli(n, m)
5 4 20 15 10 5
11 8 88 77 66 55 44 33 22 11

Esercizio 51

Scrivi una funzione che riceve come parametri due numeri naturali, m ed n, la quale mostra i primi m multipli di n, partendo dal più piccolo (n) e arrivando al più grande (n * m).

La segnatura della funzione deve essere:

void multipli(int n, int m);

Ecco alcuni esempi di input e output attesi:

n m multipli(n, m)
5 4 5 10 15 20
11 8 11 22 33 44 55 66 77 88

Esercizio 52

Scrivi una funzione ricorsiva che mostri in output le istruzioni utili a risolvere il gioco della torre di Hanoi.

La segnatura della funzione deve essere:

void hanoi(int n, char from, char helper, char to);

Dove:

Ad esempio, la chiamata hanoi(3, 'A', 'B', 'C'); deve far apparire le seguenti istruzioni:

Move disc from A to C
Move disc from A to B
Move disc from C to B
Move disc from A to C
Move disc from B to A
Move disc from B to C
Move disc from A to C

Esercizio 53

Scrivi un algoritmo che, letto in input un numero intero positivo, mostra in output le singole cifre di quel numero, separate da uno spazio, in ordine inverso. Ad esempio, se il numero in input fosse 2812, l’algoritmo mostrerebbe come output: 2 1 8 2.

Consiglio: usa un ciclo while nel quale, all’inizio ogni iterazione, ottieni la cifra più a destra con n % 10. Alla fine di ogni iterazione, dividi n per 10: n = n / 10.

Esercizio 54

Scrivi un algoritmo che continua a chiedere dei numeri interi in input all’utente, finché egli non inserisce il numero 0. A quel punto, mostra in output il massimo valore inserito.

Esercizio 55

Scrivi un algoritmo che continua a chiedere dei numeri interi in input all’utente, finché egli non inserisce il numero 0. A quel punto, mostra in output la media dei valori inseriti (escluso lo zero).

Nota bene: Se l’utente immette subito il numero 0, allora non deve apparire nessun output.

Nota bene: la media di numeri interi, in generale, è un numero reale. Mostra la media con due cifre decimali.

Esercizio 56

Scrivi un algoritmo che crea una matrice 10x10, nella quale salva le tabelline dei numeri da 1 a 10. Poi, mostra in output il contenuto della matrice. L’output apparirà così:

  1   2   3   4   5   6   7   8   9  10
  2   4   6   8  10  12  14  16  18  20
  3   6   9  12  15  18  21  24  27  30
  4   8  12  16  20  24  28  32  36  40
  5  10  15  20  25  30  35  40  45  50
  6  12  18  24  30  36  42  48  54  60
  7  14  21  28  35  42  49  56  63  70
  8  16  24  32  40  48  56  64  72  80
  9  18  27  36  45  54  63  72  81  90
 10  20  30  40  50  60  70  80  90 100

Esercizio 57

Scrivi un algoritmo che, data la seguente matrice 10x10:

int m[10][10] = {
    {47, -94, 4, 35, 44, 1, 26, 9, -7, 70},
    {-17, 46, -16, -7, 7, 68, -2, -94, -27, -42},
    {-96, -31, -96, 6, -51, -64, -28, 37, -59, -52},
    {-7, 26, -59, 63, -20, -26, 30, 34, 5, 44},
    {-22, -53, -64, 88, -97, -72, 43, -19, -83, -42},
    {-85, -46, 37, 32, -38, -81, -50, -78, 83, 6},
    {44, -19, -42, -16, 84, 97, 5, -68, 10, -61},
    {80, 94, 20, -49, -59, 67, 84, -36, 64, 18},
    {-35, -75, -99, 95, -46, -36, -75, 72, -93, -2},
    {88, -75, -24, -81, -57, -28, -30, -91, 20, 88},
};

Mostra in output, sulla stessa riga, separati da uno spazio, gli elementi della diagonale principale, ovvero quella in cui gli indici di riga e colonna sono uguali. Quali sono tali elementi?

Esercizio 58

Scrivi una funzione che, ricevuta come parametro una matrice 10x10, restituisce come output la somma degli elementi della diagonale secondaria, ovvero quella che parte da in alto a destra e finisce in basso a sinistra.

La segnatura della funzione deve essere:

int sum_sec_diag(int matrix[10][10]);

Quanto vale la somma degli elementi della diagonale secondaria della matrice dell’esercizio precedente?

Esercizio 59

Scrivi una funzione ricorsiva che, dati due numeri naturali, ne calcoli il massimo comune divisore tramite sottrazioni ripetute.

La segnatura della funzione deve essere:

int mcd(int a, int b);

Ad esempio:

mcd(10, 5) –> 5

mcd(273, 105) –> 21

Esercizio 60

Scrivi una funzione che, ricevuta come parametro una matrice 5x5, mostra in output la sua matrice trasposta.

La segnatura della funzione deve essere:

void transpose(int matrix[5][5]);

Ad esempio, data la matrice:

int m[5][5] = {
    {-35, -62, -26, -37, -31},
    {82, 20, 37, 90, -20},
    {51, -7, -80, -29, 41},
    {4, 23, 6, 14, 11},
    {22, 46, -70, 96, -46},
};

Chiamando transpose(m), apparirà come output:

-35  82  51   4  22
-62  20  -7  23  46
-26  37 -80   6 -70
-37  90 -29  14  96
-31 -20  41  11 -46

Esercizio 61

Scrivi una funzione ricorsiva che, ricevuto come parametro un numero intero positivo n, mostra in output la successione di Collatz di n.

La segnatura della funzione deve essere:

void collatz(int n);

La congettura di Collatz riguarda il seguente algoritmo:

  1. si prenda un numero intero positivo n.

  2. se n = 1, l’algoritmo termina.

  3. Se n è pari, si divida per due; altrimenti si moltiplichi n per 3 e si aggiunga 1.

È possibile formare una successione applicando la funzione ripetutamente prendendo come primo elemento un qualunque intero positivo e, ad ogni passaggio, applicare la funzione al risultato precedente.

Per esempio, iniziando con n = 6, otteniamo la successione 6, 3, 10, 5, 16, 8, 4, 2, 1.

La congettura di Collatz asserisce che questo algoritmo giunge sempre a termine, indipendentemente dal valore di partenza.

Rimane una congettura (e non un teorema), poiché nessuno è mai riuscito a dimostrare formalmente la ragione di questo comportamento.

Esercizio 62

Scrivi una funzione ricorsiva chemostra il risultato della funzione 91 di McCarthy, dato un numero intero qualsiasi.

La segnatura della funzione deve essere:

void mccarthy(int n);

La funzione 91 di McCarthy è una funzione ricorsiva che restituisce 91 per tutti gli argomenti n ≤ 101 e restituisce n − 10 per n > 101.

La Funzione 91 di McCarthy è definita come segue:

Funzione 91 di McCarthy

Esercizio 63

Scrivi una funzione che, ricevuto come parametro un numero naturale, restituisce true se tale numero è abbondante, altrimenti false.

La segnatura della funzione deve essere:

bool abbondante(int n);

def abbondante(n: int) -> bool

Un numero naturale N è detto abbondante se la somma dei suoi divisori (N escluso) è maggiore di N stesso.

Ad esempio, 12 è un numero abbondante, poiché 1 + 2 + 3 + 4 + 6 = 16 > 12.

Qual è il primo numero abbondante e dispari? Nel main(), scrivi del codice che sfrutti la funzione abbondante() per rispondere a questa domanda.

Esercizio 64

Scrivi una funzione che, ricevuto come parametro un numero naturale, restituisce true se tale numero è perfetto, altrimenti false.

bool perfetto(int n);

def perfetto(n: int) -> bool

Un numero naturale N è detto perfetto se è uguale alla somma dei suoi divisori, N escluso.

Ad esempio, 6 è un numero perfetto, poiché 1 + 2 + 3 == 6.

Quali sono i primi quattro numeri perfetti? Nel main(), scrivi del codice che sfrutti la funzione perfetto() per rispondere a questa domanda.

Esercizio 65

Scrivi un algoritmo che:

  1. chiede all’utente di inserire cinque numeri interi in input, e li salva in un vettore
  2. mostra in output i valori contenuti nel vettore
  3. mostra in output i valori contenuti nel vettore, sommando +8 a ciascun valore

Ecco un esempio esatto dell’input/output di questo algoritmo:

N = 1
N = 8
N = -13
N = 10
N = 11

I valori del vettore:
v[0] = 1
v[1] = 8
v[2] = -13
v[3] = 10
v[4] = 11

I valori del vettore, con un incremento di +8:
v[0] + 8 = 9
v[1] + 8 = 16
v[2] + 8 = -5
v[3] + 8 = 18
v[4] + 8 = 19

Esercizio 66

Scrivi un algoritmo che:

  1. chiede all’utente di inserire dei numeri interi in input e li salva in un vettore, finché l’utente non inserisce un numero negativo, oppure fino ad aver letto 20 valori. Il numero negativo non deve fare parte del vettore.
  2. mostra in output i valori contenuti nel vettore
  3. mostra in output la somma dei valori contenuti nel vettore.

Ecco un esempio esatto dell’input/output di questo algoritmo:

Inserisci dei numeri interi positivi:
3
10
12
18
-4

I valori del vettore:
v[0] = 3
v[1] = 10
v[2] = 12
v[3] = 18

Somma = 43

Esercizio 67

Scrivi un algoritmo che:

  1. chiede all’utente di inserire dei numeri interi in input e li salva in un vettore, finché l’utente non inserisce un numero multiplo di 17. Tale numero multiplo di 17 non deve fare parte del vettore.
  2. mostra in output i valori
  3. mostra in output la somma dei valori in posizione pari
  4. mostra in output la somma dei valori in posizione dispari
  5. mostra in output la differenza tra le due somme sopra citate

Ecco un esempio esatto dell’input/output di questo algoritmo:

Inserisci dei numeri interi positivi:
3
10
-9
8
23
17

I valori:
v[0] = 3
v[1] = 10
v[2] = -9
v[3] = 8
v[4] = 23

Somma dei valori in posizione pari: 17
Somma dei valori in posizione dispari: 18
Differenza: -1

Esercizio 68

Scrivi un algoritmo che chiede all’utente di inserire dei numeri nell’intervallo [0, 20) (0 è incluso, mentre 20 è escluso). Appena l’utente inserisce un valore esterno a questo intervallo, l’algoritmo smette di chiedere valori in input. L’algoritmo deve mostrare quante volte un certo valore è stato inserito in input dall’utente. Ecco un esempio dell’input/output di questo programma:


Inserisci dei valori nell'intervallo [0, 20):
12
12
0
3
9
8
4
12
3
21

La frequenza di 0 è stata: 1
La frequenza di 1 è stata: 0
La frequenza di 2 è stata: 0
La frequenza di 3 è stata: 2
La frequenza di 4 è stata: 1
La frequenza di 5 è stata: 0
La frequenza di 6 è stata: 0
La frequenza di 7 è stata: 0
La frequenza di 8 è stata: 1
La frequenza di 9 è stata: 1
La frequenza di 10 è stata: 0
La frequenza di 11 è stata: 0
La frequenza di 12 è stata: 3
La frequenza di 13 è stata: 0
La frequenza di 14 è stata: 0
La frequenza di 15 è stata: 0
La frequenza di 16 è stata: 0
La frequenza di 17 è stata: 0
La frequenza di 18 è stata: 0
La frequenza di 19 è stata: 0

Suggerimento: crea un vettore di 20 elementi interi. All’inizio, poni tutti i valori del vettore pari a 0. Poi, se l’utente, ad esempio, inserisce il numero 8, allora incrementi di 1 il valore in posizione 8 del vettore.

Esercizio 69

La serie di Fibonacci è 0, 1, 1, 2, 3, 5, 8, 13, … dove ogni numero è pari alla somma dei due precedenti. Scrivi un algoritmo che dichiari il vettore fib_numbers e lo riempia con i primi 20 numeri di Fibonacci.

Suggerimento: riempi i primi due numeri individualmente e poi usa un ciclo per calcolare i rimanenti.

Ecco l’output di questo programma:


0 0
1 1
2 1
3 2
4 3
5 5
6 8
7 13
8 21
9 34
10 55
11 89
12 144
13 233
14 377
15 610
16 987
17 1597
18 2584
19 4181

Esercizio 70

Scrivi un algoritmo che:

  1. crea un vettore a, il quale contiene cinque numeri interi nell’intervallo [-100, 100], inseriti in input dall’utente
  2. crea un vettore b, il quale contiene cinque numeri interi nell’intervallo [-100, 100], generati in maniera pseudo-casuale
  3. mostra in output i valori contenuti nei due vettori
  4. mostra in output la scritta: Maggiore! se ciascun elemento di a è maggiore dell’elemento di b nella stessa posizione. Altrimenti, mostra in output la scritta: Non maggiore :(

Ad esempio:

n = 88
n = 102
Valore non valido, riprova.
n = -3
n = -23
n = 3
n = -222
Valore non valido, riprova.
n = 2

a = [88, -3, -23, 3, 2]
b = [-6, 81, 85, 25, 17]

Non maggiore :(

Esercizio 71

Scrivi un algoritmo che riempie un vettore di 10 numeri pseudo-casuali nell’intervallo [-20, 5].

L’algoritmo mostra in output la scritta: OK 😎 se tutti (!) i valori contenuti nel vettore sono negativi e dispari. Altrimenti, mostra in output la scritta: KO ☹️

Esercizio 72

Scrivi un algoritmo che chiede all’utente di inserire 10 valori interi e li salva in una lista.

L’algoritmo mostra in output la scritta: Ordinato 😎 se i valori nella lista sono ordinati in ordine crescente. Altrimenti, mostra in output la scritta: Disordinato ☹️

Esercizio 73

Scrivi un algoritmo che, chiesto in input il nome dell’utente, lo saluta. L’input/output del programma sarà di questo tipo:


Come ti chiami? Angelo
Ciao, Angelo!

Attenzione:


Come ti chiami? Marco Tullio Cicerone
AVVISO: il tuo nome è più lungo di 20 caratteri: solo i primi 20 saranno salvati.
Ciao, Marco Tullio Ciceron!

Esercizio 74

Parti dalla soluzione all’esercizio precedente e aggiungi questa funzionalità: fai in modo che, se l’utente clicca invio, senza inserire alcun nome, si mostri un messaggio di errore, e gli si chieda di nuovo di inserire un nome.

Ecco un esempio dell’input/output:


Come ti chiami?
ERRORE: non hai inserito alcun nome. Riprova.

Come ti chiami? Marco Tullio Cicerone
AVVISO: il tuo nome è più lungo di 20 caratteri: solo i primi 20 saranno salvati.
Ciao, Marco Tullio Ciceron!

Esercizio 75

Parti dalla soluzione all’esercizio precedente e aggiungi questa funzionalità: fai in modo che, anche quando il nome inserito dall’utente è più lungo del consentito, si mostri un messaggio di errore, e gli si chieda di nuovo di inserire un nome.

Ecco un esempio dell’input/output:


Come ti chiami?
ERRORE: non hai inserito alcun nome. Riprova.

Come ti chiami? Marco Tullio Cicerone
ERRORE: hai inserito un nome troppo lungo. Riprova.

Come ti chiami? Angelo
Ciao, Angelo!

Esercizio 76

Parti dalla soluzione all’esercizio precedente e aggiungi questa funzionalità: fai in modo che, se il nome inserito contiene degli spazi all’inizio o alla fine, si mostri un messaggio di errore, e gli si chieda di nuovo di inserire un nome.

Ecco un esempio dell’input/output:


Come ti chiami?
ERRORE: non hai inserito alcun nome. Riprova.

Come ti chiami? Angelo
ERRORE: Il nome contiene degli spazi iniziali. Riprova.

Come ti chiami? Angelo // Non si vede, ma qui l'utente ha messo degli spazi alla fine del nome
ERRORE: Il nome contiene degli spazi finali. Riprova.

Come ti chiami? Marco Tullio Cicerone
ERRORE: hai inserito un nome troppo lungo. Riprova.

Come ti chiami? Angelo
Ciao, Angelo!

Esercizio 77 (esercizio riassuntivo)

Parti dalla soluzione all’esercizio precedente e aggiungi questa funzionalità: dopo aver chiesto all’utente il suo nome, chiedigli di inserire il nome della città in cui vive. Per il nome della città, devono essere applicati gli stessi controlli applicati per il nome dell’utente. Ecco un esempio dell’input/output, quando l’utente inserisce al primo colpo dei valori accettabili:


Come ti chiami? Angelo
Dove abiti? Osnago

Ciao, Angelo!
Abiti a Osnago

Esercizio 78

Scrivi un algoritmo che, ricevuto in input un testo qualsiasi, restituisce il numero di parole presenti in quel testo. Con “parole” si intendono le parti del testo divise da spazi. Il testo termina con un \n.


Now is better than never. Although never is often better than _right_ now.

Numero di parole nel testo: 13

Hint: sei sicuro che sia necessario usare una variabile stringa per questo esercizio?

Esercizio 79A

Il palindromo è una sequenza di caratteri che, letta al contrario, rimane invariata. Sono esempi di palindromi: “” (la stringa vuota), “A”, “101”, “osso”…

Non sono esempi di palindromi: “Natan” (la prima N è maiuscola, l’ultima minuscola), “asso”, “permesso”, “Aa”…

Scrivi un algoritmo che chiede una parola come input e mostra in output: PALINDROMO! se la parola è palindroma, altrimenti Non palindromo.

Esercizio 79B

Parti dalla soluzione dell’esercizio precedente e migliorala, aggiungendo questa funzionalità: il programma deve mostrare un messaggio di errore e chiedere nuovamente di inserire una parola se l’utente inserisce una parola più lunga del massimo consentito. Ad esempio, se la lunghezza massima consentita per le stringa fosse 5, questo sarebbe l’input/utput del programma:


Inserisci una parola: OssessO
ERRORE: lunghezza massima 5. Parola inserita troppo lunga. Riprovare.

Inserisci una parola: Coccodrillo
ERRORE: lunghezza massima 5. Parola inserita troppo lunga. Riprovare.

Inserisci una parola: natan
PALINDROMO!

Esercizio 79C

Parti dalla soluzione dell’esercizio precedente e generalizzala, aggiungendo questa funzionalità: se anche la capitalizzazione delle lettere è diversa, il tuo programma può riconoscere una stringa palindroma. Ad esempio, le parole “Natan”, “OsSesso”, “ONno”, che finora non sarebbero state riconosciute come palindrome, essendo alcune lettere maiuscole e altre minuscole, ora, invece, dovranno dare come output: PALINDROMO!

Esercizio 80A

Scrivi un algoritmo che, ricevuta in input una password, mostra in output la scritta: Password robusta 😎 se la password:

  1. è lunga almeno 10 caratteri
  2. contiene almeno una lettera maiuscola
  3. contiene almeno una cifra numerica

Altrimenti, mostra come output: Very, very bad password 🧐. Due esempi:

$ ./es80
Password: ciao
Lunghezza: 4

Very, very bad password 🧐

$ ./es80
Password: IncrediblyStrongPa22w0rd
Lunghezza: 24

Password robusta 😎

Esercizio 80B

Parti dalla soluzione all’esercizio precedente e rendi l’output più esplicito, così da aiutare l’utente a capire cosa va bene e cosa non va bene della sua password. Esempi:

$ ./es80
Password: ciao
Lunghezza: 4

Very, very bad password 🧐
⛔️ Lunghezza non adatta
⛔️ Cifra numerica assente
⛔️ Lettera maiuscola assente

$ ./es80
Password: IncrediblyStrongPa22w0rd
Lunghezza: 24

Password robusta 😎
✅ Lunghezza adatta
✅ Cifra numerica presente
✅ Lettera maiuscola presente

$ ./es80
Password: LungaMaSenzaNumeri
Lunghezza: 18

Very, very bad password 🧐
✅ Lunghezza adatta
⛔️ Cifra numerica assente
✅ Lettera maiuscola presente

Esercizio 81

Scrivi un algoritmo che chiede all’utente di inserire in input un testo. Poi, chiede all’utente di indicare una lettera. L’algoritmo mostra in output quante volte quella lettera è ripetuta nel testo. La capitalizzazione della lettera non conta: essa può essere presente sia in minuscolo sia in maiuscolo: deve essere considerata. Ecco un esempio dell’input/output di questo programma:

Testo:
Nel mezzo del cammin di nostra vita mi ritrovai per una selva oscura, ché la diritta via era smarrita. Ahi quanto a dir qual era è cosa dura esta selva selvaggia e aspra e forte che nel pensier rinova la paura!

Carattere: a
Il carattere 'a' appare 29 volte.

Testo:
Nel mezzo del cammin di nostra vita mi ritrovai per una selva oscura, ché la diritta via era smarrita. Ahi quanto a dir qual era è cosa dura esta selva selvaggia e aspra e forte che nel pensier rinova la paura!

Carattere: A
Il carattere 'A' appare 1 volte.

Esercizio 82

Scrivi un algoritmo che chiede all’utente di inserire in input un testo. L’algoritmo restituisce in output quel testo, ma al contrario. Esempio:

Testo:
Nel mezzo del cammin di nostra vita mi ritrovai per una selva oscura, ché la diritta via era smarrita. Ahi quanto a dir qual era è cosa dura esta selva selvaggia e aspra e forte che nel pensier rinova la paura!

Testo al contrario:
!aruap al avonir reisnep len ehc etrof e arpsa e aiggavles avles atse arud asoc �� are lauq rid a otnauq ihA .atirrams are aiv attirid al ��hc ,arucso avles anu rep iavortir im ativ artson id nimmac led ozzem leN

Noterai che le lettere accentate non sono correttamente ‘rovesciate’. Questo è normale. Se chiedi al prof., può spiegarti la ragione 🤓

Esercizio 83

Scrivi un algoritmo che chiede all’utente in input un testo. L’algoritmo restituisce in output quel testo, ma con la capitalizzazione invertita. Ad esempio:

Testo:
NeL MeZzO DeL CaMmIn dI NoStRa vItA Mi rItRoVaI PeR UnA SeLvA OsCuRa, ChÉ La dIrItTa vIa eRa sMaRrItA. aHi qUaNtO A DiR QuAl eRa è cOsA DuRa eStA SeLvA SeLvAgGiA E AsPrA E FoRtE ChE NeL PeNsIeR RiNoVa lA PaUrA!
nEl mEzZo dEl cAmMiN Di nOsTrA ViTa mI RiTrOvAi pEr uNa sElVa oScUrA, cHÉ lA DiRiTtA ViA ErA SmArRiTa. AhI QuAnTo a dIr qUaL ErA è CoSa dUrA EsTa sElVa sElVaGgIa e aSpRa e fOrTe cHe nEl pEnSiEr rInOvA La pAuRa!

Hint: sei sicuro che sia necessario usare una variabile stringa per questo esercizio?

Esercizio 84

Scrivi un algoritmo che chiede in input all’utente un testo. L’algoritmo restituisce in output quel testo, ma con gli spazi ` ` sostituiti dal carattere ` `. Ad esempio:

Testo:
Ricchi X sempre
Ricchi_X_sempre

Esercizio 85

Questo è un tabellone 3x3 (come nel gioco “crucis”). Ovviamente, sono disponibili in molte altre dimensioni (8x8 per gli scacchi, 19x19 per Go e molti altri).

 --- --- ---
|   |   |   |
 --- --- ---
|   |   |   |
 --- --- ---
|   |   |   |
 --- --- ---

Scrivi un algoritmo che chiede all’utente la dimensione del tabellone da realizzare e poi stampa quel tabellone. Devi chiedere all’utente un numero intero, finché egli ne inserirà uno nell’intervallo [1, 10].

Non servono stringhe. Bisogna solo saper stampare ‘bene’ caratteri!

Esercizio 86

Scrivi un algoritmo che chiede all’utente di scrivere una sequenza di caratteri e la salva in una stringa. Se l’utente inserisce una stringa vuota, oppure una più lunga del massimo consentito (300), mostra un messaggio di errore e termina l’esecuzione.

Con la sequenza di caratteri corretta, l’algoritmo conta quante sono le vocali presenti in essa, e mostra tale numero in output. Ad esempio:

Inserisci una sequenza di caratteri: aiuola
La stringa contiene 5 vocali.

Esercizio 87

Scrivi un algoritmo che chiede all’utente di scrivere una sequenza di caratteri e la salva in una stringa. Se l’utente inserisce una stringa vuota, oppure una più lunga del massimo consentito (300), mostra un messaggio di errore e termina l’esecuzione.

Con la sequenza di caratteri corretta, l’algoritmo controlla se essa sia vocal-palindroma. Una stringa è vocal-palindroma se è palindroma considerando esclusivamente le vocali. Ad esempio, ‘asta’ è vocal-palindroma (pur non essendo palindroma in senso stretto), poiché, se ci si concentra solo sulle vocali, esse sono effettivamente in posizione speculare.

‘vocal-palindromo’ è un termine che non esiste, appena inventato dal prof.

Esempi di input/output:

Inserisci una sequenza di caratteri: asta
VOCAL-PALINDROMO!

Inserisci una sequenza di caratteri: anna
VOCAL-PALINDROMO!

Inserisci una sequenza di caratteri: nicolo
Non vocal-palindromo.

Inserisci una sequenza di caratteri: luca
Non vocal-palindromo.

Inserisci una sequenza di caratteri: aria
Non vocal-palindromo.

Esercizio 88

Tutte le richieste dell’esercizio 88 devono essere svolte in uno stesso file.

Esercizio 88A

Scrivi una funzione che, ricevuto come parametro un numero intero positivo, restituisce true se tale numero è primo, altrimenti false.

La segnatura della funzione deve essere:

bool primo(int n);

def primo(n: int) -> bool

Un numero naturale è primo se:

Per 0 e 1, la funzione deve restituire false.

Esercizio 88B

Nel main() (in Python, nel __main__), scrivi del codice che sfrutta la funzione primo() per ottenere i primi dieci numeri primi maggiori di 150. Essi sono:

151
157
163
167
173
179
181
191
193
197

Esercizio 88C

Scrivi una funzione che, ricevuto come parametro un numero intero positivo, restituisce true se tale numero è composto, altrimenti false.

La segnatura della funzione deve essere:

bool composto(int n);

def composto(n: int) -> bool

Per implementare la funzione composto(), sfrutta la funzione primo(), precedentemente definita.

Per 0 e 1, la funzione deve restituire false.

Esercizio 88D

Nel main(), scrivi del codice che sfrutta la funzione composto() per ottenere i tutti i numeri dispari e composti compresi tra 150 e 200. Essi sono:

153
155
159
161
165
169
171
175
177
183
185
187
189
195

Esercizio 89

Scrivi una funzione che, ricevuta una stringa come parametro, restitusce come risultato il numero di vocali presenti nella stringa.

La segnatura della funzione deve essere:

def conta_vocali(s: str) -> int

Non importa che la vocale sia in maiuscolo o in minuscolo: essa deve essere considerata.

Ad esempio, la stringa gicIWBlC0D2GwuoREsCPvRddjXJQboS5 contiene 6 vocali. La stringa AiUolA contiene 5 vocali.

Esercizio 90

Scrivi una funzione che, ricevuti come parametri una stringa, restitusce come risultato la vocale che appare più spesso in quella stringa. Se più vocali appaiono con la stessa, massima, frequenza, restituisce l’ultima vocale con la frequenza massima. L’ordine considerato per le vocali è: a, e, i, o, u.

La segnatura della funzione deve essere:

char vocale_maxima(char s[]);

def vocale_maxima(s: str) -> str

Non importa che la vocale sia in maiuscolo o in minuscolo: essa deve essere considerata.

Ad esempio, nella stringa gicIWBlC0D2GwuoREsCPvRddjXJQboS5 la vocale maxima è o. Nella stringa AiUolA la vocale maxima è a. Nella stringa aAeEiIoOuU, la vocale maxima è u.

Esercizio 91

Scrivi una funzione che, ricevuti come parametri un numero tra 1 e 12, rappresentante un mese dell’anno, e un numero tra 1 e 31, rappresentante un giorno del mese, restituisca quanti giorni mancano all’8 giugno.

La segnatura deve essere:

int byebyescuola(int mese, int giorno);

def byebyescuola(mese: int, giorno: int) -> int:

Questo frammento di codice può esserti utile nella risoluzione:

switch (mese)
{
    case 7: count += 31;
    case 8: count += 31;
    case 9: count += 30;
    case 10: count += 31;
    case 11: count += 30;
    case 12: count += 31;
    case 1: count += 31;
    case 2: count += 28;
    case 3: count += 31;
    case 4: count += 30;
    case 5: count += 31;
    case 6: count += 7;
}

Esercizio 91B

Nel main(), usa la funzione byebyescuola() per sapere quanti giorni mancano alla fine della scuola. Se, ad esempio, invocassi la funzione con la data dell’1 maggio, otterrei questo output:

Mancano 37 giorni al 7 giugno!

Esercizio 91C (opzionale)

La funzione byebyescuola() è stata implementata senza considerare il problema degli anni bisestili.

Per esercizio, potresti modificarla come:

int byebyescuola(int anno, int mese, int giorno);

def byebyescuola(anno: int, mese: int, giorno: int) -> int:

e, sfruttando la funzione is_leap_year() implementata in altri esercizi, dare un risultato ancora più preciso!

Esercizio 92 (opzionale)

In matematica, la congettura di Goldbach è uno dei più vecchi problemi irrisolti nella teoria dei numeri. Essa afferma questo:

Ogni numero naturale pari maggiore di 2 può essere scritto come somma di due numeri primi (che possono essere anche uguali).

Scrivi una funzione che, ricevuto come parametro un numero naturale n, restituisce il numero di coppie di numeri primi che, sommati, danno come risultato n.

La segnatura della funzione deve essere:

int goldbach(int n);

Ad esempio, se n valesse 90, la funzione restituirebbe come risultato 9, poiché esistono nove coppie di numeri primi che, sommati, danno 90 come risultato. Le coppie sono queste:

7 83
11 79
17 73
19 71
23 67
29 61
31 59
37 53
43 47

Nota bene: attento a non considerare due volte la stessa coppia. Se hai contato la coppia (3, 47), non contare la coppia (47, 3). Ovvero, itera fino a n / 2 anziché fino a n.

Per risolvere l’esercizio, è utile utilizzare la funzione primo() implementata nell’esercizio 88. A parole, dentro alla funzione goldbach() dovrà accadere questo: crea una variabile contatore, count, inizialmente uguale a 0. Per ogni coppia di numeri a e b i quali, sommati, danno n, controlla che entrambi siano numeri primi. Se sì, aumenta di uno count. Fnite le coppie (a, b), restituisci il valore di count.

Esercizio 92B

Nel main(), utilizza la funzione goldbach() per ottenere l’output seguente:

Coppie di primi che, sommati, danno 90: 9
Coppie di primi che, sommati, danno 92: 4
Coppie di primi che, sommati, danno 94: 5
Coppie di primi che, sommati, danno 96: 7
Coppie di primi che, sommati, danno 98: 3

Esercizio 93

Scrivi un algoritmo che, chiesto in input un numero intero n, restituisce come risultato la somma degli angoli interni di un poligono di n lati. Una formula per calcolare la somma degli angoli interni di un poligono di n lati è:

S ( n ) = ( n − 2 ) ⋅ 180

Se l’utente inserisce un numero minore o uguale a 2, l’algoritmo mostra il messaggio di errore Valore non valido e termina l’esecuzione.

Esercizio 94

Scrivi un algoritmo che chiede all’utente di indicare un’operazione da svolgere tra -, +, *, :, ^ (elevamento a potenza). Poi, chiede all’utente di inserire due numeri interi a e b. L’algoritmo restituisce come risultato quello ottenuto applicando l’operazione scelta ai due numeri interi inseriti.

Se il divisore è 0, l’algoritmo mostra un messaggio di errore.

Se l’utente sceglie un’operazione non consentita, l’algoritmo mostra un messaggio di errore.

Un esempio dell’input/output di questo algoritmo:

Operazione = +
a = 12
b = -4

Risultato = 8

Esercizio 95

Implementa la funzione randbool(), la quale restituisce un valore di verità casuale. Con la seguente segnatura:

bool randbool();

def randbool()-> bool:

Nel main(), usa la funzione randbool(), precedentemente implementata, per riempire una lista con 5 valori di verità casuali. Infine, mostra in ouput i valori contenuti nella lista.

Esercizio 96

Implementa la funzione randnat(), con la seguente segnatura:

int randnat(int limit);

Essa restituisce un numero naturale casuale, nell’intervallo [0, limit].

Anche limit è un possibile valore restituito dalla funzione.

Nel main(), usa la funzione randnat(), precedentemente implementata, per riempire un vettore con 5 numeri naturali casuali. Usa come limite, ad esempio, 10. Infine, mostra in ouput i valori contenuti nel vettore.

Esercizio 97

Implementa la funzione randint(), con la seguente segnatura:

int randint(int a, int b);

Essa restituisce un numero intero casuale, nell’intervallo [a, b].

Anche a e b sono possibili valori restituiti dalla funzione.

Nel main(), usa la funzione randint(), precedentemente implementata, per riempire un vettore con 5 numeri interi casuali. Genera i valori casuali, ad esempio, nell’intervallo [-10, 10]. Infine, mostra in ouput i valori contenuti nel vettore.

Esercizio 98

Implementa la funzione randchar(), con la seguente segnatura:

char randchar();

Il linguaggio C tratta i caratteri come fossero dei numeri interi, secondo il codice ASCII. Ad esempio, il numero intero 97 è interpretato come il carattere a. Ecco una tabella con tutte le equivalenze.

def randchar() -> str:

Essa restituisce un carattere minuscolo casuale.

Nel main(), usa la funzione randchar(), precedentemente implementata, per riempire un vettore con 5 caratteri minuscoli casuali. Infine, mostra in ouput i valori contenuti nel vettore.

Puoi sfruttare la funzione randint() per risolvere più facilmente questo esercizio?

Esercizio 99

Implementa la funzione randchar(), con la seguente segnatura:

char randchar(bool upper);

def randchar(upper: bool) -> str:

Se il parametro upper è true, essa restituisce un carattere maiuscolo casuale. Altrimenti, restituisce un carattere minuscolo casuale.

Nel main(), usa la funzione randchar(), precedentemente implementata, per riempire una lista con 10 caratteri casuali.

Il valore del parametro upper dev’essere anch’esso casuale.

Infine, mostra in ouput i valori contenuti nella lista.

Esercizio 100

Implementa la funzione randfloat_01(), con la seguente segnatura:

float randfloat_01();

Essa restituisce un valore reale casuale, nell’intervallo [0, 1].

Nota bene: Nella libreria stdlib.h si trova la costante RAND_MAX, la quale contiene il massimo valore casuale generabile dal dispositivo che sta eseguendo il programma. Può tornarvi molto utile 😉

Nel main(), usa la funzione randfloat_01(), precedentemente implementata, per riempire un vettore con 5 valori reali casuali in [0, 1]. Infine, mostra in ouput i valori contenuti nel vettore.

Esercizio 101

Implementa la funzione randfloat_positive(), con la seguente segnatura:

float randfloat_positive(int limit);

Essa restituisce un valore reale casuale, nell’intervallo [0, limit].

Nel main(), usa la nuova funzione randfloat_positive(), precedentemente implementata, per riempire un vettore con 5 valori reali positivi casuali. Infine, mostra in ouput i valori contenuti nel vettore.

Esercizio 102

Implementa la funzione randfloat(), con la seguente segnatura:

float randfloat(int a, int b);

def randfloat(a: int, b: int) -> float:

Essa restituisce un valore reale casuale, nell’intervallo [a, b].

Nel main(), usa la nuova funzione randfloat(), precedentemente implementata, per riempire una lista con 5 valori reali casuali. Infine, mostra in ouput i valori contenuti nella lista.

Esercizio 103

Crea una libreria di funzioni, contenente le funzioni precedentemente implementate per la generazione di valori casuali, qui elencate per comodità:

bool randbool();
int randnat(int limit);
int randint(int a, int b);
char randchar();
float randfloat_01();
float randfloat_positive(int limit);
float randfloat(int, int);
  1. Inserisci il codice sopra scritto in un file chiamato myrandom.h
  2. Implementa le funzioni sopra elencat in un file chiamato myrandom.c

I file myrandom.h e myrandom.c serviranno in esercizi futuri. Tienili da parte!

def randbool() -> bool:
def randchar() -> str:
def randfloat(a: int, b: int) -> float:

Nota bene: molte delle funzioni sopra elencate possono essere implementate in maniera più semplice sfruttando alcune delle funzioni che le precedono nell’elenco. Se non lo hai già fatto, re-implementa le funzioni più complesse sfruttando, dove serve, quelle più semplici.

Esercizio 104a

Esercizio 104b

Crea una copia del file creato nell’esercizio 104a. Quindi, nella copia, implementa le seguenti funzioni:

void print_mese(Mese);
void print_data(Data);
void print_materia(Materia);
void print_voto(Voto);
void print_valutazione(Valutazione);

Esse servono a mostrare in output, rispettivamente, un variabile Mese, una variabile Data…

Ad esempio, data la seguente data:

Data d = {8, Novembre, 2024};

La funzione print_data() la mostrerà in output così:

Data = 8 Novembre 2024

Oppure, data la seguente valutazione:

Valutazione v = {{7, Novembre, 2024}, 8.5, Informatica};

La funzione print_valutazione() la mostrerà in output così:

Valutazione =
	Materia = Informatica
	Voto = 8.50
	Data = 7 Novembre 2024

Esercizio 104c

Crea una copia del file creato nell’esercizio 104b.

Procurati i file myrandom.c e myrandom.h creati nell’esercizio 103.

Quindi, nella copia di 104b, implementa le seguenti funzioni:

Mese random_mese();
Giorno random_giorno(Mese, Anno);
Anno random_anno();
Data random_data();
Materia random_materia();
Voto random_voto();
Valutazione random_valutazione();

Il significato di ciascuna di esse dovrebbe essere chiaro.

Nota bene: la funzione random_giorno() riceve come parametri un Mese e un Anno poiché essa deve sia restituire un giorno valido per il mese dato, sia retituire un giorno valido, considerando che l’anno dato sia bisestile oppure no!

Nota bene: la funione random_voto() restituisce un voto casuale tra 0 e 10, che sia o un voto intero (es.: 9), oppure un mezzo voto (es.: 7.5), oppure un quarto di voto (es.: 7.25 o 8.75). Nient’altro!

Esercizio 104d

Crea una copia del file creato nell’esercizio 104c. Quindi, nella copia, all’interno del main():

  1. crea un vettore di variabli di tipo Valutazione, di lunghezza 5
  2. popola il vettore con cinque valutazioni casuali, sfruttando la funzione random_valutazione()
  3. mostra in output le cinque valutazione casuali contenute nel vettore, sfruttando la funzione print_valutazione()

Se hai svolto per intero l’esercizio 104, dovresti avere un file contenente circa duecento righe di codice. Complimenti! 😊

Esercizio 105a

Lo scopo di questo esercizio 105 è creare un piccolo piccolo registro elettronico per la gestione delle assenze di uno studente.

Crea le seguenti strutture dati:

Esercizio 105b

Crea una copia del file creato nell’esercizio 105a. Quindi, nella copia, implementa le seguenti funzioni:

void print_data(Data);
void print_assenza(Assenza);
void print_studente(Studente);

Il significato di ciascuna funzione è piuttosto auto-esplicativo.

Poi, nel main(), crea uno Studente, con dei dati a tua scelta, e prova a usare la funzione print_studente() per osservare tali dati. L’output della funzione dovrebbe apparire simile a questo:

Studente =
Nome = Matteo
Cognome = Derflingher
Assenza =
	Data = 18 Novembre 2024
	Giustificata = 1
Assenza =
	Data = 19 Novembre 2024
	Giustificata = 0

Quello qui sopra è l’output per uno studente chiamato Matteo Derfligher, con due assenze in date diverse, di cui una giustificata e l’altra no.

Esercizio 105c

Crea una copia del file creato nell’esercizio 105b. Quindi, nella copia, implementa la seguente funzione:

Studente aggiungi_assenza(Studente s, Assenza a);

Tale funzione riceve come parametri uno studente e un’assenza da aggiungere a esso. Quindi, restituisce come risultato quello stesso studente, ma con l’assenza a aggiunta all’elenco.

Assicurati di aggiornare opportunamente il valore della variabile n_assenze e di rispettare il limite di 10 assenze.

Nel main(), prova a:

  1. stampare lo studente PRIMA di aggiungergli una nuova assenza
  2. aggiungere un’assenza allo studente con la funzione aggiungi_assenza()
  3. stampare lo studente DOPO avergli aggiunto una nuova assenza

Esercizio 106

Scrivi un algoritmo che, assegnati valori distinti a due variabili a e b:

  1. mostra in output il contenuto delle variabili
  2. scambia il contenuto delle due variabili
  3. mostra in output il contenuto delle variabili

Mi raccomando: devi riuscire a scambiare il valore contenuto nelle variabili a e b. Niente scorciatoie!

Esempio:

a = 3, b = 8
a = 8, b = 3

Esercizio 107

Scrivi un algoritmo che, riempita una lista con 30 numeri interi casuali tra -10 e 10:

  1. mostra i valori contenuti nella lista
  2. mostra i valori contenuti nella lista, in ordine crescente
  3. mostra la media dei valori
  4. mostra la media dei valori pari
  5. mostra la mediana dei valori
  6. mostra il valore massimo
  7. mostra la frequenza del valore massimo
  8. cerca di ottenere un aspetto dell’input/output identico a questo:
lista           = [6, -6, 0, -1, -1, -1, 7, 1, 0, -7, 2, 3, -4, -2, -5, 2, -3, 9, -6, 0, 10, 2, -7, -3, 1, -7, 6, 0, -8, 0]
lista ordinata  = [-8, -7, -7, -7, -6, -6, -5, -4, -3, -3, -2, -1, -1, -1, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 3, 6, 6, 7, 9, 10]
media           = -0.40
media pari      = 0.12
media pari      = 0.125
mediana         = 0.0
massimo         = 10
freq. massimo   = 1

In Python, nella libreria di funzioni statistics, potresti trovare delle funzioni utili ad esempio per il calcolo della mediana…

Esercizio 108

Scrivi un algoritmo che, riempita una lista con 10 numeri interi casuali tra -10 e 10:

  1. mostra la lista
  2. fa apparire la scritta: “Pari tutti pari!” se tutti i numeri in posizione pari sono pari
  3. mostra la media dei valori in posizione dispari
  4. mostra la media dei valori negativi
  5. mostra la mediana della lista ottenuta considerando solo i numeri pari presenti nella lista

Esercizio 109

Scrivi un algoritmo che generi una sequenza di 20 caratteri pseudo-casuali. Poi:

  1. mostra la stringa in output
  2. mostra solo i caratteri in posizione pari
  3. mostra la stringa al contrario
  4. chiede all’utente un carattere da rimuovere dalla stringa. Ottenuto tale carattere, se esso è presente nella stringa, anziché rimuoverlo, lo ripete tre volte! Ad esempio, se la stringa fosse abaco e l’utente chiedesse di rimuovere la b, l’algoritmo mostrerebbe in output: abbbaco

Esercizio 110

Gaio Giulio Cesare era solito cifrare i propri messaggi destinati ai varii suoi comandanti di legione. Prima di consegnare un messaggio a un ambasciatore, faceva questo: prendeva il testo in chiaro e sostituiva ogni lettera con quella situata tre posizioni oltre nell’alfabeto. Ad esempio, il messaggio “avepompeus” diventava: “dyhsrpshxv”.

In Python, importa l’alfabeto delle lettere minuscole così: from string import ascii_lowercase. Poi, scrivi un algoritmo che, chiesta in input una stringa all’utente:

  1. rimuove tutti gli spazi e mostra il risultato in output
  2. considerando il testo ottenuto al punto precedente, rende tutte le lettere minuscole. Mostra il risultato in output
  3. considerando il testo ottenuto al punto precedente, sostituisce tutte le lettere non presenti in ascii_lowercase con la lettera z e mostra il risultato in output
  4. cifra il messaggio ottenuto al punto precedente usando il cifrario di Cesare. Infine, mostra il messaggio cifrato in output.

Un esempio:

Testo in chiaro = Nicolò Sala

NicolòSala
nicolòsala
nicolzsala

Testo cifrato = qlfrocvdod

Esercizio 111

Il seguente testo è stato ottenuto utilizzando un cifrario simile a quello di Cesare. L’unica differenza è che, anziché usare come chiave di cifratura tre, ne è stata usata un’altra, sconosciuta. Prova a trovare il testo in chiaro. Come fare?

bpqaqabpmtiabbqumqttnismnwzbpmaismwnjmqvoeqbpgwc

Esercizio 112A

Scrivi una funzione che, ricevuto come parametro un numero intero, restituisce una lista contenente i suoi fattori primi.

La segnatura della funzione deve essere:

def fattori_primi(n: int) -> list[int]

Ecco alcuni esempi di risultato da questa funzione:

fattori_primi(18) = [2, 3, 3]
fattori_primi(17) = [17]
fattori_primi(3496751681) = [27127, 128903]
fattori_primi(128) = [2, 2, 2, 2, 2, 2, 2]
fattori_primi(-88) = [2, 2, 2, 11]
fattori_primi(8616460799) = [89681, 96079]

Esercizio 112B

Nel 1874, il signor William Stanley Jevons scriveva in un suo libro:

Può il lettore dire quali sono i due numeri moltiplicati tra loro che produrranno il numero 8616460799? Penso che sia improbabile che qualcuno ci riesca, a parte me stesso.

La tua funzione fattori, precedentemente implementata, riesce a trovare i fattori primi di 8616460799?

Se la risposta è no, prova a migliorarla, in modo tale che riesca a trovare tali fattori.

Esercizio 112C

Scrivi una funzione che, ricevuto come parametro un numero intero, restituisce i suoi fattori primi, senza che essi siano ripetuti.

La segnatura della funzione deve essere:

def fattori_primi_unici(n: int) -> list[int]

Sfrutta la funzione fattori_primi, implementata in precedenza.

Ecco alcuni esempi di risultato da questa funzione:

fattori_primi_unici(8616460799) = [89681, 96079]
fattori_primi_unici(18) = [2, 3]
fattori_primi_unici(17) = [17]
fattori_primi_unici(3496751681) = [128903, 27127]
fattori_primi_unici(128) = [2]
fattori_primi_unici(-88) = [2, 11]

Esercizio 112D

Scrivi una funzione che, ricevuto come parametro un numero intero, restituisce i suoi fattori primi, ciascuno con la propria frequenza.

La segnatura della funzione deve essere:

def fattori_primi_freq(n: int) -> dict[int, int]

Sfrutta la funzione fattori_primi, implementata in precedenza.

Ecco alcuni esempi di risultato da questa funzione:

fattori_primi_freq(18) = {2: 1, 3: 2}
fattori_primi_freq(17) = {17: 1}
fattori_primi_freq(3496751681) = {128903: 1, 27127: 1}
fattori_primi_freq(128) = {2: 7}
fattori_primi_freq(-88) = {2: 3, 11: 1}

Esercizio 113

Scrivi un funzione che restitusce i numeri perfetti minori di un numero limite, ricevuto come parametro.

Se la funzione riceve come parametro un numero minore di 0, deve interrompersi, sollevando l’eccezione ValueError.

La segnatura della funzione deve essere:

def perfetti_minori_di(limite: int) -> list[int]

Se l’hai già implementata, sfrutta la funzione perfetto dell’Esercizio 64.

Ecco alcuni esempi:

perfetti_minori_di(10) = [0, 6]
perfetti_minori_di(100) = [0, 6, 28]
perfetti_minori_di(1_000) = [0, 6, 28, 496]
perfetti_minori_di(10_000) = [0, 6, 28, 496, 8128]

Esercizio 114

Scrivi una funzione che, ricevuta come parametro una lista di numeri interi, restituisca il prodotto dei numeri, considerati ciascuno una volta sola. Lo zero deve essere escluso dal prodotto.

La segnatura della funzione deve essere:

def prodotto(numeri: list[int]) -> int:

Alcuni esempi:

prodotto([-6, -6, 7, 2, 3, 1, 9, -2, 5, 9]) = 22680
prodotto([10, 7, -3, -5, -6, 6, -7, -7, 8, -6]) = 2116800
prodotto([-8, 8, -5, -3, 0, -10, 10, 4, 9, -3, -9, 3, 9, -4, -5, 2, -10, -1, 9, -3]) = -746496000

Esercizio 115

Scrivi una funzione che, ricevuta come parametro una lista di numeri interi, restituisca il prodotto dei numeri, escludendo i numeri ripetuti. Lo zero deve essere escluso dal prodotto.

La segnatura della funzione deve essere:

def prodotto_non_ripetuti(numeri: list[int]) -> int:

Ecco un esempio:

prodotto_non_ripetuti([10, 0, 6, 10, -10, -9, -7, 4, 6, 5]) = -12600

In questo esempio, -12600 è dato dal prodotto di -10, -9, -7, 4, 5 . Il valore zero è escluso. I valori 10, 6 sono esclusi dal prodotto poiché sono ripetuti.

Esercizio 116

Scrivi una funzione che, ricevuta una lista di nomi, restituisce una lista con tutti i caratteri di tutti i nomi messi in minuscolo.

La segnatura della funzione deve essere:

def minuscolo(nomi: list[str]) -> list[str]:

Esercizio 117

Crea una funzione che, ricevuta come parametro una lista contenente nomi di persona, e una lettera, restituisce un set contenente i nomi che iniziano con quella lettera.

La capitalizzazione della lettera (maiuscolo o minuscolo), così come la capitalizzazione dei nomi, non è rilevante. Puoi rendere tutto minuscolo.

Ogni nome deve essere considerato una volta sola nel conteggio. Nella lista, un nome potrebbe però apparire più volte.

La segnatura della funzione deve essere:

def nomi_con_iniziale(nomi: list[str], iniziale: str) -> set[str]:

Ecco degli esempi:

nomi_con_iniziale(["Leonardo", "Leonardo", "lucia", "gioele", "Luca", "leandro"], "L") = {'leonardo', 'luca', 'leandro', 'lucia'}

Esercizio 118

Crea una funzione che, ricevuta come parametro una lista contenente nomi di persona, e un prefisso, restituisce un set contenente i nomi che iniziano con quel prefisso.

La capitalizzazione del prefisso (maiuscolo o minuscolo), così come la capitalizzazione dei nomi, non è rilevante. Puoi rendere tutto minuscolo.

Ogni nome deve essere considerato una volta sola nel conteggio. Nella lista, un nome potrebbe però apparire più volte.

La segnatura della funzione deve essere:

def nomi_con_prefisso(nomi: list[str], prefisso: str) -> set[str]:

Ecco degli esempi:

nomi_con_prefisso(["Leonardo", "Leonardo", "lucia", "gioele", "Luca", "leandro"], "l") = {'leonardo', 'luca', 'leandro', 'lucia'}
nomi_con_prefisso(["Leonardo", "Leonardo", "lucia", "gioele", "Luca", "leandro"], "LU") = {'luca', 'lucia'}

Esercizio 119

Crea una funzione che, ricevuta come parametro una lista di stringhe, restituisce un dizionario in cui:

Ad esempio, se la lista l fosse ['ciao', 'mamma', 'mela', 'ciao'], la funzione restituirebbe il dizionario: {4: 3, 5: 1}.

La segnatura della funzione deve essere:

def conta(l: list[str]) -> dict[int, int]:

Esercizio 120

Crea una funzione che, ricevuta come parametro una lista di stringhe, restituisce un dizionario in cui:

Ad esempio, se la lista l fosse ['ciao', 'mamma', 'mela', 'ciao'], la funzione restituirebbe il dizionario: {4: {'ciao', 'mela'}, 5: {'mamma'}}.

La segnatura della funzione deve essere:

def raggruppa(l: list[str]) -> dict[int, set[str]]:

Esercizio 121

Crea una funzione che, ricevuto come parametro un dizionario, restituisce un altro dizionario, in cui le chiavi e i valori sono stati invertiti. Se uno stesso valore è associato a più chiavi, a quel valore dovrà essere associato None.

La segnatura della funzione deve essere:

def inverti(d: dict[str, str]) -> dict[str, str | None]:

Ad esempio, dato come parametro questo dizionario:

{'albero': 'tree', 'ciao': 'hi', 'salve': 'hi', 'mamma': 'mum'}

La funzione restituirà quest’altro dizionario:

{'tree': 'albero', 'hi': None, 'mum': 'mamma'}

Esercizio 122

Crea una funzione che, ricevuto come parametro un dizionario e un numero intero L, restituisce True se tutte le chiavi del dizionario sono stringhe di lunghezza L. Altrimenti, restituisce False.

La segnatura della funzione deve essere:

from typing import Any

def goodlength(d: dict[str, Any], L: int) -> bool:

Any è un tipo speciale, per indicare ‘un tipo qualsiasi’. Si usa nei contesti in cui il tipo di un dato non è importante. In questo esercizio, ad esempio, il tipo dei valori del dizionario è completamente ininfluente.

Ecco degli esempi:

goodlength({'a': 1, 'b': 'ciao'}, 1) = True
goodlength({'a': 1, 'b': 'ciao'}, 3) = False
goodlength({'aaa': 1, 'bob': 'ciao'}, 3) = True

Esercizio 123

Crea una funzione che, ricevuto come parametro una stringa, restituisce un dizionario in cui:

Le lettere maiuscole e minuscole, in questo esercizio, sono considerate caratteri distinti.

La segnatura della funzione deve essere:

def frequenza(s: str) -> dict[str, int]:

Ecco degli esempi:

frequenza("Abracadabra") = {'A': 1, 'b': 2, 'r': 2, 'a': 4, 'c': 1, 'd': 1}
frequenza("forzamilan") = {'f': 1, 'o': 1, 'r': 1, 'z': 1, 'a': 2, 'm': 1, 'i': 1, 'l': 1, 'n': 1}
frequenza("N112118119N") = {'N': 2, '1': 6, '2': 1, '8': 1, '9': 1}

Esercizio 124

Scrivi una funzione che, ricevuto come parametro un set, restituisce una lista ordinata di quegli oggetti.

def listify[T](s: set[T]) -> list[T]:

Importante: la sintassi usata qui sopra, con il generico tipo T, è disponibile solo dalla versione 3.13 di Python. Perciò, se appare un errore, controlla di avere installato la versione di Python più recente. Puoi controllare la versione di Python attualmente installata sul tuo computer aprendo una finestra di terminale ed eseguendo il comando python --version. Puoi scaricare la versione più recente di Python dal sito www.python.org.

Approfondimento: T indica un generico tipo di dato. Qualcuno potrebbe pensare di usare quest’altra segnatura di funzione:

def listify(s: set[Any]) -> list[Any]:

MA c’è una grande differenza: la segnatura con T indica che il tipo di dato in ingresso deve essere mantenuto in uscita. Any, al contrario, permetterebbe di cambiare il tipo di dato in uscita, rispetto a quello in ingresso.

Ecco degli esempi:

listify({3, -3, 8}) = [-3, 3, 8]
listify({"m", "i", "l", "an"}) = ['an', 'i', 'l', 'm']

Esercizio 125

Scrivi una funzione che, ricevuto come parametro un dizionario, non restituisce nessun valore, ma mostra in output le chiavi e i valori del dizionario su due colonne affiancate. Ad esempio, dato il dizionario {1: "coca", 10: "cola", "a": True}, l’output sarà questo:

Chiave	Valore
1	coca
10	cola
a	True

La segnatura della funzione deve essere:

from typing import Any

def dictprint(d: dict[Any, Any]) -> None:

Importante: sei sicuro di aver compreso la differenza tra “restituire un valore” e “mostrare un valore in output”? Prova a indicare quali sono le sostanziali differenze tra questi due tipi di funzione.

Esercizio 126A

Scrivi una funzione che, ricevuto come parametro un numero intero lunghezza, restituisce una stringa lunga lunghezza, fatta di caratteri casuali. I caratteri possibili sono:

La segnatura della funzione deve essere:

def randstr(lunghezza: int) -> str:

Ecco degli esempi:

randstr(10) = 'l7MF74aAdz'
randstr(20) = 'Cei(8jM&#Nl8MpfYEkFM'
randstr(1) = 'I'

Esercizio 126B

Prosegui dall’esercizio precedente. Nel __main__, scrivi del codice che, per cinque volte, genera una stringa usando randstr(). La lunghezza di ogni stringa deve essere un numero casuale nell’intervallo [5, 20]. Ecco un esempio:

Lunghezza casuale = 15	s = 3Xv7X=u0&LsP&0S
Lunghezza casuale = 9	s = xXieuOXjo
Lunghezza casuale = 15	s = LemPB$fUq&f6qr0
Lunghezza casuale = 13	s = UAYAzmG=vqySD
Lunghezza casuale = 19	s = 3)(Bm9EDBzNN2WjZl&d

Esercizio 127A

Scrivi una funzione che, ricevuto come parametro una stringa, elimina da essa le cifre decimali.

La segnatura della funzione deve essere:

def nodigits(s: str) -> str:

Ecco degli esempi:

s = w788oj54&bjj$7%OHeP4  nodigits(s) = woj&bjj$%OHeP
s = kq6snF6VsS)BABWaLE    nodigits(s) = kqsnFVsS)BABWaLE
s = )#n?Z1                nodigits(s) = )#n?Z
s = Ji3HHHI               nodigits(s) = JiHHHI
s = cZ?C$Z                nodigits(s) = cZ?C$Z

Esercizio 127B

Per ottenere l’output mostrato nell’esercizio 127A, importa la funzione randstr, implementata nell’esercizio 126A.

Esercizio 128

Scrivi un algoritmo con questa struttura:

a = input()
b = input()
c = input()

print(f"{a = }, {b = }, {c = }")

### Aggiungi le istruzioni qui ####

print(f"{a = }, {b = }, {c = }")

Nello spazio tra i due print, inserisci delle istruzioni che scambiano il valore delle variabili, in modo tale che si ottenga ad esempio questo output:

a = 'marco', b = 'simone', c = 'ziad'
a = 'ziad', b = 'marco', c = 'simone'

Esercizio 129

Implementa una funzione con questa segnatura:

def pairswap(valori: tuple[Any, ...]) -> tuple[Any, ...]:

La funzione, ricevuta come parametro una tupla contenente oggetti di ogni tipo, restituisce un’altra tupla, ottenuta scambiando i valori a due a due. Se la tupla ha lunghezza dispari, l’ultimo valore non cambia di posizione.

Esempi:

v = ('ciao', 'mamma', 29, True, 'nicolò')
pairswap(v) = ('mamma', 'ciao', True, 29, 'nicolò')

v = (1, 2, 3, 'Stella!')
pairswap(v) = (2, 1, 'Stella!', 3)

Esercizio 130

Crea una funzione che, ricevuti come parametri due dizionari con chiavi di tipo str e valori di tipo int, restituisca un nuovo dizionario contenente tutte le chiavi di entrambi. Se una chiave è presente in entrambi i dizionari, i valori devono essere sommati.

La segnatura della funzione deve essere:

def unisci_dizionari(d1: dict[str, int], d2: dict[str, int]) -> dict[str, int]:

Ad esempio, dati come parametri i dizionari:

{'mele': 2, 'pere': 3}
{'pere': 4, 'banane': 1}

La funzione restituirà:

{'mele': 2, 'pere': 7, 'banane': 1}

Esercizio 131

Crea una funzione che, ricevuto come parametro un dizionario e una soglia numerica, restituisca un nuovo dizionario contenente soltanto le coppie chiave:valore in cui il valore è strettamente maggiore della soglia.

La segnatura della funzione deve essere:

def filtra_dizionario(d: dict[str, int], soglia: int) -> dict[str, int]:

Ad esempio, dati come parametri il dizionario e la soglia:

{'a': 5, 'b': 2, 'c': 8}, 4

La funzione restituirà:

{'a': 5, 'c': 8}

Esercizio 132

Crea una funzione che, ricevuta come parametro una lista di parole, restituisca un dizionario che raggruppa le parole in base alla loro iniziale. Ogni chiave sarà quindi una lettera, e il valore corrispondente sarà la lista di tutte le parole che iniziano con quella lettera.

La segnatura della funzione deve essere:

def raggruppa_per_iniziale(parole: list[str]) -> dict[str, list[str]]:

Ad esempio, data come parametro la lista:

['cane', 'casa', 'sole']

La funzione restituirà:

{'c': ['cane', 'casa'], 's': ['sole']}

Esercizio 133

Crea una funzione che, ricevuto come parametro un dizionario con valori interi, restituisca la chiave che ha associato il valore massimo.

La segnatura della funzione deve essere:

def chiave_valore_massimo(d: dict[str, int]) -> str:

Ad esempio, dato come parametro il dizionario:

{'a': 5, 'b': 7, 'c': 3}

La funzione restituirà:

'b'

Esercizio 134

Crea una funzione che, ricevuto come parametro il nome di un file di testo, legga tutte le righe del file e restituisca un insieme (set) di parole uniche trovate nel file. Le parole sono separate da spazi e puoi considerarle già ben formattate (senza punteggiatura).

La segnatura della funzione deve essere:

def parole_uniche(nomefile: str) -> set[str]:

Ad esempio, se il file testo.txt contiene:

ciao mondo ciao sole

la funzione restituirà:

{'ciao', 'mondo', 'sole'}

Esercizio 135

Crea una funzione che, ricevuto come parametro il nome di un file di testo, legga tutte le righe del file e restituisca un dizionario che conta quante volte compare ciascuna parola. Le parole sono separate da spazi.

La segnatura della funzione deve essere:

def conta_parole(nomefile: str) -> dict[str, int]:

Ad esempio, se il file parole.txt contiene:

mare sole mare vento sole sole

la funzione restituirà:

{'mare': 2, 'sole': 3, 'vento': 1}

Esercizio 136

Crea una funzione che, ricevuto come parametro il nome di un file di testo, legga tutte le righe e le trasformi in una lista di tuple. Ogni tupla deve contenere due elementi: il numero della riga (partendo da 1) e il contenuto della riga senza carattere di newline \n.

La segnatura della funzione deve essere:

def righe_con_numero(nomefile: str) -> list[tuple[int, str]]:

Ad esempio, se il file righe.txt contiene:

prima riga
seconda riga
terza riga

la funzione restituirà:

[(1, 'prima riga'), (2, 'seconda riga'), (3, 'terza riga')]

Esercizio 137

Crea una funzione che, ricevuta una lista di numeri, restituisca una tupla contenente il numero più piccolo, il numero più grande e la somma di tutti i numeri.

La segnatura della funzione deve essere:

def min_max_somma(numeri: list[int]) -> tuple[int, int, int]:

Ad esempio, data la lista:

[3, 7, 1, 9, 4]

la funzione restituirà:

(1, 9, 24)

Esercizio 138

Crea una funzione che, ricevuta come parametro una lista di stringhe, restituisca un dizionario in cui le chiavi siano le stringhe e i valori siano il numero di vocali presenti in ciascuna stringa.

La segnatura della funzione deve essere:

def conta_vocali(parole: list[str]) -> dict[str, int]:

Ad esempio, data la lista:

["ciao", "scuola", "mare"]

la funzione restituirà:

{'ciao': 2, 'scuola': 3, 'mare': 2}

Esercizio 139

Crea una funzione che, ricevuto come parametro il nome di un file di testo, legga tutte le righe del file e restituisca una lista di parole presenti nel file, senza duplicati, in ordine alfabetico.

La segnatura della funzione deve essere:

def parole_alfabetico(nomefile: str) -> list[str]:

Ad esempio, se il file testo.txt contiene:

sole mare sole vento

la funzione restituirà:

['mare', 'sole', 'vento']

Esercizio 140

Crea una funzione che, ricevuto come parametro un dizionario in cui le chiavi sono nomi di persone e i valori sono età, restituisca una tupla contenente due elementi:

  1. Il nome della persona più giovane
  2. Il nome della persona più anziana

La segnatura della funzione deve essere:

def estremo_eta(persone: dict[str, int]) -> tuple[str, str]:

Ad esempio, dato il dizionario:

{'Luca': 25, 'Anna': 30, 'Mario': 20}

la funzione restituirà:

('Mario', 'Anna')

Esercizio 141

Un computer di bordo deve decidere se l’astronave può partire. L’astronave ha tre sistemi principali:

Le regole per il decollo sono:

  1. Se il carburante è almeno 70%, la temperatura è inferiore a 100°C e gli scudi sono attivi, la nave può decollare: → "Decollo autorizzato!"
  2. Se il carburante è tra 50% e 69% (estremi inclusi) e gli scudi sono attivi, ma la temperatura è almeno 100°C, mostra: → "Attendere raffreddamento motori"
  3. Se il carburante è inferiore a 50% ma gli scudi sono attivi: → "Carburante insufficiente"
  4. Se gli scudi non sono attivi in nessuno dei casi precedenti: → "Decollo negato: scudi disattivati"
  5. Se uno dei valori inseriti non è valido (carburante < 0 o > 100, temperatura < -50 o > 300, scudi ≠ 0 o 1): → mostra solo "Valori non validi"

Esempi di input/output:

Carburante (%): 80
Temperatura (°C): 90
Scudi attivi (1=si, 0=no): 1

Decollo autorizzato!

Carburante (%): 60
Temperatura (°C): 120
Scudi attivi (1=si, 0=no): 1

Attendere raffreddamento motori

Carburante (%): -5
Temperatura (°C): 90
Scudi attivi (1=si, 0=no): 1

Valori non validi

Esercizio 142

Scrivi un algoritmo che, letto in input un tempo espresso in secondi, lo converte e visualizza in minuti e secondi. Esempio: 125 secondi → 2 minuti e 5 secondi.

Esercizio 143A

Scrivi un algoritmo che chiede all’utente di inserire dei numeri nell’intervallo [0, 10] (estremi inclusi). Appena l’utente inserisce un valore esterno a questo intervallo, l’algoritmo smette di chiedere valori in input. L’algoritmo deve mostrare, per ogni numero in [0, 10], se esso è stato inserito dall’utente, oppure no. Ecco un esempio dell’input/output di questo programma:

Inserisci dei valori nell'intervallo [0, 10]:
2
4
8
23

0? No
1? No
2? Sì
3? No
4? Sì
5? No
6? No
7? No
8? Sì
9? No
10? No

Esercizio 143B

Considera l’esercizio precedente. Ora, per ogni numero in [0, 10] mostra quante volte è stato inserito.

Inserisci dei valori nell'intervallo [0, 10]:
2
4
8
8
23

0? 0
1? 0
2? 1
3? 0
4? 1
5? 0
6? 0
7? 0
8? 2
9? 0
10? 0

Esercizio 144

Scrivi un algoritmo che chiede all’utente di inserire dei numeri interi. L’utente può inserire dei numeri interi qualunque, ma l’algoritmo salva solo i primi 5 numeri pari inseriti. Letti questi 5 numeri pari, la lettura dell’output termina. Di questi numeri, calcola e mostra: il minimo, il massimo, la media, la varianza, la deviazione standard. Un esempio dell’input/output:

Inserisci un numero intero: 3
Inserisci un numero intero: 8
Inserisci un numero intero: 13
Inserisci un numero intero: -22
Inserisci un numero intero: 2
Inserisci un numero intero: 23
Inserisci un numero intero: 23
Inserisci un numero intero: 24
Inserisci un numero intero: 1000

Risultati:
Minimo: -22
Massimo: 1000
Media: 202.40
Varianza: 159259.84
Deviazione standard: 399.07

Esercizio 145

Scrivi un algoritmo che legge in input un solo unico numero positivo n. In output, mostra la frequenza al suo interno delle cifre da 0 a 9.

Tip: per il numero n, usa il tipo long long int.

Tip: anzitutto, costruisci un ciclo che produca le singole cifre del numero.

Esempio:

Inserisci un numero positivo: 29031997

Frequenza delle cifre:
Cifra 0: 1 volte
Cifra 1: 1 volte
Cifra 2: 1 volte
Cifra 3: 1 volte
Cifra 4: 0 volte
Cifra 5: 0 volte
Cifra 6: 0 volte
Cifra 7: 1 volte
Cifra 8: 0 volte
Cifra 9: 3 volte

Esercizio 146

Scrivi un programma che simuli il lancio di un dado a 6 facce.

  1. Inizializza il generatore con srand(time(NULL));
  2. Genera un numero casuale tra 1 e 6.
  3. Ripeti il lancio 10 volte usando un ciclo.
  4. Stampa ogni risultato.

Output di esempio:

Lancio 1: 4
Lancio 2: 1
Lancio 3: 6
...

Esercizio 147

Scrivi un programma che riempia un vettore con numeri casuali.

  1. Crea un vettore di 20 interi.
  2. Inserisci numeri casuali tra 0 e 100.
  3. Stampa tutti i valori.
  4. Calcola e stampa:
    • valore massimo
    • valore minimo
    • media dei valori

Esercizio 148

Simula la generazione di molti numeri casuali e osservane la distribuzione.

  1. Genera 1000 numeri casuali tra 0 e 9.
  2. Conta quante volte compare ciascun numero.
  3. Stampa un istogramma testuale, producendo un asterisco ogni 10 comparse. Output di esempio:
0: ********** (107)
1: ********** (104)
2: *********** (116)
3: *********** (110)
4: ******** (83)
5: ******** (89)
6: ********** (106)
7: ********* (96)
8: ******** (81)
9: ********** (108)

Esercizio 149

Scrivi un programma che:

  1. Generi 15 numeri reali casuali compresi tra 0.0 e 1.0.
  2. Li memorizzi in un vettore di float.
  3. Stampi:
    • Tutti i valori, con tre cifre decimali
    • Quanti valori sono maggiori di 0.5
    • La media dei valori

Esercizio 150

Scrivi un programma che:

  1. Generi casualmente 30 caratteri alfabetici maiuscoli (tra 'A' e 'Z').
  2. Li salvi in un vettore di char.
  3. Stampi:
    • Tutti i caratteri generati
    • Quante vocali sono presenti
    • Quante consonanti sono presenti

Esercizio 151

Scrivi un programma che:

  1. Chieda all’utente una lunghezza L per una password (massimo 20).
  2. Generi una password casuale, di lunghezza L, composta da:
    • Lettere maiuscole
    • Lettere minuscole
    • Numeri

    Salva la password in un vettore di char.

  3. Stampa la password.

👉 Suggerimento: Puoi decidere casualmente che tipo di carattere generare (numero, maiuscola o minuscola) usando rand() % 3.

Esercizio 152

Implementa la seguente funzione:

long int niceo();

La funzione deve ripetere i seguenti passi:

  1. genera una sequenza di cinque caratteri minuscoli casuali e li salva in un vettore di tipo char
  2. se la sequenza generata è {'n', 'i', 'c', 'e', 'o'}, termina restituendo il numero di tentativi effettuati (cioè quante sequenze di 5 caratteri sono state generate)
  3. altrimenti, continua generando una nuova sequenza

Nel main(), usa la funzione niceo() per ottenere un output del tipo:

La sequenza {'n', 'i', 'c', 'e', 'o'} è stata ottenuta dopo 2253722 tentativi!

Suggerimento:

  1. il testo dell’esercizio richiede, in generale, l’implementazione di una funzione. Nello specifico, implementerai una versione ricorsiva della funzione ↩ ↩2 ↩3 ↩4