Trovare i due numeri più grandi - probabile problema di overflow aritmetico!! ma come risolverlo?

di il
7 risposte

Trovare i due numeri più grandi - probabile problema di overflow aritmetico!! ma come risolverlo?

Trovare i due numeri più grandi tra 10 numeri. [ Nota: potete inserire ogni numero solo una volta ].

Il mio problema è che per numeri di poche cifre il risultato viene corretto mentre per numeri con molte cifre i numeri vengono riportati giusti come ordine ma errati nelle ultime cifre. Come posso risolvere questo problema??? Secondo me potrebbe essere un problema di overflow aritmetico ma non so come potrei correggerlo.

Vi stampo i due pritscreen uno con poche cifre e l'altro con più cifre. Grazie
Ciao.

http://prntscr.com/fh01s corretto se con poche cifre

http://prntscr.com/fh02q non corretto nelle ultime cifre

Ecco il codice sorgente:

#include <stdio.h>
int main ( void )
{
    float primoN;
    float secondoN;
    float terzoN;
    float quartoN;
    float quintoN;
    float sestoN;
    float settimoN;
    float ottavoN;
    float nonoN;
    float decimoN;
    
    
    puts( "Inserisci 10 numeri differenti, per piacere, e ti verranno indicati i due maggiori tra questi\n" );
    scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );

