[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home] [volume] [parte]


Capitolo 586.   Problemi elementari di programmazione

In questo capitolo vengono mostrati alcuni algoritmi elementari portati in C. Per la spiegazione degli algoritmi, se non sono già conosciuti, occorre leggere quanto riportato nel capitolo 543.

586.1   Somma tra due numeri positivi

Il problema della somma tra due numeri positivi, attraverso l'incremento unitario, è descritto nella sezione 543.2.1.

Una copia di questo file dovrebbe essere disponibile presso <allegati/a2/somma.c>.

#include <stdio.h>

int
somma (int x, int y)
{
    int z = x;
    int i;

    for (i = 1; i <= y; i++)
      {
        z++;
      };

    return z;
}

int
main (int argc, char *argv[])
{
    int x;
    int y;
    int z;

    // Converte le stringhe ottenute dalla riga di comando in
    // numeri interi e li assegna alle variabili x e y.

    sscanf (argv[1], "%d", &x);
    sscanf (argv[2], "%d", &y);

    z = somma (x, y);

    printf ("%d + %d = %d\n", x, y, z);

    return 0;
}

In alternativa si può tradurre il ciclo for in un ciclo while.

int
somma (int x, int y)
{
    int z = x;
    int i = 1;

    while (i <= y)
      {
        z++;
        i++;
      };

    return z;
}

586.2   Moltiplicazione di due numeri positivi attraverso la somma

Il problema della moltiplicazione tra due numeri positivi, attraverso la somma, è descritto nella sezione 543.2.2.

Una copia di questo file dovrebbe essere disponibile presso <allegati/a2/moltiplica.c>.

#include <stdio.h>

int
moltiplica (int x, int y)
{
    int z = 0;
    int i;

    for (i = 1; i <= y; i++)
      {
        z = z + x;
      }

    return z;
}

int
main (int argc, char *argv[])
{
    int x;
    int y;
    int z;

    // Converte le stringhe ottenute dalla riga di comando in
    // numeri interi e li assegna alle variabili x e y.

    sscanf (argv[1], "%d", &x);
    sscanf (argv[2], "%d", &y);

    z = moltiplica (x, y);

    printf ("%d * %d = %d\n", x, y, z);

    return 0;
}

In alternativa si può tradurre il ciclo for in un ciclo while.

int moltiplica (int x, int y)
{
    int z = 0;
    int i = 1;

    while (i <= y)
      {
        z = z + x;
        i++;
      }

    return z;
}

586.3   Divisione intera tra due numeri positivi

Il problema della divisione tra due numeri positivi, attraverso la sottrazione, è descritto nella sezione 543.2.3.

Una copia di questo file dovrebbe essere disponibile presso <allegati/a2/dividi.c>.

#include <stdio.h>

int
dividi (int x, int y)
{
    int z = 0;
    int i = x;

    while (i >= y)
      {
        i = i - y;
        z++;
      }

    return z;
}

int
main (int argc, char *argv[])
{
    int x;
    int y;
    int z;

    // Converte le stringhe ottenute dalla riga di comando in
    // numeri interi e li assegna alle variabili x e y.

    sscanf (argv[1], "%d", &x);
    sscanf (argv[2], "%d", &y);

    z = dividi (x, y);

    printf ("Divisione intera - %d:%d = %d\n", x, y, z);

    return 0;
}

586.4   Elevamento a potenza

Il problema dell'elevamento a potenza tra due numeri positivi, attraverso la moltiplicazione, è descritto nella sezione 543.2.4.

Una copia di questo file dovrebbe essere disponibile presso <allegati/a2/exp.c>.

#include <stdio.h>

int
exp (int x, int y)
{
    int z = 1;
    int i;

    for (i = 1; i <= y; i++)
      {
        z = z * x;
      }

    return z;
}

int
main (int argc, char *argv[])
{
    int x;
    int y;
    int z;

    // Converte le stringhe ottenute dalla riga di comando in
    // numeri interi e li assegna alle variabili x e y.

    sscanf (argv[1], "%d", &x);
    sscanf (argv[2], "%d", &y);

    z = exp (x, y);

    printf ("%d ** %d = %d\n", x, y, z);

    return 0;
}

In alternativa si può tradurre il ciclo for in un ciclo while.

int
exp (int x, int y)
{
    int z = 1;
    int i = 1;

    while (i <= y)
      {
        z = z * x;
        i++;
      };

    return z;
}

È possibile usare anche un algoritmo ricorsivo.

int exp (int x, int y)
{
    if (x == 0)
      {
        return 0;
      }
    else if (y == 0)
      {
        return 1;
      }
    else
      {
        return (x * exp (x, y-1));
      }
}

586.5   Radice quadrata

Il problema della radice quadrata è descritto nella sezione 543.2.5.

