Obiettivo: Imparare ad utilizzare i servomotori del Kit EV3 Mindstorm al fine di eseguire traiettorie curve. 

Teoria:

I contenuti teorici riportati in questa lezione sono relativi al robot Driving Base EV3. Questo robot è costituito da due servomotori, che permettono di controllare le due ruote, ed una ruota a sfera.

I servomotori presenti nel kit EV3 Minstrom presentano le seguenti caratteristiche:

• Contagiri con precisione di un grado
• 160/170 giri al minuto
• Coppia motrice 20 N/cm 
• Coppia massima 40 N/cm

La modalità di connessione è rapida, è sufficiente connettere i servomotori attraverso l’utilizzo dei cavi al mattoncini EV3 utilizzando le porte di uscita (A, B, C, D). Attraverso la programmazione del mattoncini sarà possibile selezionare la porta impiegata e programmare in modo corretto il servomotore regolando velocità di rotazione e tempo di accensione.

Regolando la velocità di rotazione dei entrambi i servomotori è possibile impostare 3 differenti modalità di curva:

• Pivot Turn: una ruota ferma ed una ruota in movimento. In questo caso il robot gira intorno alla ruota ferma, la quale funge da perno. La velocità di rotazione dipende dalla ruota in movimento.
• Smooth Turn: le ruote si muovono entrambe nella stessa direzione ma a velocità differente. In questo caso il robot tende a curvare nella direzione della ruota che si muove più lentamente.
• Spin Turn: le due ruote si muovo alla stessa velocità ma in direzioni differenti. In questo caso il robot ruota su se stesso. La velocità di rotazione dipende dalla velocità delle due ruote.

Codice:

Viene in seguito riportato il codice (schema a blocchi) utilizzato per effettuare le tre differenti tipologie di rotazione.

E’ importante considerare che attraverso il programma è possibile regolare la velocità di rotazione di ogni singola ruota ed il tempo di rotazione espresso in: secondi, rotazioni, gradi.

Si potrebbe pensare che attraverso il codice sia possibile definire immediatamente la tipologia di curva desiderata (ad esempio una curva a gomito a 90 gradi), d’altro canto questo non è possibile poiché lo stesso tempo e la stessa velocità di rotazione posso avere effetti differenti su robot differenti.

• Pivot Turn: il programma si avvia quando viene premuto il tasto centrale sul robot. Le ruote effettuano una sola rotazione. Il motore della ruota A è impostato ad una velocità pari al 50% mentre la velocità della ruota B è impostata allo 0%.
• Smooth Turn: il programma si avvia quando viene premuto il tasto sinistro sul robot. Le ruote effettuano una sola rotazione. Il motore della ruota A è impostato ad una velocità pari al 80% mentre la velocità della ruota B è impostata allo 20%.
• Spin Turn: il programma si avvia quando viene premuto il tasto sinistro sul robot. Le ruote effettuano una sola rotazione. Il motore della ruota A è impostato ad una velocità pari al 50% mentre la velocità della ruota B è impostata a -50%.

Obiettivo: Realizzare il gioco della tombola utilizzando il linguaggio di programmazione Java. Un progetto realizzato dagli alunni della classe terza del Istituto Tecnico Commerciale di Fano, Zaninati Luca, Cesarotti Valentina, Cuccaroni Edoardo, Bartoli Luca con la supervisione del Prof. Emanuele Tonucci

Teoria:

Il gioco della tombola è un tradizionale gioco da tavolo inventato a Napoli nel XVIII secolo come alternativa casalinga al gioco del lotto. Uno degli elementi caratterizzanti di questo gioco è il sistema di associazione tra numeri e significati di solito umoristici.
Elemento caratteristico del gioco è la casualità: un giocatore con il ruolo di croupier ha a disposizione un tabellone sul quale sono riportati i numeri da 1 a 90. Il croupier estrae i pezzi in modo casuale ed annuncia agli altri giocatori il numero uscito. L’annuncio termina generalmente con la citazione di una delle immagini che la trazione napoletana associa ai numeri da 1 a 90. I giocatori dispongono invece di una o più cartelle, ogni volta che il numero estratto è presente sulla scheda del giocatore questo copre la casella corrispondente. Vince il giocatore che per primo copre tutti e quindici i numeri presenti sulla scheda.

