RISOLTO [C++] Vector con size>=10, memorizza numeri a caso

[Svpam]

Spoiler

Dato un numero N da tastiera stampare in output il numero Nmax-Nmin, dove Nmax e Nmin sono, rispettivamente, il massimo ed il minimo ottenibile con le singole cifre di N.
Es: per N=12345.
Nmax=54321, Nmin=12345
output: 54321-12345=41976

Ho scritto il programma e funziona.

Ma se N ha più di 10 cifre da problemi (con 11 o + cifre nemmeno compila)
Se ad esempio come N inserisco: 1234556789 (10 cifre)
in output da: 988755531-135557889

Il codice che ho scritto è questo:

#include <iostream>
#include <vector>
#include <algorithm> //funzione sort
using namespace std;


int main()
{
    int n; //numero in input
    cin>>n;

    vector<int>Nmax; //vettore per memorizzare singole cifre
    vector<int>Nmin; // "        "        "            "

/* ricavo le cifre:    */

    int x=10;
    while(n>=x)
    {
        x*=10;
    }
    x/=10;

    int cifra=0;

    while(x>=1)
    {
        cifra=n/x;
        n-=cifra*x;
        x/=10;
        Nmax.push_back(cifra); //memorizzo cifre nel vettore
        Nmin.push_back(cifra); // "            "        "
    }

/* ordino i vettori, uno in modo decrescente e l'altro in modo crescente    */
    sort(Nmax.begin(), Nmax.end(), greater<int>());
    sort(Nmin.begin(), Nmin.end());

    int N_max=0; //variabile su cui eseguire la sottrazione
    int N_min=0; // "        "        "            "

/* copio i vettori nelle due variabili:    */
    for (int k=0; k<Nmax.size(); k++) 
    {
        int num=Nmax[k];
        if (num!=0)
        {
            while (num>0) 
            {
                N_max*=10;
                num/=10;
            }
            N_max+=Nmax[k];
        }
        else 
        {
            N_max*=10;
        }
    }

    for (int r=0; r<Nmin.size(); r++) 
    {
        int num2=Nmin[r];
        if (num2!=0)
        {
            while (num2>0) 
            {
                N_min*=10;
                num2/=10;
            }
            N_min+=Nmin[r];
        }
        else 
        {
            N_min*=10;
        }
    }

/* sottraggo N_max e N_min:    */
    cout<<N_max<<"-"<<N_min<<endl;
    cout<<N_max-N_min;
    return 0;
}

 

[BAT]

re: [C++] Vector con size>=10, memorizza numeri a caso

nel programma usi il tipo int, generalmente rappresentato a 32 bit per cui può rappresentare gli interi tra
-2147483648 a +2147483647 (ossia tra -2^31 e +2^31-1)
ossai numeri interi da 10 cifre ma dentro quell'intervallo;
se tu usassi un unsigned int rappresenteresti i numeri da 0 a 2^32-1 ossia da 0 fino a 4294967295
al massimo puoi allargare l'intervallo usando tipi più ampi come un long long (19 cifre, la prima dell'intero massimo rappresentabile è un 9) o un unsigned long long, che ti dovrebbe permettere 20 cifre (ma la prima del massimo è un 1) perché questi tipi, da specifiche hanno almeno una rappresentazione a 64 bit.
Questo significa che quando leggi l'input n devi stampare un messaggio di avviso che l'intero inserito deve essere "al massimo xyz" dove xyz ti è dato dai limiti numerici del compilatore. Ma anche così non basta, a seconda del numero in input puoi ugualmente andare fuori range (per es. 198765432 è nel range come intero a 32 bit in input, ma poi come output non va più bene).

Una via alternativa potrebbe essere di acquisire il numero in input non come intero ma come sequenza di caratteri (le singole cifre) che hanno già un loro ordinamento; la stampa è da fare sempre su una successione di caratteri. In questo modo non andresti mai fuori range.
In pratica:
- acquisisci le singole cifre (o la stringa di caratteri che rappresenta il numero in input) e le memorizzi una ad una come elementi di un vettore;
- ordini il vettore in modo crescente
- la stampa dal primo all'ultimo elemento è il numero minimo
- la stampa dall'ultimo elemento al primo è il numero massimo

In questo modo stampi singolo caratteri, non tratti mai con numeri interi per cui non vai fuori range.

 

[Svpam]

re: [C++] Vector con size>=10, memorizza numeri a caso

nel programma usi il tipo int, generalmente rappresentato a 32 bit per cui può rappresentare gli interi tra
-2147483648 a +2147483647 (ossia tra -2^31 e +2^31-1)
ossai numeri interi da 10 cifre ma dentro quell'intervallo;
se tu usassi un unsigned int rappresenteresti i numeri da 0 a 2^32-1 ossia da 0 fino a 4294967295
al massimo puoi allargare l'intervallo usando tipi più ampi come un long long (19 cifre, la prima dell'intero massimo rappresentabile è un 9) o un unsigned long long, che ti dovrebbe permettere 20 cifre (ma la prima del massimo è un 1) perché questi tipi, da specifiche hanno almeno una rappresentazione a 64 bit.
Questo significa che quando leggi l'input n devi stampare un messaggio di avviso che l'intero inserito deve essere "al massimo xyz" dove xyz ti è dato dai limiti numerici del compilatore. Ma anche così non basta, a seconda del numero in input puoi ugualmente andare fuori range (per es. 198765432 è nel range come intero a 32 bit in input, ma poi come output non va più bene).

Una via alternativa potrebbe essere di acquisire il numero in input non come intero ma come sequenza di caratteri (le singole cifre) che hanno già un loro ordinamento; la stampa è da fare sempre su una successione di caratteri. In questo modo non andresti mai fuori range.
In pratica:
- acquisisci le singole cifre (o la stringa di caratteri che rappresenta il numero in input) e le memorizzi una ad una come elementi di un vettore;
- ordini il vettore in modo crescente
- la stampa dal primo all'ultimo elemento è il numero minimo
- la stampa dall'ultimo elemento al primo è il numero massimo

In questo modo stampi singolo caratteri, non tratti mai con numeri interi per cui non vai fuori range.

Grazie.