Costruire un programma che legge una sequenza di numeri interi (terminata con lo zero) e per ogni valore indichi se si tratta di un numero pari o dispari.

/**************************************************************************
 * Nome: lab1-pari_dispari.c                                              *
 * Autore: Alessandro Saetti                                              *
 * Data: 16/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h> // Richiesta da system("pause");
/* Nome: main
 * Scopo: Stampa numeri pari e dispari
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main() 
{
    // DICHIARAZIONE VARIABILI/INIZIALIZZAZIONE
    int n;

    printf(" - DETERMINA SE PARI O DISPARI - \n");
    printf("Inserisci dei numeri interi positivi (0 per terminare):\n");
    do 
    {
        printf("==> ");       
        scanf("%d", &n);
        if (n > 0) 
           if(n % 2 == 0) 
              printf("%d e' pari!\n", n);        
           else
              printf("%d e' dispari!\n", n);
        
    } while(n > 0);

    system("pause");
    return(0);
}

Costruire un programma che legge una sequenza di date (conclusa con la data fittizia 0/0/0) e restituisce la data più vecchia. Non sono richiesti controlli sulla correttezza delle date.

/**************************************************************************
 * Nome: lab2-date.c                                                      *
 * Autore: Alessandro Saetti                                              *
 * Data: 16/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h> // Richiesta da system("pause");
#include <limits.h> // Contiene la definizione di INT_MAX (2^31-1)
/* Nome: main
 * Scopo: Calcola e stampa la data minima
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main() 
{
    // DICHIARAZIONE VARIABILI/INIZIALIZZAZIONE
    int gg, mm, aa, min_aa = INT_MAX, min_mm = 13, min_gg= 32;
    // INPUT
    printf("Immetti la data (g/m/aaaa) (0/0/0 per terminare):\n");
    do {
       printf("-> ");
       scanf("%d/%d/%d", &gg, &mm, &aa);
       if (aa > 0 && mm > 0 && gg > 0) 
       {
          if (aa < min_aa) //  Se l'anno appena letto e' minore del minimo
          {                //  fino a quel punto acquisito
             min_aa = aa;
             min_mm = mm;
             min_gg = gg;
          } 
          else if (aa == min_aa && mm < min_mm) 
          {
             min_mm = mm;
             min_gg = gg;
          }
          else if (aa == min_aa && mm == min_mm && gg < min_gg)
             min_gg = gg;
       }
    } while(gg != 0 || mm != 0 || aa != 0);
    // OUTPUT
    printf("La data minima e': %d/%d/%d\n", min_gg, min_mm, min_aa);
    
    system("pause");
    return(0);
}

Costruire un programma che legge due numeri razionali e mostra a video la frazione somma ridotta ai minimi termini.

/**************************************************************************
 * Nome: lab4-frazioni.c                                                  *
 * Autore: Alessandro Saetti                                              *
 * Data: 16/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h> // Richiesta da system("pause");
/*
 * Nome: main
 * Scopo: Stampa la frazione somma ridotta ai minimi termini
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main() 
{
    int num1, num2, den1, den2; 
    int num, den, min , MCD, i;
    // INPUT
    printf("Digita la prima frazione (A/B): ");
    scanf("%d/%d", &num1, &den1);
    printf("Digita la seconda frazione (C/D): ");
    scanf("%d/%d", &num2, &den2);
    
    // ALGORITMO:
    // 1) Determino la frazione somma non ridotta
    num = num1 * den2 + num2 * den1;
    den = den1 * den2;
    // 2) Calcolo il MASSIMO COMUNE DIVISORE
    //    - il MCD è minore o uguale di num o den
    if (num > den)
       min = den;
    else
       min = num;
    //    - divido num e den per i. Se il resto è zero allora
    //      i è il nuovo MCD. 
    for (i = 1; i <= min ; i++)
        if ( num % i == 0 && den %i == 0) 
           MCD = i;
    // Invece di partire da 1 parto da min. Se num e den non è multiplo di
    // i allora passo a considerare il numero i-1 altrimenti ho determinato
    // il MCD
    // for (MCD=min ; ((num%MCD)+(den%MCD))>0 ; MCD--);

    // OUTPUT
    printf("Frazione Somma (Non ridotta): (A*D+C*B)/B*D = (%d*%d+%d*%d)/(%d*%d) = %d/%d\n",num1, den2, num2, den1, den1, den2, num,den);
    printf("Frazione Somma (Ridotta)    : (A*D+C*B)/B*D = %d/%d = (%d*%d)/(%d*%d) = %d/%d\n",num, den, num/MCD, MCD, den/MCD, MCD, num/MCD, den/MCD);

    system("pause");
    return(0);
}

Costruire un programma che genera N numeri interi compresi tra 1 e 100 e mostra la media di tali valori

/**************************************************************************
 * Nome: lab4-media.c                                                     *
 * Autore: Alessandro Saetti                                              *
 * Data: 23/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h> // Richiesta da system("pause");
#include <time.h>   // Serve per la funzione time()
#define DIM 100
/*
 * Nome: main
 * Scopo: Stampa la media dei numeri in un vettore
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main()
{
    float media;
    int i, vet[DIM], somma;
    // INIZIALIZZAZIONE:
    // - Inizializzo il generatore di numeri casuali
    srand(time(NULL));
    // - genero DIM numeri interi tra 1..100
    for (i=0; i < DIM; i++) 
        vet[i] = (rand() % 100 + 1);

    // ALGORITMO
    somma=0;
    for (i=0; i < DIM; i++) 
        somma += vet[i];
    // Si noti che il risultato che si ottiene scrivendo (float)(somma/n)
    // e' errato!
    media = (float)somma / DIM;

    // OUTPUT
    for (i=0; i < DIM; i++) 
       printf("%4d", vet[i]);
    printf("\n\nMedia: %.2f\n", media);

    system("pause");
    return 0;
}

Costruire un programma che legge un intero positivo minore di 1024 e visualizza lasua rappresentazione in binario

/**************************************************************************
 * Nome: lab2-dectobin.c                                                  *
 * Autore: Alessandro Saetti                                              *
 * Data: 23/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h> // Richiesta da system("pause");
/*
 * Nome: main
 * Scopo: Stampa conversione base 2
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main()
{
    int dec, t, bin[10], i, n = 0;

    // INPUT
    printf("Immetti un intero (positivo minore di 1024):\n");    
    do {
        printf("-> ");
        scanf("%d", &dec);
    } while(dec < 0 || dec > 1023);
    
    // ALGORITMO
    t=dec;
    do {
       bin[n++] = t % 2; // resto divisione per 2
       t = t /2;       // divisione intera
    } while (t != 0);

    printf("Conversione in base 2 di %d: ", dec);
    for (i = n-1; i >=0; i--) 
        printf("%d", bin[i]);
    printf("\n\n");

    system("pause");
    return 0;
}

Costruire un programma che genera N numeri binari e li converte in decimale.

/**************************************************************************
 * Nome: lab4-bintodec.c                                                  *
 * Autore: Alessandro Saetti                                              *
 * Data: 23/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h> // Richiesta da system("pause");
#include <math.h>   // Serve per la funzione powf()
#include <time.h>   // Serve per la funzione time()
#define NrDigit 8
#define NrRighe 5
/*
 * Nome: main
 * Scopo: Stampa conversioni in base 10 di numeri binari su righe di matrice
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
 int main() 
 {
    int Valori[NrRighe][NrDigit], r, c;
    float V[NrRighe]={0.0}; // tutti i valori sono inizializzati a zero

    // INIZIALIZZAZIONE:
    // - Inizializzo il generatore di numeri casuali
    srand(time(NULL));
    // - Genero dei numeri 0 / 1 casuali
    for (r=0; r < NrRighe; r++) 
        for (c=0; c < NrDigit; c++) 
            Valori[r][c]=rand()%2;

    // ALGORITMO: Decodifica da binario a decimale
    for (r=0; r < NrRighe; r++) 
        for (c=0; c < NrDigit; c++) 
            V[r]+=Valori[r][c]*powf(2,NrDigit-1-c);

    // OUTPUT
    printf("CONVERSIONE NUMERI BINARIO/DECIMALE:\n\n");
    for (r=0; r < NrRighe; r++) 
    {
        printf("%d) Il numero binario ", r+1);
        for (c=0; c < NrDigit; c++) 
            printf("%1d",Valori[r][c]);
        printf(" convertito in decimale e': %.0f\n", V[r]);
    }

    system("pause");
    return(0);
}

Costruire un programma che legge un numero positivo e visualizza i prossimi 5 anni bisestili. Nel calendario Gregoriano un anno è bisestile se il suo numero è divisibile per 4, con l'eccezione degli anni secolari (quelli divisibili per 100) che sono bisestili solo se divisibili per 400. Si potrebbe ulteriormente migliorare il calendario gregoriano togliendo tre giorni ogni diecimila anni. A tale riguardo John Herschel (1792-1871) suggerì di non considerare bisestili (mentre, in base al calendario gregoriano, lo dovrebbero essere) gli anni 4000, 8000 e 12000.

/**************************************************************************
 * Nome: casa1-anno.c                                                     *
 * Autore: Alessandro Saetti                                              *
 * Data: 16/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h> // Richiesta da system("pause");
/*
 * Nome: main
 * Scopo: Stampa anni bisestili
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main() {
    int n, i = 1;

    // INPUT
    printf(" - CALCOLO DEGLI ANNI BISESTILI - \n");
    printf("Inserisci un numero intero positivo:\n");
    do {
        printf("==> ");       
        scanf("%d", &n);
    } while(n <= 0);

    // ALGORITMO + OUTPUT
    do {
       n++;
       // Divisibile per 4 ma non per 100 ma non multiplo di 400
       if (n % 4 == 0 && n % 100 != 0 || n % 400 == 0) {
          printf("Il %d^anno bisestile e' %d\n", i, n);
          i++;
       }
    } while(i <= 5);

    system("pause");
    return(0);
}

Richiedi la lunghezza dei 3 lati di un triangolo (quindi numeri reali positivi). Verifica quindi che sia soddisfatta la disuguaglianza triangolare {(Lato + lungo) <= (somma altri 2 lati) } e restituisci il perimetro.

/**************************************************************************
 * Nome: casa2-triangolo.c                                                *
 * Autore: Alessandro Saetti                                              *
 * Data: 16/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h> // Richiesta da system("pause");
/*
 * Nome: main
 * Scopo: Acquisisce la lunghezza dei lati di un triangolo e calcola perimetro 
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main() {
    float l1, l2, l3, somma_altri, max_lato, perimetro;

    // INPUT + Controllo correttezza
    printf(" - CALCOLO DEL PERIMETRO - \n");
    printf("Inserisci la lunghezza dei 3 lati di un triangolo e calcolane il perimetro:\n");
    do 
    {
       // INPUT
       printf("Lato 1: ==> ");       
       scanf("%f",&l1);
       printf("Lato 2: ==> ");       
       scanf("%f",&l2);
       printf("Lato 3: ==> ");       
       scanf("%f",&l3);
       
       // ALGORITMO - Verifico che sia soddisfatta la disuguaglianza triangolare
       // Inizio con il considerare come lato + lungo l1
       max_lato = l1;
       somma_altri = l2+l3;
       if (l2 > max_lato) 
       {
          // se l2 > Lato + lungo ==> l2 è il nuovo lato + lungo
          max_lato = l2;
          somma_altri = l1 + l3;
       }
       if (l3 > max_lato)
       {
          // se l3 > Lato + lungo ==> l3 è il nuovo lato + lungo
          max_lato = l3;
          somma_altri = l1 + l2;
       }
       // Continuo a chiedere fino non ho dei reali positivi ed è soddisfatta
       // la disuguaglianza triangolare 
    } while(l1 <= 0 || l2 <= 0 || l3 <= 0 || somma_altri < max_lato);
    // ALGORITMO: determino il perimetro
    perimetro = l1 + l2 + l3;
    //OUTPUT
    printf("Il perimetro e': %.2f\n", perimetro);

    system("pause");
    return(0);
}

Costruire il programma che chiede inizialmente il numero di valori da leggere. Successivamente legge la sequenza di numeri e al termine ne restituisce la media.

/**************************************************************************
 * Nome: casa3-media.c                                                    *
 * Autore: Alessandro Saetti                                              *
 * Data: 16/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h> // Richiesta da system("pause");
/*
 * Nome: main
 * Scopo: Stampa la media tra n numeri acquisiti da tastiera
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main() 
{
    int i,n,x,somma=0;
    float media;

    // INPUT
    printf(" - CALCOLO DELLA MEDIA - \n");
    // Leggo quanti valori leggere
    printf("Inserisci il numero di valori da leggere:\n");
    do {
        printf("==> ");       
        scanf("%d",&n);
    } while(n < 0);
    // - Leggo gli n valori
    printf("Inserisci %d numeri interi:\n", n);
    for (i=1; i <= n; i++) 
    {
        printf("%d numero: ==> ", i);       
        scanf("%d",&x);
        somma+=x;
    }
    // ALGORITMO - si noti il risultato che si ottiene scrivendo: (float)(somma/n)
    media=(float)somma/n; 
    // OUTPUT
    printf("La media e': %.2f\n",media);

    system("pause");
    return(0);
}

Costruire un programma che visualizza il calendario del mese basandosi su due dati (richiesti all'utente!): - numero di giorni nel mese - giorno della settimana del primo del mese

/**************************************************************************
 * Nome: casa4-calendario.c                                               *
 * Autore: Alessandro Saetti                                              *
 * Data: 16/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h> // Richiesta da system("pause");
/*
 * Nome: main
 * Scopo: Stampa calendario mensile
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main()
{
    int i, n, gg_inizio, num_gg;
    
    // INPUT - Inizializzazione
    n=0;
    printf("Digita:\n- Il numero di giorni nel mese: ");
    scanf("%d", &num_gg);
	printf("- il giorno della settimana con cui inizia il mese\n");
    printf("  (1=>Dom., 2=>Lun., ..., 7=>Sab.): ");
    scanf("%d", &gg_inizio);                     

    // ALGORITMO = OUTPUT 
    printf("\n D\t L\t M\t M\t G\t V\t S\n");
    for (i=1; i < gg_inizio; i++, n++)
        printf("  \t");

    for (i=1; i <= num_gg; i++) 
    {
        printf("%2d\t", i);
        n++;
        if ( (n%7 == 0) && (n!=0))
           printf("\n");    
    }

    printf("\n\n");
    system("pause");
    return(0);
}

Costruire un programma che determini, in una sequenza di valori casuali compresi tra -50 e 50, il più piccolo numero maggiore del minino.

/**************************************************************************
 * Nome: casa1-secondoMin.c                                               *
 * Autore: Alessandro Saetti                                              *
 * Data: 23/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h>  // Richiesta da system("pause");
#include <time.h>    // Richiesta da time();
#define DIM 100
#define LB -50
#define UB 50
/*
 * Nome: main
 * Scopo: Trova il numero nel vettore per il quale esiste un numero piu' piccolo
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main() 
{
    int vet[DIM], i, min, min2;
    // INPUT - INIZIALIZZAZIONE
    // - Inizializzo il generatore di numeri casuali
    srand(time(NULL));
    // - genero DIM numeri interi tra -50 e +50
    for (i=0; i < DIM; i++) 
        vet[i] = rand() % (UB-LB+1) +LB;

    // ALGORITMO
    // Pongo come minimi di default l'upper bound della sequenza ovvero 50
    // bound della sequenza
    min = UB;
    min2 = UB;
    for ( i=0; i < DIM ; i++ ) 
    {
        if (vet[i] < min) 
        {
           // Se il valore analizzato è + piccolo del minimo allora il minimo
           // diventa il 2^ minimo mentre il valore analizzato diviene il nuovo
           // minimo
           min2 = min;
           min = vet[i];
        }
        else if (vet[i] < min2) 
        {
           // Se il valore analizzato è + piccolo del 2° minimo allora 
           // il valore analizzato diviene il nuovo 2^ minimo
           min2 = vet[i];
        }
    }

    // OUTPUT
    for (i=0; i < DIM; i++) 
       printf("%5d", vet[i]);
    printf("\nIl Numero piu' piccolo superiore al minimo (%d) e': %d\n", min, min2);

    system("pause");
    return(0);
}

Costruire un programma che trovi in un elenco di N numeri quello con il maggior numero di divisori.

/**************************************************************************
 * Nome: casa2-maxdivisori.c                                              *
 * Autore: Alessandro Saetti                                              *
 * Data: 23/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h>  // Richiesta da system("pause");
#include <time.h> // Richiesta da time();
#define DIM 20
#define LB 10
#define UB 100
/*
 * Nome: main
 * Scopo: Trova il numero in un vettore con il massimo numero di divisori 
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main() 
{
    int vet[DIM], i, j, n, numdiv, max_div = 0, best;

    // INPUT E INIZIALIZZAZIONE
    // - leggo il valore massimo
    printf("Immetti un intero (> 10 e < 100):\n");    
    do {
       printf(": --> ");
       scanf("%d", &n);
    } while (n <= LB || n>= 100);
    // - Inizializzo il generatore di numeri casuali
    srand(time(NULL));
    // - genero DIM numeri interi tra 10 e 100
    for (i=0; i < DIM; i++) 
        vet[i] = rand() % (n-LB+1) +LB;
    // ALGORITMO
    max_div = 0;
    for (i=0; i max_div) 
        {
           max_div = numdiv;
           best = vet[i];
        }
    }
    // OUTPUT
    for (i=0; i < DIM; i++) 
       printf("%5d", vet[i]);
    printf("\nIl numero con piu' divisori (%d) : %d\n",max_div, best);

    system("pause");
    return(0);
}

Costruire un programma che generi una matrice 4x3 e visualizzi la somma degli elementi su ogni riga e colonna.

/**************************************************************************
 * Nome: casa3-sommaRigheColonne.c                                        *
 * Autore: Alessandro Saetti                                              *
 * Data: 23/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h>  // Richiesta da system("pause");
#include <time.h> // Richiesta da time();
#define NR_RIGHE 4
#define NR_COLONNE 3
#define UB 9
/*
 * Nome: main
 * Scopo: Somma righe e colonne
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main() 
{
    int mat[NR_RIGHE][NR_COLONNE], i, j, somma ;
    // INPUT-INIZIALIZZAZIONE
    // - Inizializzo il generatore di numeri casuali
    srand(time(NULL));
    // - genero i numeri interi della matrice 4x3
    for (i=0; i < NR_RIGHE; i++) 
    {
        for (j=0; j < NR_COLONNE; j++) 
        {
            mat[i][j] = rand() % UB + 1;
            printf("%3d", mat[i][j]);
        }
        printf("\n");
    }
    // ALGORITMO + OUTPUT
    for (i=0; i < NR_RIGHE; i++) 
    {
        somma = 0;
        for (j=0; j < NR_COLONNE; j++)
            somma += mat[i][j];
        printf("\nSomma riga %d: %d", i+1, somma);
    }
    for (i=0; i < NR_COLONNE; i++) 
    {
        // Scrittura in forma compatta
        for (j=0, somma = 0; j < NR_RIGHE; somma += mat[j++][i]);
        printf("\nSomma colonna %d: %d", i+1, somma);
    }
    printf("\n\n");

    system("pause");
    return(0);
}

Costruire un programma che calcoli il prodotto tra una matrice NxM (generata automaticamente) e un vettore M-Dimensionale e mostri il risultato.

/**************************************************************************
 * Nome: casa4-prodottomat.c                                              *
 * Autore: Alessandro Saetti                                              *
 * Data: 23/2/10                                                          *
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h>  // Richiesta da system("pause");
#include <time.h> // Richiesta da time();
#define NR_RIGHE 4
#define NR_COLONNE 5
#define UB 9
/*
 * Nome: main
 * Scopo: Calcola il prodotto tra una matrice ed un vettore
 * Input: --
 * Output: 0 se il programma termina correttamente
 */