Scopo di questa lezione è implementare in codice Java il gioco della tombola, nello specifico il programma permetterà la gestione randomica dei numeri estratti, attività solitamente affidata al croupier.

Il codice:

Viene in seguito riportato il codice utilizzato per l’estrazione automatica dei 90 numeri.
Elemento caratterizzante della tombola è la personalizzazione della smorfia in dialetto Fanese.
Per gestire questi due elementi il tabellone e il testo associato ad ogni numero sono utilizzati due differenti array tombola e frasi con dimensione pari a 90.
Dopo la dichiarazione e relativa inizializzazione dell’array delle frasi, l’array tombola viene riempito con numeri casuali (da 1 a 90) utilizzando la classe rand del linguaggio di programmazione Java.
E’ importante considerare che l’array tombola non può contenere due volte lo stesso numero, per questo è stato implementato uno specifico meccanismo di controllo

Codice Eseguibile:

https://onlinegdb.com/b21Kj50g6

Obiettivo: Realizzare un programma che implementi un gioco di calcio (nello specifico calci di rigore) utilizzando il linguaggio di programmazione C++.

I Calciatori

Vengono in seguito riportate una serie di Carte di alcuni giocatori dalle quali si può prendere spunto per la realizzazione del gioco. Ogni carta è caratterizzata da una serie di attributi (differenti per portieri e giocatori) che saranno definiti nel codice attraverso le strutture Calciatore e Portiere.
Nello specifico, gli attributi dei portieri sono:

• string nome;
• string ruolo;
• int tuffo;
• int presa;
• int rinvio;
• int riflessi;
• int reattivita;
• int piazzamento;

Differentemente, gli attributi dei Calciatori sono:

• string nome;
• string ruolo;
• int velocita;
• int tiro;
• int passaggio;
• int dribbling;
• int difesa;
• int fisico;

Il codice

Viene in seguito illustrato il codice utilizzato per implementare un gioco di combattimento tra Pokemon.
Il programma simula un gioco di combattimento tra due allenatori di Pokémon, ognuno con un mazzo di 3 Pokémon. Ogni Pokémon ha un nome, un tipo, dei punti vita, un attacco e una debolezza. Il codice gestisce la creazione di mazzi di Pokémon, l’inizializzazione delle proprietà di ogni Pokémon, e la simulazione di combattimenti tra i Pokémon di due allenatori.

Struttura del codice

1. Inclusioni e dichiarazioni globali:

   • La struttura Portiere definisce le caratteristiche dei portieri.
   • La struttura Calciatore definisce le caratteristiche dei calciatori.
   • La struttura Squadra è costituita dal nome della squadra da un portiere e da due giocatori.

2. Variabili locali:

   • Vengono dichiarati differenti oggetti di tipo Portiere e Calciatore (uno per ogni giocatore: Courtois, Martinez, Donnarumma, Messi, DiMaria, Barella, Immobile.

3. Funzioni:

   • inizializzaMessi(Calciatore &c): inizializza un oggetto di tipo calciatore con i valori specifici di Messi.
   • inizializzaDonnarumma(Portiere &p): inizializza un oggetto di tipo calciatore con i valori specifici di Donnarumma.
   • intro(): stampa un messaggio di benvenuto.

   • rigore(Calciatore calciatore, Portiere portiere, int indice)): Simula un calcio di rigore. La funzione dovrebbe restituire 1 se il calciatore segna e 0 se il portiere para.
   • sfida(Squadra team1, Squadra team2, int numRigori): simula una partita ai calci di rigore Questa funzione, richiama la funzione rigore per ciascun rigore tirato.

4. Funzione main():

   • Definisce le squadre.
   • Vengono inizializzati i calciatori ed i portieri.
   • La funzione intro() stampa un messaggio di benvenuto.

   • Viene eseguita la funzione sfida.

Modifiche:

Al fine di rendere il gioco più avvincente è possibile introdurre una serie di modifiche:

