Cómo definir una función para encontrar el producto de dígitos en Python usando recursividad

Estoy resolviendo esto en dos modos de recursión.

Recursion regular:

def calc Producto (n):
if (len (str (n)) == 1):
volver n
más:
retorno (n% 10 * calcProduct (n / 10))

imprimir (calcProduct (12345))

Recursión de la cola:

def calc Producto (n, producto):
if (len (str (n)) == 1):
producto impreso
más:
calcProduct (n / 10, ((n% 10) * producto))

calcProduct (12345,1)

Más detalles sobre la recursividad de la cola

EDITAR: Deepak Gupta editado de acuerdo con su comentario
En lugar de imprimir el resultado, simplemente repita el proceso con algún cambio en la condición

# su código va aquí
def calc Producto (n, producto):
si (n <= 0):
if (len (str (producto))> 1):
#print product
calcProduct (producto, 1)
más:
producto impreso
más:
rem = 1
si (n% 10! = 0):
rem = (n% 10)
calcProduct (n / 10, (rem * producto))

calcProduct (123456,1)

Compile esto en línea

Si estás obligado a hacerlo con recursividad entonces,

def product (n, p): return (int (str (n) [0]) * product (int (str (n) [1:]), p) if len (str (n))> 1 más n * pags)
imprimir (producto (1213, 1))

Es una solución corta y elegante.

O

def product (n, p): num = str (n); return (int (num [0]) * product (int (num [1:]), p) if len (num)> 1 más n * p)
imprimir (producto (1213, 1))

Pero personalmente no recomendaré ninguno de estos.

Una mejor solución que la recursividad anterior sería:

del operador import mul
def product (n): return reduce (mul, [int (x) para x en str (n)], 1)
imprimir (producto (1213))

Es bastante simple de entender. Convierta el número en cadena y cada carácter es su dígito. Simplemente aplique reduce a él usando el operador de multiplicación. Esto es mucho más eficiente.

Ahora bien, esto es lo que se llama un uso efectivo de python.

¿Por qué usar la recursividad cuando puedes hacerlo en un solo ciclo while?

vacío principal()
{
int producto = 1; i = 12345
mientras que (i> 0)
{
producto = producto * (i% 10);
i = i / 10;
}
printf (“% d”, producto);
}

No se Python.
Aquí está el algoritmo general:

Encuentra no. de dígitos en el entero (supongo que solo se trata de enteros).

En Excel, por ejemplo, esto es -> len (su número entero) [No, no necesita convertirlo a texto primero.]

Di la longitud = n.

Definir p = 1.

Para i = 1 a n, multiplique p con el i-ésimo dígito (el i-ésimo carácter , si piensa en el entero como una cadena de texto de sus dígitos).

es decir, para i = 1 a n,

p = p X value (mid (su número entero, i, 1)) [En Excel. Porque de nuevo, siendo un llamado MBA ahora, no recuerdo muchos lenguajes de programación más allá de Excel y VBA.]

Allí. El valor final de p es su producto.

No conozco Python, pero en C / Java esto puede ser como sigue:

int product_of_digits (int n)

{

int producto = 1;
si (n == 0)
retorno 1;
más
{
producto * = n% 10;
producto * = producto_de_dígitos (n / 10);
producto devuelto;

}

}