numero di cifre (metodo ricorsivo)

[mastodilu]

fatto... ma non mi è del tutto chiaro:

class NumeroDiCifre
{
    public static int QuanteCifre(int numero)
    {   
        if(numero>1)
        {  numero=numero/10;
            return 1+QuanteCifre(numero);
        }else
            return 0;
    }
    
    
    public static void main(String[] args)
    {    int numero,n;
        System.out.print("Inserisci il numero: ");
        numero=SavitchIn.readLineInt();
        n=QuanteCifre(numero);
        System.out.print("Ha "+n+" cifra/e");
    }
}

[francesco.muia]

Allora se vuoi eliminare il conta è un'altro "conto" scusa il gioco di parole, cmq anche in questo caso ti servono 2 return, una appunto per effettuare le chiamate ricorsive 1 + QuanteCifre(n) e l'altra per "stoppare" la ricorsione quando n diventa < 0.

[andbin]

ok ma il return che avevo messo serviva a restituire "conta" che mi è stato detto essere inutile...

Sì, è inutile.
L'ho detto nella prima risposta ma lo posso ripetere meglio: se il numero è maggiore (o diverso se vuoi gestire anche i negativi) di zero, allora dovrai restituire un 1 fisso più il valore fornito dalla invocazione ricorsiva in cui passi il numero diviso 10.
Altrimenti se è zero, restituisci 0.

[mastodilu]

se il numero è maggiore (o diverso se vuoi gestire anche i negativi) di zero, allora dovrai restituire un 1 fisso più il valore fornito dalla invocazione ricorsiva in cui passi il numero diviso 10.
Altrimenti se è zero, restituisci 0.[/QUOTE]
così?

    public static int QuanteCifre(int numero)
    {
        if(numero>0)
        {   numero=numero/10;
            return 1+QuanteCifre(numero);
        }else
            return 0;
    }

funziona ma non capisco perchè

[andbin]

così?

Sì. Puoi anche passare alla invocazione ricorsiva direttamente il risultato della divisione, invece di aggiornare 'numero'. Ma comunque è ok.

funziona ma non capisco perchè

Es. 1234

QuanteCifre(1234): 1234 maggiore di 0, quindi 1 + QuanteCifre(123)
   QuanteCifre(123): 123 maggiore di 0, quindi 1 + QuanteCifre(12)
      QuanteCifre(12): 12 maggiore di 0, quindi 1 + QuanteCifre(1)
         QuanteCifre(1): 1 maggiore di 0, quindi 1 + QuanteCifre(0)
            QuanteCifre(0): zero, quindi 0

Quanti "1" vengono sommati?

[francesco.muia]

L'unico modo che hai per capirlo è eseguirlo passo passo (intendo mentalmente).
N=1234;
1 -> numero = numero/10 = 123 -> return 1 + -> QuanteCifre
2-> numero = numero/10 = 12 return 1+1 -> QuanteCifre (l'uno in + deriva dalla prima invocazione)
3-> numeor = numero/10 = 1 return 1+1+1 .....

[mastodilu]

La logica l'ho capita ma non riesco a capire come possa funzionare una funzione ricorsiva che ogni volta ha un return che dovrebbe finire nella variabile n=funzione_ricorsiva(variabile).
Ogni volta che la funzione viene invocata da se stessa non dovrebbe "sovrascrivere" n ?
Inoltre se ogni chiamata ricorsiva "crea la stessa funzione ma a sè stante" come fa a sommare 1 ogni volta e a tenere la conta degli 1 precedentemente sommati?

[andbin]

La logica l'ho capita ma non riesco a capire come possa funzionare una funzione ricorsiva che ogni volta ha un return che dovrebbe finire nella variabile n=funzione_ricorsiva(variabile).
Ogni volta che la funzione viene invocata da se stessa non dovrebbe "sovrascrivere" n ?
Inoltre se ogni chiamata ricorsiva "crea la stessa funzione ma a sè stante" come fa a sommare 1 ogni volta e a tenere la conta degli 1 precedentemente sommati?

Ma hai visto il mio esempio con 1234 dove ho evidenziato anche l'annidamento delle invocazioni con una lieve indentazione?

Ok, partiamo dal fondo e torniamo indietro:

al livello di QuanteCifre(0) esso restituisce 0
al livello di QuanteCifre(1) esso fa 1 + 0 e restituisce quindi 1
al livello di QuanteCifre(12) esso fa 1 + 1 e restituisce quindi 2
al livello di QuanteCifre(123) esso fa 1 + 2 e restituisce quindi 3
al livello di QuanteCifre(1234) esso fa 1 + 3 e restituisce quindi 4

[mastodilu]

dovrei averlo fatto, grazie a tutti