• Elementi di Randomicità nel calcio di rigore
  – Ogni tiro dovrebbe essere caratterizzato da un elemento di randomicità.

Obiettivo: Realizzare un programma che implementi un gioco di combattimento tra Pokemon utilizzando il linguaggio di programmazione C++.

I Pokemon

Vengono in seguito riportate una serie di Carte Pokemon dalle quali si può prendere spunto per la realizzazione del gioco. Ogni carta è caratterizzata da una serie di attributi che saranno definiti nel codice attraverso la struttura pokemon. Questi attributi sono: nome, tipo, puntiVita, nomeAttacco, danniAttacco, debolezza.

Il codice

Viene in seguito illustrato il codice utilizzato per implementare un gioco di combattimento tra Pokemon.
Il programma simula un gioco di combattimento tra due allenatori di Pokémon, ognuno con un mazzo di 3 Pokémon. Ogni Pokémon ha un nome, un tipo, dei punti vita, un attacco e una debolezza. Il codice gestisce la creazione di mazzi di Pokémon, l’inizializzazione delle proprietà di ogni Pokémon, e la simulazione di combattimenti tra i Pokémon di due allenatori.

Struttura del codice

1. Inclusioni e dichiarazioni globali:

   • La struttura pokemon definisce un Pokémon con:
     – nome: nome del Pokémon (es. Pikachu, Charmander).
     – tipo: tipo del Pokémon (es. “fuoco”, “acqua”).
     – puntiVita: salute del Pokémon.
     – nomeAttacco: nome dell’attacco del Pokémon.
     – danniAttacco: danno dell’attacco.
     – debolezza: tipo di attacco che danneggia maggiormente il Pokémon.

2. Variabili globali:

   • Vengono dichiarati sei oggetti di tipo pokemon (uno per ogni Pokémon di gioco: Pikachu, Charmander, Pidgey, Squirtle, Vulpix, Bulbasaur).
   • Vengono dichiarate delle costanti di tipo stringa per rappresentare i tipi di Pokémon: elettro, fuoco, acqua, ghiaccio, lotta.

3. Funzioni:

   • inizializzaPikachu(pokemon &p): inizializza un oggetto di tipo pokemon con i valori specifici di Pikachu.
   • inizializzaCharmander(pokemon &p): inizializza un oggetto di tipo pokemon con i valori specifici di Charmander.
   • intro(): stampa un messaggio di benvenuto. La funzione è vuota e non implementata.
   • creazioneMazzi(pokemon mazzo1[], pokemon mazzo2[], int numPokemon): crea due mazzi con i Pokémon specificati. Ogni mazzo contiene 3 Pokémon.
   • combattimento(pokemon &p1, pokemon &p2): gestisce un combattimento tra due Pokémon. La funzione non è ancora implementata in modo completo, ma stampa un messaggio indicando i Pokémon che stanno combattendo. La funzione dovrebbe restituire 1 se il primo Pokémon vince e 2 se il secondo Pokémon vince.
   • combattimentoMazzi(pokemon mazzo1[], pokemon mazzo2[], int numPokemon): simula un combattimento tra i mazzi dei due allenatori. Chiama la funzione combattimento per ciascun Pokémon dei due mazzi. La funzione dovrebbe restituire 1 se il giocatore 1 vince più sfide e 2 se il giocatore 2 vince più sfide.

4. Funzione main():

   • Definisce i nomi degli allenatori e il numero di Pokémon in ciascun mazzo (3 per ciascun giocatore).
   • Viene inizializzato Pikachu e Charmander tramite le funzioni inizializzaPikachu e inizializzaCharmander.
   • La funzione intro() stampa un messaggio di benvenuto (anche se non implementata).
   • I mazzi dei due giocatori vengono creati dalla funzione creazioneMazzi.
   • Viene avviato un ciclo per eseguire un numero definito di sfide (3 in questo caso). Ad ogni sfida, si simula un combattimento tra i Pokémon nei mazzi.

Modifiche:

Al fine di rendere il gioco più avvincente è possibile introdurre una serie di modifiche:

