[Resolvido] Digitos de um número

[askazy]

Boa noite, bom o objetivo do programar é criar uma função recursiva, a qual dado um numero inteiro n entre 1 e 9999999 imprima os dígitos do mesmo na ordem em que ele aparece, exemplos

Exemplo 1: n= 123456

saída: 1 2 3 4 5 6

Exemplo2: n=32123

saída: 3 2 1 2 3

Não estou conseguindo enxergar uma forma de resolver isso usando recursão, se fosse do último ao primeiro dígito eu até saberia, mas começando do primeiro, não sei o que fazer.

[nelsonr]

Não estou a ver a necessidade de uma função recursiva.

Não será necessário apenas passar por todos os caracteres da string e imprimir o caracter?

[askazy]

Isso foi exercício de uma prova, o qual não consegui fazer. Era obrigatório fazer uma função recursiva.

[thoga31]

O que se faz classicamente é obter o dígito e escrevê-lo logo no monitor. Só após escrevermos o dígito é que voltamos a chamar a função de forma recursiva.

O segredo está essencialmente em trocar esta ordem. Assim o que acontece é que a função recursiva é chamada, e quando chegas ao último dígito começa a ser feito o printf de trás para a frente.

Um pedaço de papel e caneta vão-te ajudar a perceber este efeito.

Edited June 27, 2014 by thoga31

[nhm]

Se sabes fazer em ordem inversa, também sabes fazer em ordem correta. Como o thoga31 apontou, é só trocar a ordem das operações. De uma forma geral, a ordem das operações em funções recursivas dita o funcionamento de um algoritmo.

Edited June 27, 2014 by nhm

[askazy]

Acho que consegui, meio que na sorte mas acho que deu:

#include <stdio.h>
void digitos(int n){
if (n>10){
 digitos(n/10);
 digitos(n%10);
}
else{
 printf ("%d ",n);
}
}
int main(){
 int n;
 scanf ("%d",&n);
 digitos(n);
return 0;
}

Só que não consegui muito bem ver o funcionamento.

Edited June 27, 2014 by askazy

[nhm]

Essa solução funciona, mas faz mais chamadas recursivas do que é necessário. Repara que n%10 produz sempre um valor entre 0 e 9, logo essa chamada vai sempre para o "else".

Se substituires essa chamada por simplesmente um printf, reduzes em muito o número de chamadas e fica mais legível.

void digitos(int n){
 if(n > 0){
	  digitos(n/10);
	  printf("%d ", n%10);
 }
}

Para te ajudar a perceberes o funcionamento do algoritmo, vamos analisar o caso de digitos(123).

Esta é a ordem de operações (as | servem para identificares a chamada a que o código pertence).

digitos(123)

| digitos(12) (123/10)

| | digitos(1) (12/10)

| | | digitos(0) - como n <= 0, não faz nada

| | print(1) (1%10)

| print(2) (12%10)

print(3) (123%10)

Edited June 27, 2014 by nhm

[thoga31]

Para quê chamar a função duas vezes? Já reparaste que a segunda chamada, digitos(n%10), é redundante? n%10 é sempre menor que 10, pelo que é uma forma complicada de fazer o printf - chamas a função, n é menos que 10, e faz printf, voltando à função inicial.

void digs(long n) {
  if (n>=10)
     digs(n/10);
  printf("%ld ", n%10);
}

Como funciona? Tu tens o número 1234, por exemplo. 1234>=10, pelo que vai chamar a função digs. 1234/10 = 123, ou seja, estamos a invocar digs(123). E assim em diante, até que chamamos digs(1). Como 1<10, a condição do if não se cumpre, e paramos a chamada recursiva. Faz o printf de 1%10 que é 1, e volta à função que a chamou inicialmente. Esta era a função digs(12) e é feito o printf respectivo.

Em esquema:

digs(1234)
----> 1234 >= 10? Sim, logo:
  |> digs(1234/10) = digs(123)
  |
  |  ----> 123 >= 10? Sim, logo:
  |     |> digs(123/10) = digs(12)
  |     |
  |     |  ----> 12 >= 10? Sim, logo:
  |     |     |> digs(12/10) = digs(1)
  |     |     |
  |     |     |  ----> 1 >= 10? Não, logo:
  |     |     |     |> printf(1%10 = 1)
  |     |     |     |
  |     |     |  <---- [volta à função que fez a chamada]
  |     |     |> printf(12%10 = 2)
  |     |     |
  |     |  <----
  |     |> printf(123%10 = 3)
  |     |
  |  <----
  |> printf(1234%10 = 4)
  |
[Fim]

Edited June 28, 2014 by thoga31

[askazy]

Entendi, obrigado @nhm e @thoga31