ho un programma che dice:
Si scriva un programma che ricevuto in input un numero composto al massimo
di 9 cifre (da 0 a 9) produca una sequenza "descrittiva" ( utilizzare un
ciclo con 10 iterazioni). Ogni numero descrive quello che lo precede
contando ordinatamente "tutte" le cifre che lo compongono ( usare una
funzione per calcorare la "descrizione" ).


Ora: io ho provato a risolverlo così:
codice:
# include <stdio.h>
# define SIZE_base 10
# define SIZE_colonne 10
# define SIZE_righe 2
# define SIZE_max 1024

int main()
{
   int num;
   int i = 0;
   int j = 0;
   int k, x, e;
   long vet[i];
   int vett[SIZE_righe][SIZE_colonne]; //matrice bidimensionale
   int cr;                             //contatore righe
   int cc;                             //contatore colonne
   long sol[SIZE_max];                  //vettore che verrà stampato
   int m=0;
   int z=0;
   int hold;
   int p, q, w;                        //contatore necessari a popolare la
                                       //matrice bidimensionale

   printf ("\n Inserisci una stringa (al massimo di 9 cifre):  ");
   scanf ("%d", &num );
   
   while ( num > 0 ) 
      {                                 //ho popolato un vettore con i singoli 
      vet[ i++ ] = (num % 10);          //numeri della stringa numerica 
      j++;                              //inserita dall'utente. Non ha importanza
      num = num / 10;                   //il fatto che sia popolata al contrario.
      }	                             
      
   for (x = 0; x < SIZE_base; x++)
   { 
      for ( cr = 0 ; cr < 2 ; cr ++ )   //Popolo la parte superiore della matrice 
         {                              //con numeri, la parte inferiore con 0
         for ( cc = 0 ; cc < SIZE_base ; cc++ )
            {
            vett[0][cc] = cc;
            vett[1][cc] = 0;      
            }   
         }
             
      q = 0;
    
      for ( p = 0 ; p < SIZE_base; p++ )//una volta creata la matrice
         {                              //multidimensionale, con questo metodo
         for( w = 0 ; w < j ; w++ )     //ripopolo la matrice con gli indici
            {                           //corretti del numero (ad ogni numero
            if ( vet[w] == p )          //corrisponderà l'indice con le volte
            q++;                        //che quel numero è presente nella
            }                           //stringa
         vett[1][p] = q;    
         q = 0;
         }
         
      z = 0 ;                           //fondamentale! Ad ogni giro parto 
                                        //sempre da 0.
                                            
      for ( cc = 0 ; cc < SIZE_base ; cc++ )
         {
         if ( vett[1][cc] != 0 )        //"cuore" del programma
            {                           //Popolo il vettore sol (sol sta per
            hold = vett[1][cc];         //soluzione). In questa maniera ce l'ho
            sol[z] = hold;              //pronto per una successiva stampa
            sol[z+1] = vett[0][cc];     
            z = z + 2 ;
            }   
         }   
         
      printf("(GIRO %d)\t", x + 1 );
       
      for( m = 0 ; m < z ; m++ )        //stampa del vettore sol 
         printf( "%d" , sol[m] );

      printf("\n");
   
      for ( e = 0 ; e < m ; e++ )       //alla fine del primo giro, il vettore
         {                              //sol deve divenire il vettore su cui     
         vet[e] = sol[e];               //ricominciare il secondo giro. Ecco
         }                              //spiegato il "ritorno" a vet per mezzo
                                        //di un assegnamento.          
          
      j = e +1  ;                           //la nuova lunghezza del vettore non 
                                        //sarà più j ma chiaramente e.
   }     
   system ("pause");
   return 0;  
      
}
Se metto numeri piccoli funziona, se metto numeri "grandi" tipo 7889 dopo qualche ciclo si stoppa.
per me c'è qualche error nella dimension del vettore int.