• Elementi di Randomicità Probabilità di Colpo Critico:
  – Ogni attacco potrebbe avere una probabilità di infliggere danni doppi o tripli, per simulare i colpi critici. – Mossa Speciale Casuale: I Pokémon potrebbero avere un’abilità speciale che si attiva in modo casuale (per esempio, un attacco che colpisce 2 volte di seguito).
• Aggiungere Altri Pokémon: I giocatori potrebbero scegliere tra una lista di Pokémon più ampia, con caratteristiche diverse (punteggi vita, tipo di attacco, ecc.).
• Tipi di Attacco e Interazioni con i Tipi: Ogni Pokémon potrebbe avere una lista di attacchi con effetti diversi, e gli attacchi potrebbero essere influenzati dal tipo del Pokémon avversario. Ad esempio: Fuoco è efficace contro Erba. Acqua è efficace contro Fuoco. Elettrico è efficace contro Acqua. Potrebbero implementare la logica che, in base al tipo di attacco e al tipo di Pokémon, i danni subiti o inflitti cambiano.
• Punti Esperienza e Livelli Punti Esperienza (XP): Ogni volta che un Pokémon vince una battaglia, guadagna dei punti esperienza che lo fanno salire di livello, aumentando così i suoi punti vita o danni.
• Evoluzione: I Pokémon potrebbero evolversi quando raggiungono un certo livello, aumentando le loro statistiche (esempio: Pikachu evolve in Raichu).
• Intelligenza Artificiale: Implementare un’IA per il secondo giocatore.
• Modalità Storia: I giocatori potrebbero affrontare una serie di battaglie contro allenatori (che potrebbero avere Pokémon diversi) fino a raggiungere il “campione” finale.

Obiettivo: Realizzare un programma che implementi una Slot Machine utilizzando il linguaggio di programmazione C++.

Il codice

Viene in seguito illustrato il codice utilizzato per implementare una semplice versione di una Slot Machine. Nel dettaglio, il codice prevede una netta distinzione tra il motore grafico che permette di stampare la griglia del gioco ed il codice di gestione del gioco (i.e., gestione dei soldi, controllo delle vincite, etc…).

• Motore Grafico: La funzione void grafica(char s[]) ha il ruolo di stampare la griglia di gioco definita nell’array di caratteri t che contiene le informazioni relative alle celle del tabellone e aggiorna la console con il contenuto di ogni cella, disegnando una griglia di gioco.

• Codice di gestione del gioco: La dinamica del gioco viene sviluppata all’interno della funzione main. Nel dettaglio l’intero gioco viene implementato attraverso un ciclo while indefinito che prevede la condizione (soldi>0). In questo caso il giocatore continuerà a giocare fino a che avrà soldi a disposizione. Ogni volta che il giocatore preme invio per giocare, vengono rispettivamente: decrementi i soldi, generati nuovi valori nella griglia della slot, stampata la grafica, e controllate eventuali vincite.
  Sono inoltre definite una serie di funzioni, alcune già implementate ed altre invece da implementare al fine di terminare il gioco.
• Costanti e Definizione dei colori: Utilizza macro per definire alcuni colori (rosso, verde, giallo, blu) per il testo in console e applicarli tramite escape codes. La macro NUMCELLE definisce la dimensione del tabellone (3×3 = 9 celle).
• Funzione mySleep(int seconds): Definisce una versione personalizzata della funzione sleep, compatibile con l’ambiente di esecuzione online di OnlineGDB, per ritardare l’output di un certo numero di secondi. In aggiunta, std::cout.flush() forza l’output immediato del buffer di stampa.
• Funzione intro(): Visualizza un messaggio: Best Slot Machine Ever usando colori diversi per ogni parola (“Best”, “Slot”, “Machine”, “Ever”) con una pausa tra ognuna. Chiede poi all’utente di premere Invio per proseguire.
• Funzione regole(): È una funzione vuota che può essere riempita per mostrare le regole del gioco. Al momento, non ha alcuna implementazione.
• Funzione generazioneSlot(int slot[]): genera il contenuto della slot machine riempiendo ogni cella con un numero casuale compreso tra 0 e 2. Ogni numero rappresenta un simbolo differente.
  Funzione conversioneSlot(int slot[], char slotCaratteri[]): converte i valori interi generati in generazioneSlot in caratteri. I valori rappresentano i simboli:
