C/C++ - Come invertire un numero[C]

l'esercizio l'ho preso dal libro "Corso completo di programmazione" terza edizione H.M deitel

la richiesta è quella di visualizzare una tabella di equivalenza tra decimali,binari,ottali ed esadecimali...il problema è che una volta svolto il tutto non sapevo come capovolgere i numeri..ora tutto risolto grazie molte.

Posso darti un consiglio? Butta via il Deitel: è il peggior nemico di chiunque voglia imparare a programmare.

Comunque, mi fa piacere che tu sia riuscito a risolvere il problema (tra l'altro con lo stesso algoritmo che ti ho in seguito proposto io)

in realtà è un mezzo provvisorio ho deciso di iscrivermi all'uni quindi per non stare con le mani in mano cerco quanto meno di mettere le basi anche se all'uni si parte da zero.. grazie mille dei consigli

Capisco... allora probabilmente ci penserà il tuo docente (speriamo sia una persona seria... ) a insegnarti il corretto stile di programmazione

Se ti va di seguire un "mezzo provvisorio" più serio, comunque, guarda qui: fabiomanganiello.com/…

E comunque, ogni programmatore C AL MONDO deve avere questo, che è stato scritto dai "creatori" del linguaggio C: amazon.it/linguaggio-Principi-programmazione-manuale-riferimento/dp/…

(Ah, e un'altra cosa: se ami l'autodidattica e vuoi acquisire da subito un corretto stile di programmazione, potresti trarre giovamento anche da questo: amazon.com/Problem-Solving-Programming-Concepts-9th/dp/… )

Grazie mille gentilissimo

Personalmente quel "invertire il numero" l'avevo inteso come semplice rovesciamento dell'array di char ottenuto "all'indietro" dalla conversione numero->stringa.

/*==============================================================================
Riceve, tramite il parametro s, un puntatore ad una stringa "zero terminated" e
la "rovescia" in loco invertendone l'ordine dei caratteri.
Restituisce lo stesso puntatore ricevuto tramite il parametro s.
==============================================================================*/

char *inverti_stringa( char *s ) {
    if( s != NULL ) { /* s deve essere un puntatore valido */
        long i, l, lMezzi;
        char aux;

        for( l=0; s[l]; ++l ); /* ricava la lunghezza della stringa */

        /* inverte l'ordine dei caratteri nella stringa */
        for( lMezzi=l/2, i=0; i<lMezzi; ++i ) {
            aux = s[i];
            s[i] = s[l-i-1];
            s[l-i-1] = aux;
        }
    }

    return s;
}

La conversione numero->stringa su base qualsiasi entro l'ambito 2<->36, invece, l'avrei risolta così:

/*==============================================================================
Converte il numero intero di tipo long int passato tramite il parametro n nella
sua rappresentazione sotto forma di stringa nella numerazione corrispondente
alla base indicata tramite il parametro base. La base della numerazione puo'
essere compresa tra 2 e 36; se il parametro base eccede i limiti consentiti, la
funzione non fornisce la rappresentazione sotto forma di stringa del numero
passato in n, bensi' una stringa d'errore che recita "(la base eccede i limiti
consentiti)".
Il valore di ritorno e' un puntatore a un buffer statico costituito da un array
di 36 char che viene sovrascritto ad ogni nuova chiamata della funzione.
==============================================================================*/

char *numero_in_stringa( long n, int base ) {
    static const char cifre[40] = "0123456789abcdefghijklmnopqrstuvwxyz";
    static char buff[36]; /* puo' contenere max 32 cifre + il segno negativo */
    long long nn = n; // long long necessario per trattare il valore -2147483648
    int i;

    if( base >= 2 && base <= 36 ) {
        int cifra, negativo;

        negativo = nn < 0; /* memorizziamo il segno */
        nn = negativo ? -nn : nn; /* usiamo sempre un valore positivo */

        /* N.B. la stringa viene generata "all'indietro" */
        for( i=0; nn!=0; ++i ) {
            cifra = nn%base;
            buff[i] = cifre[cifra];
            nn /= base;
        }

        if( negativo ) buff[i++] = '-'; /* apponiamo il segno? */
        buff[i] = 'La conversione numero->stringa su base qualsiasi entro l'ambito 2<->36, invece, l'avrei risolta così:



/*==============================================================================
Converte il numero intero di tipo long int passato tramite il parametro n nella
sua rappresentazione sotto forma di stringa nella numerazione corrispondente
alla base indicata tramite il parametro base. La base della numerazione puo'
essere compresa tra 2 e 36; se il parametro base eccede i limiti consentiti, la
funzione non fornisce la rappresentazione sotto forma di stringa del numero
passato in n, bensi' una stringa d'errore che recita "(la base eccede i limiti
consentiti)".
Il valore di ritorno e' un puntatore a un buffer statico costituito da un array
di 36 char che viene sovrascritto ad ogni nuova chiamata della funzione.
==============================================================================*/

char *numero_in_stringa( long n, int base ) {
    static const char cifre[40] = "0123456789abcdefghijklmnopqrstuvwxyz";
    static char buff[36]; /* puo' contenere max 32 cifre + il segno negativo */
    long long nn = n; // long long necessario per trattare il valore -2147483648
    int i;

    if( base >= 2 && base <= 36 ) {
        int cifra, negativo;

        negativo = nn < 0; /* memorizziamo il segno */
        nn = negativo ? -nn : nn; /* usiamo sempre un valore positivo */

        /* N.B. la stringa viene generata "all'indietro" */
        for( i=0; nn!=0; ++i ) {
            cifra = nn%base;
            buff[i] = cifre[cifra];
            nn /= base;
        }

        if( negativo ) buff[i++] = '-'; /* apponiamo il segno? */
        buff[i] = '{parsed_message}'; /* terminiamo la stringa */
        inverti_stringa( buff ); /* "rovesciamo" la stringa */
    }
    else { /* non sono ammesse basi minori di 2 o maggiori di 36 */
        const char *err = "(la base eccede i limiti consentiti)";
        for( i=0; err[i]; ++i ) buff[i] = err[i]; /* copiamo l'errore */
        buff[i] = '{parsed_message}'; /* terminiamo la stringa */
    }

    return buff; /* restituiamo un puntatore a uno spazio di memoria statico */
}



Edit: chissà perché "vede" il codice come C#... a me sembra comunissimo C.'; /* terminiamo la stringa */
        inverti_stringa( buff ); /* "rovesciamo" la stringa */
    }
    else { /* non sono ammesse basi minori di 2 o maggiori di 36 */
        const char *err = "(la base eccede i limiti consentiti)";
        for( i=0; err[i]; ++i ) buff[i] = err[i]; /* copiamo l'errore */
        buff[i] = 'La conversione numero->stringa su base qualsiasi entro l'ambito 2<->36, invece, l'avrei risolta così:



/*==============================================================================
Converte il numero intero di tipo long int passato tramite il parametro n nella
sua rappresentazione sotto forma di stringa nella numerazione corrispondente
alla base indicata tramite il parametro base. La base della numerazione puo'
essere compresa tra 2 e 36; se il parametro base eccede i limiti consentiti, la
funzione non fornisce la rappresentazione sotto forma di stringa del numero
passato in n, bensi' una stringa d'errore che recita "(la base eccede i limiti
consentiti)".
Il valore di ritorno e' un puntatore a un buffer statico costituito da un array
di 36 char che viene sovrascritto ad ogni nuova chiamata della funzione.
==============================================================================*/

char *numero_in_stringa( long n, int base ) {
    static const char cifre[40] = "0123456789abcdefghijklmnopqrstuvwxyz";
    static char buff[36]; /* puo' contenere max 32 cifre + il segno negativo */
    long long nn = n; // long long necessario per trattare il valore -2147483648
    int i;

    if( base >= 2 && base <= 36 ) {
        int cifra, negativo;

        negativo = nn < 0; /* memorizziamo il segno */
        nn = negativo ? -nn : nn; /* usiamo sempre un valore positivo */

        /* N.B. la stringa viene generata "all'indietro" */
        for( i=0; nn!=0; ++i ) {
            cifra = nn%base;
            buff[i] = cifre[cifra];
            nn /= base;
        }

        if( negativo ) buff[i++] = '-'; /* apponiamo il segno? */
        buff[i] = '{parsed_message}'; /* terminiamo la stringa */
        inverti_stringa( buff ); /* "rovesciamo" la stringa */
    }
    else { /* non sono ammesse basi minori di 2 o maggiori di 36 */
        const char *err = "(la base eccede i limiti consentiti)";
        for( i=0; err[i]; ++i ) buff[i] = err[i]; /* copiamo l'errore */
        buff[i] = '{parsed_message}'; /* terminiamo la stringa */
    }

    return buff; /* restituiamo un puntatore a uno spazio di memoria statico */
}



Edit: chissà perché "vede" il codice come C#... a me sembra comunissimo C.'; /* terminiamo la stringa */
    }

    return buff; /* restituiamo un puntatore a uno spazio di memoria statico */
}

Edit: chissà perché "vede" il codice come C#... a me sembra comunissimo C.