DidaWiki

Questa pagina è in sola lettura. Puoi visualizzare il sorgente, ma non puoi modificarlo. Contatta l'amministratore se pensi che ci sia un errore.
====== Esercitazione 3 ======


Oggi dovremo di nuovo usare funzioni sui reali.

Ma il C non ha operatori nativi del linguggio per queste
operazioni, 
come la radice quadrata, l'elevamento a potenza o
l'arrotondamento.

Per effettuare questa operazione si fa ricorso a funzioni della
libreria 
matematica dichiarata con

<code>
 #include <math.h> 
 </code>
che  realizza le funzioni 
matematiche più comuni (assicuratevi di avere l'opzione -lm  al momento della
compilazione come ultima opzione):

<code>
   gcc nome.c -o nome -lm
</code>


Alcune funzioni matematiche utili della libreria <math.h>:
<code>
double floor(double x)  
 </code>
 il più grande intero non maggiore di x (per numeri
maggiori di 0, la parte intera di x)

<code>
double ceil(double x)  
 </code>
il più piccolo intero non minore di x (per numeri
maggiori di 0, 
la parte intera +1 di x)
<code>
double pow(double x, double y) 
 </code> 
 x elevato alla y

<code>
double sqrt(double x)
</code> 
 radice quadrata di x
(vedere http://it.wikipedia.org/wiki/Math.h per ulteriori funzioni
e dettagli)

Gli esercizi di oggi vanno risolti usando solamente costrutti
iterativi.
Per chi sapesse come usare gli array, questi non vanno usati per
risolvere
gli esercizi

Nella propria home directory creare una sotto directory chiamata es03, in cui
metteremo tutti i file C di oggi.

===== Esercizio 1  =====
Scrivere il programma calcolatrice che legge un valore di tipo
double, uno di 
tipo char e poi ancora uno di tipo double. Se il carattere letto è
uno dei quattro 
segni di operazioni aritmetiche (+, -, *, /) il programma esegue
l'operazione 
sui due valori e stampa il risultato.
Altrimenti stampa un messaggio di errore.
Stampare i risultati con al max 2 cifre decimali.


===== Esercizio 2  =====

Nella morra due giocatori si sfidano scegliendo un simbolo
ciascuno tra sasso, forbici e carta: due simboli uguali pareggiano, mentre il sasso
batte le forbici, 
le forbici battono la carta, e la carta batte il sasso.