• Funzione controlloVittoria(char s[], int &soldi): verifica se c’è una combinazione vincente nella slot machine

https://onlinegdb.com/cDD7cRgAy

Modifiche:

Al fine di rendere il gioco più avvincente è possibile introdurre una serie di modifiche:

• Completare le funzioni di riferimento per terminare il gioco.
  Design più Creativo per il Tabellone: Offrire temi personalizzati per il tabellone e simboli differenti.

Obiettivo: Realizzare un programma che implementi il gioco del TRIS utilizzando il linguaggio di programmazione C++.

Il codice

Viene in seguito illustrato il codice utilizzato per implementare una semplice versione del gioco del TRIS. Nel dettaglio, il codice prevede una netta distinzione tra il motore grafico che permette di stampare la griglia del gioco ed il codice di gestione del gioco (i.e., scelta della posizione, controllo del vincitore etc…).

• Motore Grafico: La funzione void grafica(char t[]) ha il ruolo di stampare la griglia di gioco definita nell’array di caratteri t che contiene le informazioni relative alle celle del tabellone e aggiorna la console con il contenuto di ogni cella, disegnando una griglia di gioco.

• Codice di gestione del gioco: La dinamica del gioco viene sviluppata all’interno della funzione main. Nel dettaglio l’intero gioco viene implementato attraverso un ciclo while indefinito che prevede l’impiego di due condizioni ((vittoriaG1==0) && (vittoriaG2==0)). In questo caso i giocatori continueranno a giocare fino a che uno dei due non vince e la variabile di riferimento è impostata uguale ad 1. Ogni volta che un giocatore sceglie la posizione all’interno della griglia, viene aggiornata la GUI attraverso la funzione, precedentemente illustrata, grafica(tabellone).
  Sono inoltre definite una serie di funzioni, alcune già implementate ed altre invece da implementare al fine di terminare il gioco.
• Costanti e Definizione dei colori: Utilizza macro per definire alcuni colori (rosso, verde, giallo, blu) per il testo in console e applicarli tramite escape codes. La macro NUMCELLE definisce la dimensione del tabellone (3×3 = 9 celle).
• Funzione mySleep(int seconds): Definisce una versione personalizzata della funzione sleep, compatibile con l’ambiente di esecuzione online di OnlineGDB, per ritardare l’output di un certo numero di secondi. In aggiunta, std::cout.flush() forza l’output immediato del buffer di stampa.
• Funzione intro(): Visualizza un messaggio di benvenuto al gioco del tris usando colori diversi per ogni parola (“Il”, “Gioco”, “del”, “Tris”) con una pausa tra ognuna. Chiede poi all’utente di premere Invio per proseguire.
• Funzione regole(): È una funzione vuota che può essere riempita per mostrare le regole del gioco. Al momento, non ha alcuna implementazione.
• Funzione inserimentoPosizione(char tabellone[], char simbolo): Chiede all’utente di inserire una posizione (indice da 0 a 8) dove desidera giocare il proprio simbolo (‘x’ o ‘y’). La funzione aggiorna l’array tabellone on il simbolo alla posizione specificata. È presente un commento per inserire un controllo di validità per evitare inserimenti fuori dai limiti dell’array o su celle già occupate.
• Funzione controlloVittoriaG1(char t[], char mark): Controlla se il giocatore ha vinto. Verifica solo una combinazione di vittoria, cioè se le prime tre celle del tabellone contengono lo stesso simbolo (mark). Ritorna 1 se la condizione è vera e 0 altrimenti. Questa funzione è molto semplice e non verifica tutte le combinazioni vincenti (orizzontali, verticali, diagonali), quindi necessita di ampliamento.

https://onlinegdb.com/4tpuwLrc3

Modifiche:

Al fine di rendere il gioco più avvincente è possibile introdurre una serie di modifiche:

• Completare le funzioni di riferimento per terminare il gioco.
  Design più Creativo per il Tabellone: Offrire temi personalizzati per il tabellone e per i simboli (X e O) che i giocatori possono scegliere, creando un’esperienza più personalizzata.