// Inizio parte di controllo dell'errore di doppio inserimento di numeri.

    if ( primoN == secondoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il primo ed il secondo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( primoN == terzoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il primo ed il terzo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( primoN == quartoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il primo ed il quarto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( primoN == quintoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il primo ed il quintoN sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( primoN == sestoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il primo ed il sesto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( primoN == settimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il primo ed il settimoN sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", primoN, secondoN, terzoN, quartoN, quintoN, sestoN, settimoN, ottavoN, nonoN, decimoN );
    }
    if ( primoN == ottavoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il primo ed l'ottavo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( primoN == nonoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il primo ed il nono sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( primoN == decimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il primo ed il decimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( secondoN == terzoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il secondo ed il terzo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( secondoN == quartoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il secondo ed il quarto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( secondoN == quintoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il secondo ed il quinto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( secondoN == sestoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il secondo ed il sesto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( secondoN == settimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il secondo ed il settimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( secondoN == ottavoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il secondo ed l'ottavo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( secondoN == nonoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il secondo ed il nono sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( secondoN == decimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il secondo ed il decimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( terzoN == quartoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il terzo ed il quarto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( terzoN == quintoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il terzo ed il quinto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( terzoN == sestoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il terzo ed il sesto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( terzoN == settimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il terzo ed il settimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( terzoN == ottavoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il terzo ed l'ottavo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( terzoN == nonoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il terzo ed il nono sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( terzoN == decimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il terzo ed il decimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quartoN == quintoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quarto ed il quinto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quartoN == sestoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quarto ed il sesto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quartoN == settimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quarto ed il settimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quartoN == ottavoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quarto ed l'ottavo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quartoN == nonoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quarto ed il nono sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quartoN == decimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quarto ed il decimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quintoN == sestoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quinto ed il sesto sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quintoN == settimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quinto ed il settimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quintoN == ottavoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quinto ed l'ottavo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quintoN == nonoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quinto ed il nono sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( quintoN == decimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il quinto ed il decimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( sestoN == settimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il sesto ed il settimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( sestoN == ottavoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il sesto ed l'ottavo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( sestoN == nonoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il sesto ed il nono sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( sestoN == decimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il sesto ed il decimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( settimoN == ottavoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il settimo ed l'ottavo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( settimoN == nonoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il settimo ed il nono sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( settimoN == decimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il settimo ed il decimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( ottavoN == nonoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno l'ottavo ed il nono sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( ottavoN == decimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno l'ottavo ed il decimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    if ( nonoN == decimoN ) {
        puts( "Inserisci nuovamente i numeri perchè almeno il nono ed il decimo sono uguali tra di loro" );
        scanf( "%f%f%f%f%f%f%f%f%f%f", &primoN, &secondoN, &terzoN, &quartoN, &quintoN, &sestoN, &settimoN, &ottavoN, &nonoN, &decimoN );
    }
    
// Fine parte di controllo dell'errore di doppio inserimento di numeri.
    
    else {
        puts( "" );
        puts( "I due numeri maggiori tra i dieci numeri differenti tra di loro sono, rispettivamente:\n" );
           }
    
// Calcolo del primo numero maggiore e del secondo:


    float primoMaggiore = primoN;
    float secondoMaggiore = secondoN;
   
    if ( secondoN > primoMaggiore ) {
	      primoMaggiore = secondoN;
	      secondoMaggiore = primoN;
    }
    
    if ( terzoN > primoMaggiore ) {
	      primoMaggiore = terzoN;
    	  if ( secondoN > secondoMaggiore ) {
	          secondoMaggiore = secondoN;
	      } else { secondoMaggiore = primoN; }
    }
    if ( terzoN < primoMaggiore ) {
	      primoMaggiore = primoMaggiore;
	      if ( terzoN > secondoMaggiore ) {
	          secondoMaggiore = terzoN;
	      } else if ( terzoN < secondoMaggiore ) 
	          { secondoMaggiore = secondoMaggiore; }
    }
    
    if ( quartoN > primoMaggiore ) {
        primoMaggiore = quartoN;
        if ( terzoN > secondoMaggiore ) {
            secondoMaggiore = terzoN;
        } else { secondoMaggiore = secondoMaggiore; }
    }
    if ( quartoN < primoMaggiore ) {
        primoMaggiore = primoMaggiore;
        if ( quartoN > secondoMaggiore ) {
            secondoMaggiore = quartoN;
        } else if ( quartoN < secondoMaggiore ) {
           secondoMaggiore = secondoMaggiore; }
    }
    
    
    if ( quintoN > primoMaggiore ) {
        primoMaggiore = quintoN;
        if ( quartoN > secondoMaggiore ) {
            secondoMaggiore = quartoN;
        } else { secondoMaggiore = secondoMaggiore; }
    }
    if ( quintoN < primoMaggiore ) {
        primoMaggiore = primoMaggiore;
        if ( quintoN > secondoMaggiore ) {
            secondoMaggiore = quintoN;
        } else if ( quintoN < secondoMaggiore ) {
             secondoMaggiore = secondoMaggiore; }
    }
    
    
    
    if ( sestoN > primoMaggiore ) {
        primoMaggiore = sestoN;
        if ( quintoN > secondoMaggiore ) {
            secondoMaggiore = quintoN;
        } else { secondoMaggiore = secondoMaggiore; }
    }
    if ( sestoN < primoMaggiore ) {
        primoMaggiore = primoMaggiore;
        if ( sestoN > secondoMaggiore ) {
            secondoMaggiore = sestoN;
        } else if ( sestoN < secondoMaggiore ) {
             secondoMaggiore = secondoMaggiore; }
    }
    
    
    if ( settimoN > primoMaggiore ) {
        primoMaggiore = settimoN;
        if ( sestoN > secondoMaggiore ) {
            secondoMaggiore = sestoN;
        } else { secondoMaggiore = secondoMaggiore; }
    }
    if ( settimoN < primoMaggiore ) {
        primoMaggiore = primoMaggiore;
        if ( settimoN > secondoMaggiore ) {
            secondoMaggiore = settimoN;
        } else if ( settimoN < secondoMaggiore ) {
             secondoMaggiore = secondoMaggiore; }
    }
    
    
    
    if ( ottavoN > primoMaggiore ) {
        primoMaggiore = ottavoN;
        if ( settimoN > secondoMaggiore ) {
            secondoMaggiore = settimoN;
        } else { secondoMaggiore = secondoMaggiore; }
    }
    if ( ottavoN < primoMaggiore ) {
        primoMaggiore = primoMaggiore;
        if ( ottavoN > secondoMaggiore ) {
            secondoMaggiore = ottavoN;
        } else if ( ottavoN < secondoMaggiore ) {
             secondoMaggiore = secondoMaggiore; }
    }
    
    
    
    if ( nonoN > primoMaggiore ) {
        primoMaggiore = nonoN;
        if ( ottavoN > secondoMaggiore ) {
            secondoMaggiore = ottavoN;
        } else { secondoMaggiore = secondoMaggiore; }
    }
    if ( nonoN < primoMaggiore ) {
        primoMaggiore = primoMaggiore;
        if ( nonoN > secondoMaggiore ) {
            secondoMaggiore = nonoN;
        } else if ( nonoN < secondoMaggiore ) {
             secondoMaggiore = secondoMaggiore; }
    }
    
    
    if ( decimoN > primoMaggiore ) {
        primoMaggiore = decimoN;
        if ( nonoN > secondoMaggiore ) {
            secondoMaggiore = nonoN;
        } else { secondoMaggiore = secondoMaggiore; }
    }
    if ( decimoN < primoMaggiore ) {
        primoMaggiore = primoMaggiore;
        if ( decimoN > secondoMaggiore ) {
            secondoMaggiore = decimoN;
        } else if ( decimoN < secondoMaggiore ) {
             secondoMaggiore = secondoMaggiore; }
    }
    
    printf( "Il primo numero maggiore della serie di dieci è:\n%.3f\nmentre il secondo numero maggiore è:\n%.3f.\nGrazie!", primoMaggiore, secondoMaggiore );
}

7 Risposte

  • Re: Trovare i due numeri più grandi - probabile problema di overflow aritmetico!! ma come risolverlo?

    E' una questione di cifre significative ... usa i double ... (anche se esistono sempre dei limiti).

    In ogni caso, quel codice non si può leggere ... diciamo che è assurdo ...
  • Re: Trovare i due numeri più grandi - probabile problema di overflow aritmetico!! ma come risolverlo?

    Forse sarebbe più leggibile con dei commenti comunque la prima parte è per evitare che vengano inseriti due numeri uguali, come richiesto dall'esercizio; non saprei come farla più corta questa parte. La seconda parte è la parte di ricerca dei due numeri maggiori.

    Io non sono ancora arrivato alla variabile double . Sarebbe una sostituta di int o float per numeri piuttosto grandi? Ho sentito parlare di overflow aritmetico e che ci sono dei limiti di cifre per ogni computer che possono variare e che bisognerebbe sempre controllare soprattutto per programmi industriali. Ma come si fa a controllare l'overflow della mia macchina?? se è l'overflow il problema...Grazie.

    P.S. avevo sentito parlare del file di intestazione <limits.h> ma altro non so... Grazie.
    Ciao.
  • Re: Trovare i due numeri più grandi - probabile problema di overflow aritmetico!! ma come risolverlo?

    Allora per ordine.
    1) è un meraviglioso esempio di loop unrolling: solo un principiante potrebbe avere un'idea del genere (o uno moolto più esperto)
    Per l'inserimento potresti fare qualcosa banale del tipo:
    memorizzo i dati in un vettore nella posizione i-esima (cioè un vettore di 10 numeri) e controllando se viene inserito due volte.
    Avrai problemi di flagging o bigm che dir si voglia

    2) per i double: evidentemente ancora non hai studiato calcolo numerico e (in)stabilità.
    A grandissime linee non puoi fare confronti del tipo x è UGUALE a y con numeri in virgola mobile.
    Quello che devi fare è utilizzare una qualche genere di metrica, la più banale delle quali è il modulo, cioè |x-y|<eps, con eps la precisione che ritieni essere sufficiente per discriminare due reali.
    Ovviamente anche questo per la stabilità numerica non va benissimo, perchè il modulo, tra l'altro, non è derivabile ovunque (ha una cuspide in zero).
    Normalmente, cioè quando non si ha necessità di cose "turche" si opera in norma2, cioè col quadrato (il che è buono perchè è facilmente calcolabile, stabile numericamente, e derivabile ovunque essendo un banale polinomio).

    Come vedi non è banale nulla, nell'informatica, a un livello di consapevolezza non elementare.
    Forza!
  • Re: Trovare i due numeri più grandi - probabile problema di overflow aritmetico!! ma come risolverlo?

    Scusa, mi son dimenticato dell'overflow.
    Allora nei tipi primitivi puoi inserire numeri in virgola mobile grandi fino a un TOT (qui se vuoi faccio lo spiegone, ma lasciamo stare).
    In sostanza una variabile double occupa uno certo spazio in memoria (8 byte) e può "contenere" numeri fino a una certa grandezza (in realtà essendo in virgola mobile puoi usare anche gli esponenti).

    Ebbene, come faccio ad esempio a memorizzare che so il numero 123456789012345678901234567890.31415192647343423212122323 ?

    Semplice, non fai.
    Ti servono una serie di funzioni a precisione estesa, che memorizzano i valori in modo "strano" (cioè mediante strutture dati più complesse) che possono anche, talvolta, avere precisione infinita (cioè limitata dalla massima memoria allocabile nello heap).
    Ci sono tante librerie già fatte ma, sul tenore della banalità dell'esercizio, non mi preoccuperei più di tanto.
  • Re: Trovare i due numeri più grandi - probabile problema di overflow aritmetico!! ma come risolverlo?

    In C, quando non si conosce il segno degli operandi diventa complicato, se non impossibile, rilevare se il calcolo è stato effettuato correttamente, mentre quando si parla di unsigned basta confrontare il risultato ottenuto con gli operandi. Ad esempio;
    
    #include <limits.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void)
    {
    	unsigned int a = UINT_MAX;
    	unsigned int b = 1;
    	unsigned int result;
    	
    	result = a + b;
    	
    	if(result < a || result < b) /* Basta solo una condizione*/
    	{
    		(void) fputs("Errore di overflow", stderr); /* Per inciso, UINT_MAX + 1 = 0 */
    		return (EXIT_FAILURE); /*Oppure routine di recupero*/
    	}
    	else
    	{
    		(void) fputs("Operazione effettuata con successo\n", stdout);
    	}
    	return (EXIT_SUCCESS);
    }
    
    In ogni caso in C l'oveflow si può solo rilevare una volta avvenuto.
  • Re: Trovare i due numeri più grandi - probabile problema di overflow aritmetico!! ma come risolverlo?

    +m2+ ha scritto:


    [...]è un meraviglioso esempio di loop unrolling[...]
  • Re: Trovare i due numeri più grandi - probabile problema di overflow aritmetico!! ma come risolverlo?

    Grazie a tutti!! ))

Devi accedere o registrarti per scrivere nel forum
7 risposte