Una copia di questo file dovrebbe essere disponibile presso <allegati/a2/radice.c>.

#include <stdio.h>

int
radice (int x)
{
    int z = 0;
    int t = 0;

    while (1)
      {
        t = z * z;

        if (t > x)
          {
            //  È stato superato il valore massimo.
            z--;
            return z;
          }

        z++;
      }

    // Teoricamente, non dovrebbe mai arrivare qui.
}

int
main (int argc, char *argv[])
{
    int x;
    int z;

    sscanf (argv[1], "%d", &x);

    z = radice (x);

    printf ("radq(%d) = %d\n", x, z);

    return 0;
}

586.6   Fattoriale

Il problema del fattoriale è descritto nella sezione 543.2.6.

Una copia di questo file dovrebbe essere disponibile presso <allegati/a2/fatt.c>.

#include <stdio.h>

int
fatt (int x)
{
    int i = (x - 1);

    while (i > 0)
      {
        x = x * i;
        i--;
      }

    return x;
}

int
main (int argc, char *argv[])
{
    int x;
    int z;

    sscanf (argv[1], "%d", &x);

    z = fatt (x);

    printf ("%d! = %d\n", x, z);

    return 0;
}

In alternativa, l'algoritmo si può tradurre in modo ricorsivo.

int
fatt (int x)
{
    if (x > 1)
      {
        return (x * fatt (x - 1));
      }
    else
      {
        return 1;
      }
}

586.7   Massimo comune divisore

Il problema del massimo comune divisore, tra due numeri positivi, è descritto nella sezione 543.2.7.

Una copia di questo file dovrebbe essere disponibile presso <allegati/a2/mcd.c>.

#include <stdio.h>

int
mcd (int x, int y)
{
    while (x != y)
      {
        if (x > y)
          {
            x = x - y;
          }
        else
          {
            y = y - x;
          }
      }

    return x;
}

int
main (int argc, char *argv[])
{
    int x;
    int y;
    int z;

    sscanf (argv[1], "%d", &x);
    sscanf (argv[2], "%d", &y);

    z = mcd (x, y);

    printf ("Il massimo comune divisore di %d e %d è %d\n", x, y, z);

    return 0;
}

586.8   Numero primo

Il problema della determinazione se un numero sia primo o meno, è stato descritto nella sezione 543.2.8.

Una copia di questo file dovrebbe essere disponibile presso <allegati/a2/primo.c>.

#include <stdio.h>

unsigned int
primo (int x)
{
    unsigned int primo = 1;
    int i = 2;
    int j;

    while ((i < x) && primo)
      {
        j = x / i;
        j = x - (j * i);

        if (j == 0)
          {
            primo = 0;
          }
        else
          {
            i++;
          }
      }

    return primo;
}

int
main (int argc, char *argv[])
{
    int x;

    sscanf (argv[1], "%d", &x);

    if (primo (x))
      {
        printf ("%d è un numero primo\n", x);
      }
    else
      {
        printf ("%d non è un numero primo\n", x);
      }

    return 0;
}

586.9   Successione di Fibonacci

La successione di Fibonacci è descritta nella sezione 543.2.9.

Gli esempi mostrano una funzione che restituisce l'elemento n-esimo nella sequenza di Fibonacci, mentre la chiamata di questa funzione viene fatta in modo da ottenere l'elenco dei primi n numeri di Fibonacci. La prima soluzione mostra una funzione ricorsiva. Una copia di questo file dovrebbe essere disponibile presso <allegati/a2/fibonacci.c>.

#include <stdio.h>

unsigned int
fibonacci (unsigned int n)
{
    if (n == 0)
      {
        return 0;
      }
    else if (n == 1)
      {
        return 1;
      }
    else
      {
        return (fibonacci (n-1) + fibonacci (n-2));
      }
}

int
main (int argc, char *argv[])
{
    unsigned int n;
    unsigned int i;

    sscanf (argv[1], "%u", &n);

    for (i = 0; i <= n; i++)
      {
        printf ("%u ", fibonacci (i));
      }
    printf ("\n");

    return 0;
}

L'esempio seguente mostra solo la funzione, in forma iterativa:

unsigned int
fibonacci (unsigned int n)
{
    unsigned int f1 = 1;
    unsigned int f0 = 0;
    unsigned int fn = n;
    unsigned int i;

    for (i = 2; i <= n; i++)
      {
        fn = f1 + f0;
        f0 = f1;
        f1 = fn;
      }

    return fn;
}

Appunti di informatica libera 2008 --- Copyright © 2000-2008 Daniele Giacomini -- <appunti2 (ad) gmail·com>


Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome problemi_elementari_di_programmazione.htm

[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home]

Valid ISO-HTML!

CSS validator!

Gjlg Metamotore e Web Directory