• Implementare una intelligenza artificiale come avversario, così i giocatori possono competere anche da soli (introdurre differenti livelli di difficoltà, facile medio e difficile).
• Implementare un sistema di punteggio e statistiche che memorizzi il numero di vittorie, sconfitte e pareggi in una sessione.
• Tabellone alternativo: realizzare un tabellone alternativo 4×4 del tris.

Obiettivo: Realizzare un programma che implementi il gioco dell’oca utilizzando il linguaggio di programmazione C++.

Il codice

Viene in seguito illustrato il codice utilizzato per implementare una semplice versione del gioco dell’oca. Nel dettaglio, il codice prevede una netta distinzione tra il motore grafico che permette di stampare la griglia date le posizioni dei due giocatori ed il codice di gestione del gioco (i.e., lancio dei dadi aggiornamento della posizione, etc…).

• Motore Grafico: La funzione void grafica(int pos1, int pos2) ha il ruolo di stampare la griglia di gioco date le posizioni pos1 e pos2 dei due differenti giocatori. Nel dettaglio viene stampata una griglia con 17 caselle su ognuna delle quali viene riportato un numero da 00 a 16. L’impiego delle variabili relative alle posizioni degli utenti sono utili per stampare sulla specifica posizione del giocatore gli indicatori “XX” e “YY”. Ogni volta che il giocatore cambia posizione attraverso questa funzione viene effettuato un refresh della pagina.

• Codice di gestione del gioco: La dinamica del gioco viene sviluppata all’interno della funzione main. Nel dettaglio l’intero gioco viene implementato attraverso un ciclo while indefinito che prevede l’impiego di due condizioni (pos1<NUMPOS) && (pos2<NUMPOS). In questo caso i giocatori continueranno a lanciare dadi fino a che un giocatore non supera la posizione definita dalla DEFINE NUMPOS. Ogni volta che viene lanciato un dado viene aggiornata la GUI attraverso la funzione, precedentemente illustrata, grafica(pos1, pos2).

Modifiche:

Al fine di rendere il gioco più avvincente è possibile introdurre una serie di modifiche:

• Caselle speciali: per avanzare, indietreggiare, o saltare dei turni
• Ponti: per passare da una casella ad un’altra.
• Gestione dei dadi: si può prevedere un secondo lancio quando si ottiene un sei.

Obiettivo: Realizzare un programma per creare immagini utilizzando le matrici in stile ASCII Art. Attraverso il codice può essere inoltre aggiunto il senso del movimento.

Il codice (statico)

Viene in seguito illustrato il codice utilizzato per stampare su console una forma specifica creata con caratteri. L’esempio specifico rappresenta una barchetta stilizzata.
Inizialmente, questo programma dichiara una matrice 11×11 e la inizializza con spazi vuoti. Successivamente, imposta alcuni caratteri specifici in posizioni specifiche della matrice per creare una forma particolare, e infine, stampa la matrice.

Ecco una descrizione dettagliata del funzionamento del codice:

1. Inclusione delle librerie: Questo programma include le librerie <iostream> e <unistd.h> per la gestione delle operazioni di input/output.
2. Dichiarazione della funzione foo: Questa funzione prende come argomento una matrice bidimensionale di caratteri di dimensione 11×11 e la stampa su console.
3. Main: Il main prevede una inizializzazione della matrice ed una serie di comandi che permettono di impostare alcuni caratteri specifici (come asterischi e trattini) in posizioni specifiche della matrice per creare una forma particolare. Infine la funzione foo(matrix) viene utilizzata per stampare il contenuto della matrice sulla console.

Il codice (dinamico):

In questa versione del codice, viene aggiunto il movimento dell’immagine grazie all’utilizzo delle funzioni usleep e System(“clear”) che rispettivamente bloccano il codice per un numero dato di microsecondi e cancellano il testo sulla console.

Obiettivo: Realizzare un programma per creare i gruppi di lavoro in modo casuale utilizzando il linguaggio di programmazione C++. Il programma prevede di utilizzare una codifica intera per associare ad ogni persona un numero (ad esempio sfruttando l’ordine alfabetico dei cognomi di ogni partecipante). 