int main()
{
    int M[NR_RIGHE][NR_COLONNE], V[NR_COLONNE], i, j, somma ;
    // INPUT-INIZIALIZZAZIONE
    // - Inizializzo il generatore di numeri casuali
    srand(time(NULL));
    // - genero i numeri interi della matrice 4x5
    printf("Matrice %dx%d :\n\n",NR_RIGHE,NR_COLONNE);
    for (i=0; i < NR_RIGHE; i++) 
    {
        for (j=0; j < NR_COLONNE; j++) 
        {
            M[i][j] = rand() % UB + 1;
            printf("%3d", M[i][j]);
        }
        printf("\n");
    }
    // Chiedo il vettore  
    printf("\nInserisci i %d numeri interi relativi al vettore V:\n\n",NR_COLONNE);
    for (i=0 ; i < NR_COLONNE ; i++) 
    {
        do {
            printf("V[%d] --> ",i);
            scanf("%d",&V[i]);
        } while (V[i] <= 0 || V[i] > UB);
    }
    // ALGORITMO+OUTPUT
    printf("\nIl vettore prodotto e':\n\n");
    for(i=0 ; i < NR_RIGHE ;i++) 
    {
        somma = 0;
        for(j=0; j < NR_COLONNE ; j++)                    
           somma += M[i][j] * V[j];
        printf("%4d\n",somma);
    }
    printf("\n");

    system("pause");
    return(0);
}

Soluzione C++

Soluzione JavaScript

Soluzione VBA

Soluzione ASP

Soluzione PHP