Scrivere il programma morra che gestisce una sfida tra PC e
utente:
  - generando un numero casuale da 1 a 3 così definiti:
       *1: sasso, 
       *2: forbici, 
       *3: carta (utilizzare il costrutto #define per rendere leggibile l'associazione tra il numero e il simbolo)
  - leggendo un carattere ('s': sasso, 'f': forbici, 'c': carta)
  - stampando l'esito del confronto.

Se l'utente immette un carattere diverso da 's', 'f' e 'c' allora
perde comunque.

===== Esercizio 3  =====
Scrivere un programma che esegue istruzioni for per stampare le
seguenti 
serie di numeri:

  - 1, 2, 3, 4, 5, 6, 7
  - 3, 8, 13, 18, 23
  - 20, 14, 8, 2, -4, -10
  - 19, 27, 35, 43, 51

===== Esercizio 4  =====
Modificare il programma precedente in modo da usare solo
istruzioni while per i cicli

===== Esercizio 5  =====
Scrivere un programma che calcoli e visualizzi la somma degli
interi pari 
da 2 a 1000 (estremi compresi)


===== Esercizio 6  =====
Scrivere un programma che chieda all'utente di inserire una
sequenza di interi 
maggiori di 0 (terminata quando l'utente inserisce uno zero, che
non fa parte 
della sequenza).
Calcolare e stampare la somma e la media dei valori inseriti.

===== Esercizio 7  =====
Scrivere un programma che chieda all'utente di inserire una
sequenza di interi 
maggiori di 0 (terminata quando l'utente inserisce uno zero, che
non fa parte 
della sequenza).
Stampare il minimo e il massimo della sequenza, il numero di occorrenze del minimo e il numero di occorrenze del massimo. 


===== Esercizio 8  =====
Scrivere un programma rettangolo che legge due interi positivi
A e B e 
quindi stampa un rettangolo di dimensioni AxB usando il carattere
'*'. 
Esempio di rettangolo 5*3:

%%*****%%\\
%%*****%%\\
%%*****%%\\

===== Esercizio 9  =====
Scrivere un programma isoscele che chieda all'utente un intero
n e stampi 
un triangolo isoscele di asterischi, di altezza lunga n e base
lunga 2n-1. 
(Se il valore letto è negativo si consideri il suo valore
assoluto).

Esempio di interazione con il programma:
<code>
Inserisci l'altezza: 6

     *   
    ***   
   *****   
  *******
 *********
***********
</code>
Suggerimento: per allineare correttamente le righe, stampare su
ogni riga 
il giusto numero di spazi prima degli asterischi.

===== Esercizio 10  =====
Modificare il programma precedente per stampare un rombo
vuoto.
Nota: accettare solo numeri dispari come altezza.

Esempio di interazione con il programma:
<code>
Inserisci l'altezza (dispari): 8
Inserisci l'altezza (dispari): 9
     *
    * *
   *   *
  *     *
 *       *
  *     *
   *   *
    * *
     *
</code>

===== Esercizio 11  =====

Modificare il programma 9 per stampare un triangolo isoscele
di altezza 
lunga n (con n compreso tra 0 e 9 ) e base lunga 2n-1 fatto come
sotto.

Se il valore letto è non è compreso tra 0 e 9 si chieda all'utente
un nuovo 
valore finché l'intero immesso non appartenga all'intervallo
richiesto.

Esempio di interazione con il programma:
<code>
Dammi un numero intero positivo compreso tra 0 e 9: -2
Dammi un numero intero positivo compreso tra 0 e 9: 5
   
    1
   212
  32123
 4321234
543212345
</code>

===== Esercizio 12  =====
Un triangolo rettangolo puo' avere tutti i lati di lunghezza
intera.

Un insieme di tre valori interi per i lati di un triangolo
rettangolo e' 
chiamato Tripletta Pitagorica. Questi tre lati devono soddisfare
la condizione che 
la somma del quadrato di due dei lati deve essere uguale al
quadrato del terzo.

Scrivere un programma che trovi e stampi tutte le triplette
pitagoriche in cui tutti 
e tre i lati sono minori di 500.

Suggerimento: usare tre for annidati ed eseguire la ricerca in
modo esaustivo, cioe' 
coprendo tutte le possibili triple.

===== Esercizio 13  =====
Modificare il programma bisestile dato la volta scorsa in modo
che continui 
a leggere valori finchè l'utente immette anni non bisestili e che
si fermi 
quando l'utente immette un anno bisestile.

Esempio di interazione con il programma:
<code>
Dammi un anno (un intero): 1997
1997 non e' bisestile!
Dammi un anno (un intero): 1900
1900 non e' bisestile!
Dammi un anno (un intero): 1992
Finalmente un anno bisestile!
</code>

===== Esercizio 14  =====
La media pesata dei voti di uno studente si calcola
moltiplicando ogni voto 
per il suo peso in crediti, sommando tutti questi valori e
dividendo per la 
somma del numero di crediti.

Quindi uno studente con due esami, fisica 1 (voto: 24, crediti:15)
e informatica 
(voto: 28, crediti:6), avra' una media pesata circa uguale a 
(24*15 + 28*6)/(15+6) = 25,14.

Scrivere il programma calcola_la_media che chiede ad uno studente
i voti degli 
esami e il loro peso in crediti, uno per volta.

Lo studente dovrà inserire 0 per segnalare che ha terminato
l'inserimento. 

Il programma quindi calcola e stampa la sua media pesata sui
crediti.

Nota: si tenga conto che la votazione del singolo esame e il
numero di crediti 
sono interi. 
Inoltre sono votazioni valide per il superamento di un esame solo
quelle comprese 
tra 18 e 30 (estremi inclusi) e il numero di crediti di un esame
deve essere 
maggiore di 0.

===== Esercizio 15  =====
Modificare il programma precedente per chiedere il numero di
crediti 
del prossimo esame che lo studente deve sostenere. 

Il programma quindi calcola quale voto lo studente dovrebbe
prendere perchè 
la media migliori raggiungendo la votazione (intera)
immediatamente superiore 
alla media attuale. 

Se tale voto fosse maggiore di 30, il
programma deve 
stampare il messaggio "Mi dispiace, non si puo'".

===== Esercizio 16  =====
Esercizio proposto a lezione: 
"Algoritmo di Euclide con i resti per il calcolo del MCD". 
La descrizione informale dell'algoritmo è:
<code>
  leggi m ed n
while m ed n sono entrambi != 0 {
  sostituisci il maggiore tra m ed n con il resto della divisione
del maggiore
        per il minore
}
stampa il numero tra i due che e' diverso da 0
</code>
Implementare questo algoritmo in C nel programma euclide.


===== Esercizio 17  =====
 Scrivere un programma alfabeto che chiede all'utente una
sequenza di caratteri 
alfabetici minuscoli verificando che ogni carattere letto sia
maggiore o uguale 
ai precedenti (secondo l'ordine alfabetico).
 
Il primo carattere inserito può essere un qualsiasi carattere
minuscolo.

La sequenza termina quando l'utente immette un carattere non
alfabetico o maiuscolo 
oppure se immette un carattere minore di uno di quelli letti
precedentemente.

Terminata la lettura dei caratteri il programma deve stampare il
numero di 
caratteri minuscoli diversi appartenenti alla sequenza (il
carattere che causa la 
terminazione non è considerato parte della sequenza).

Se la sequenza è vuota, cioè non viene immesso alcun carattere
minuscolo, allora 
il programma stampa solo un avvertimento.

Esempi di esecuzione:
<code>
Dammi un carattere: X
La sequenza di lettere minuscole e' vuota
</code>
<code>
Dammi un carattere: a
Dammi un carattere: r
Dammi un carattere: r
Dammi un carattere: f
Totale lettere minuscole ordinate e diverse: 2
</code>
<code>
Dammi un carattere: a
Dammi un carattere: a
Dammi un carattere: a
Dammi un carattere: d
Dammi un carattere: z
Dammi un carattere: 4
Totale lettere minuscole ordinate e diverse: 3
</code>

===== Esercizio 18  =====
Scrivere un programma rappresentazione che legge una sequenza
di 0 e di 1 
di dimensione prefissata K e stampa il numero intero la cui
rappresentazione 
in complemento a 2 su K cifre è la sequenza letta.

Esempio di esecuzione :
<code>
Digitare una sequenza di 0 e 1 lunga 5:
0 1 1 1 0
Il numero intero e': 14
</code>
Nota: il programma deve definire K con un'istruzione define e deve
poter funzionare 
anche con valori diversi da 5 semplicemente cambiando questa
define.

===== Esercizio 19  =====
Esercizio proposto a lezione:
scrivi un programma che stampa la tavola pitagorica (come matrice
quadrata, 
con righe da 1 a 10 e colonne da 1 a 10).

Sulle slide dell'ultima lezione c'è una possibile soluzione, chi
non se la 
ricorda provi a ricostruirla.

Riuscite a stampare la tavola correttamente spaziata?

(Suggerimento: guardate i dettagli del formato di printf).

Usate la barra verticale | per separare ogni colonna dalla
successiva
e sequenze di segni meno - per separare ogni riga dalla
successiva.

A lezione è stata proposta una soluzione con due cicli for
annidati. 

Riuscite a scrivere il programma con un unico ciclo for? 
Ne vale la pena? Quali sono gli svantaggi di quest'ultima
soluzione?