Il codice:

Questo programma scritto in C++ è progettato per suddividere un certo numero di alunni in gruppi di dimensioni specifiche e quindi assegnare casualmente ciascun alunno a un gruppo in modo da garantire che ogni gruppo abbia il numero desiderato di alunni.

Ecco una descrizione dettagliata del funzionamento del codice:

1. Vengono dichiarate le variabili numAlunni, numGruppi, numAlunniGruppo, e numAlunniResidui per memorizzare il numero totale di alunni, il numero desiderato di gruppi, il numero di alunni per gruppo e il numero di alunni rimanenti non assegnati a un gruppo.
2. L’utente viene invitato a inserire il numero di alunni della classe e il numero di gruppi desiderati. Ci sono alcune condizioni di controllo che verificano che il numero di gruppi non sia maggiore del numero di alunni e che entrambi i numeri siano positivi. Se queste condizioni non sono soddisfatte, il programma mostra un messaggio di errore e termina.
3. Viene calcolato il numero di alunni per gruppo (numAlunniGruppo) dividendo il numero totale di alunni per il numero di gruppi.
4. Viene calcolato il numero di alunni residui (numAlunniResidui) che non possono essere distribuiti uniformemente tra i gruppi. Questi alunni residui verranno assegnati casualmente ai gruppi successivamente.
5. Viene dichiarato un array numAlunniGruppoVect per tenere traccia del numero di alunni in ciascun gruppo. Inizialmente, ogni gruppo avrà numAlunniGruppo alunni.
6. I alunni residui vengono assegnati casualmente ai gruppi in modo da assicurare che tutti i gruppi abbiano il numero desiderato di alunni. Per fare ciò, viene utilizzato un ciclo while e un array estrattiAlunniVect per tenere traccia degli alunni già assegnati.
7. Viene quindi dichiarato un array ordineAlunniVect per tenere traccia dell’ordine in cui gli alunni sono stati assegnati ai gruppi.
8. Un ciclo while viene utilizzato per assegnare casualmente gli alunni ai gruppi finché non sono stati assegnati tutti gli alunni.
9. Infine, viene stampata la composizione dei gruppi con il numero degli alunni in ciascun gruppo.

In sintesi, questo programma accetta il numero di alunni e il numero di gruppi desiderati, assegna casualmente gli alunni ai gruppi, assicurandosi che ogni gruppo abbia il numero corretto di alunni, e quindi visualizza la composizione dei gruppi.

Codice Eseguibile:

Obiettivo: Sono riportati in seguito una serie di esercizi utili per testare le proprie conoscenze nell’ambito dei linguaggi di programmazione strutturata relativamente all’utilizzo delle strutture.
Gli esercizi, a complessità crescente, possono essere risolti utilizzando anche differenti linguaggi di programmazione come C, Python, Pascal, Java, PHP.

Per la risoluzione degli esercizi si suggerisce l’utilizzo del compilatore online:

https://www.onlinegdb.com/online_c++_compiler

ESERCIZI CON STRUTTURE

1) Realizzare tre differenti strutture per: modellare un rettangolo, un quadrato ed un cerchio. Utilizzare queste strutture per permettere ad un utente di inserire :
– base ed altezza del rettangolo
– lato del quadrato
– raggio del cerchio.
Calcolata l’area delle differenti forme geometriche, il programma deve riportare in seguito quale delle tre è caratterizzata dall’area maggiore.

2) Realizzare un programma che preveda l’utilizzo di una struttura Impiegato. La struttura permette di descrivere un impiegato in base a:
– nome (dato di tipo string)
– cognome (dato di tipo string)
– stipendio base (dato di tipo int)
– anni di servizio (dato di tipo int)
– stipendio totale (dato di tipo int)
Il programma deve:
– Chiedere all’utente di inserire il nome, cognome, stipendio base e anni di servizio dell’impiegato.
– Calcolare lo stipendio totale, aggiungendo un bonus di 100€ per ogni anno di servizio.
– Stampare a schermo tutti i dati dell’impiegato, compreso lo stipendio totale calcolato. (N.B. Lo stipendio totale deve essere assegnato dopo l’inserimento dei dati, sulla base del calcolo effettuato).

3) Realizzare un programma che preveda l’utilizzo di una struttura Auto. La struttura permette di descrivere un automobile in base a:
– marca (dato di tipo string)
– cilindrata (dato di tipo int)
– anno di immatricolazione (dato di tipo int)
– acquirente (dato di tipo string)
Il programma deve prevedere inoltre l’utilizzo di un Array di tipo auto (con dimensioni pari a 5) che consenta di inserire da tastiera i dati delle auto in vendita in un autosalone. (N.B. si utilizzi un ciclo definito per iterare su tutti gli elementi dell’array)

4) Realizzare un programma che preveda l’utilizzo di una struttura Libro. La struttura permette di descrivere un libro in base a:
– titolo (dato di tipo string)
– autore (dato di tipo string)
– anno di pubblicazione (dato di tipo int)
– prezzo (dato di tipo float)
Il programma deve prevedere inoltre l’utilizzo di un array di tipo Libro (con dimensioni pari a 5) che consenta di inserire da tastiera i dati di un archivio di libri. Al termine dell’inserimento, il programma deve: visualizzare l’elenco completo dei libri inseriti individuare e stampare il libro con il prezzo più alto (N.B. si utilizzi un ciclo definito per iterare su tutti gli elementi dell’array).

5) Realizzare un programma che preveda l’utilizzo di una struttura Libro. La struttura permette di descrivere un libro in base a:
– titolo (dato di tipo string)
– autore (dato di tipo string)
– anno di pubblicazione (dato di tipo int)
– prezzo (dato di tipo float)
Il programma deve prevedere inoltre l’utilizzo di un array di tipo Libro (con dimensioni pari a 5) che consenta di gestire un archivio di libri. L’utente deve poter interagire con il programma tramite un menu, scegliendo tra le seguenti opzioni:
1. Inserire un nuovo libro (se ci sono ancora slot disponibili)
2. Ottenere le informazioni di un libro specifico (richiedendo l’indice dell’array)
3. Visualizzare l’elenco completo dei libri inseriti
4. Uscire dal programma
(N.B. si utilizzi un ciclo indefinito per iterare sulle operazioni fino a quando l’utente sceglie di uscire).

6) Realizzare un programma che preveda l’utilizzo di una struttura Studente. La struttura permette di descrivere uno studente in base a:
– nome (dato di tipo string)
– cognome (dato di tipo string)
– eta (dato di tipo int)
– media dei voti (dato di tipo float)
– classe di appartenza (dato di tipo string)
Il programma deve prevedere inoltre l’utilizzo di un array di tipo Studente (con dimensioni pari a 5) che consenta di gestire i dati di una scuola. L’utente deve poter interagire con il programma tramite un menu, scegliendo tra le seguenti opzioni:
1. Inserire un nuovo studente (se ci sono ancora slot disponibili)
2. Ricercare uno studente per nome e cognome e visualizzarne i dettagli
3. Visualizzare l’elenco completo degli studenti
4. Calcolare la media delle medie degli studenti
5. Uscire dal programma
(N.B. si utilizzi un ciclo indefinito per iterare sulle operazioni fino a quando l’utente sceglie di uscire).

7) Realizzare un programma che preveda l’utilizzo di una struttura Studente. La struttura permette di descrivere uno studente in base a:
– nome (dato di tipo string)
– cognome (dato di tipo string)
Il programma deve prevedere inoltre l’utilizzo di un matrice di interi denominata Presenze. Questa matrice ha una dimensione 10×6 e consente di gestire le presenze di 10 alunni dal lunedì al sabato (1 lo studente è presente, 0 lo studente è assente).
Completare il programma sviluppando le seguenti funzioni
1. void inserisciStudenti(Studente elenco[], int n);
2. void registraPresenze(int presenze[][5], int n);
3. void stampaPresenze(Studente elenco[], int presenze[][5], int n);
4. void reportAssenze(Studente elenco[], int presenze[][5], int n);
5. void studentePiuAssenze(Studente elenco[], int presenze[][5], int n);
Esercizi a quiz con le strutture