javascript - recursiva - recursividad ejemplos

Sustracción de recursión de Javascript

Question

Ejemplo 1

function x(num) {
if (num == 0) {
return 1;
}
else {
return (num * x(num - 1));
}
}
x(8);

8 * 7 * 6 * 5 * 4 * 3 * 2 * 1

El resultado es 40320 como se esperaba.

Ejemplo 2

function x(num) {
if (num == 0) {
return 0;
}
else {
return (num + x(num - 1));
}
}
x(8);

8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0

El resultado es 36 como se esperaba

Ejemplo 3

function x(num) {
if (num == 0) {
return 0;
}
else {
return (num - x(num - 1));
}
}
x(8);

8 - 7 - 6 - 5 - 4 - 3 - 2 - 1 - 0

El resultado es 4

¿Alguien puede explicar por qué?

¿No debería ser la respuesta -20?

Answer 1

¿Por qué no -20 y la resta no comienza a partir del 8? debido a que la función está en bucle a través de todos esos números, después de alcanzar 0 Función al principio de la resta. Pero antes de que todas las funciones hagan x(num - 1) operación. Simplemente puede resolverlo con 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 cuya función es multiplicar primero 2 * 1 = 2 y luego 2 * 3 = 6 luego 6 * 4 ...

Answer 2

Como otros respondieron, la resta se está haciendo al revés, de derecha a izquierda:

x = 8-7-6-5-4-3-2-(1-0)
x = 8-7-6-5-4-3-(2-1)
x = 8-7-6-5-4-(3-1)
x = 8-7-6-5-(4-2)
x = 8-7-6-(5-2)
x = 8-7-(6-3)
x = 8-(7-3)
x = (8-4)
x = 4

Lo que está buscando es una inversa de la adición, que podría escribirse de la siguiente manera:

function addition(num) {
if (num == 0) {
return 0;
}
else {
return (num + addition(num - 1));
}
}
function subtraction(num) {
return num - addition(num - 1);
}

Llamar a la resta (8) produciría -20, porque está restando la suma de todos los números menores, mientras que su función original restó todos los números menores entre sí.

Answer 3

Debido a que su función es efectivamente calcular de derecha a izquierda:

8 - (7 - (6 - (5 - (4 - (3 - (2 - (1 - 0))))))) => 4

Y no:

8 - 7 - 6 - 5 - 4 - 3 - 2 - 1 - 0 => -20

Answer 4

El cálculo con su función básicamente va de derecha a izquierda:

 8 - 7 - 6 - 5 - 4 - 3 - 2 - 1 - 0
= 8 - 7 - 6 - 5 - 4 - 3 - 2 - 1
= 8 - 7 - 6 - 5 - 4 - 3 - 1
= 8 - 7 - 6 - 5 - 4 - 2
= 8 - 7 - 6 - 5 - 2
= 8 - 7 - 6 - 3
= 8 - 7 - 3
= 8 - 4
= 4

Esto se debe a que cada vez que se llama recursivamente a la función x , se intenta evaluar la expresión más a la derecha.

Efectivamente, la "pila" se ve así:

 8 - x(8 - 1)
= 8 - (7 - x(7 - 1))
= 8 - (7 - (6 - x(6 - 1)))
= 8 - (7 - (6 - (5 - x(5 - 1))))
= 8 - (7 - (6 - (5 - (4 - x(4 - 1)))))
= 8 - (7 - (6 - (5 - (4 - (3 - x(3 - 1))))))
= 8 - (7 - (6 - (5 - (4 - (3 - (2 - x(2 - 1)))))))
= 8 - (7 - (6 - (5 - (4 - (3 - (2 - (1 - x(1 - 1))))))))
= 8 - (7 - (6 - (5 - (4 - (3 - (2 - (1 - 0)))))))
= 8 - (7 - (6 - (5 - (4 - (3 - (2 - 1))))))
= 8 - (7 - (6 - (5 - (4 - (3 - 1)))))
= 8 - (7 - (6 - (5 - (4 - 2))))
= 8 - (7 - (6 - (5 - 2)))
= 8 - (7 - (6 - 3))
= 8 - (7 - 3)
= 8 - 4
= 4

La evaluación de JavaScript para una resta "pura" es:

8 - 7 - 6 - 5 - 4 - 3 - 2 - 1 - 0; // -20

Answer 5

La ecuación 8-7-6-5-4-3-2-1-0 escrita con recursión debe tener algo que repetir. 8 no es parte de él porque no lo resta. Así que deberías hacer algo como:

= 8 + ( "recursion starting from 7")
= 8 + ( -7 + "recursion starting from 6")
...
= 8 + ( -7 + -6 + -5 + -4 + -3 + -2 + "recursion starting from 1")
= 8 + ( -7 + -6 + -5 + -4 + -3 + -2 + -1 + "recursion starting from 0")
= 8 + ( -7 + -6 + -5 + -4 + -3 + -2 + -1 + -0 /* end case */ )

El código sería algo así como

 function x(num, first){
if (first){
return num + x(num-1, false);
} else if (num > 0){
return -num + x (num-1, false);
} else {
return 0;
}
}

Answer 6

La primera resta de su recursión comienza con los dos últimos números y corre hacia atrás:

x = 8-7-6-5-4-3-2-(1-0)
x = 8-7-6-5-4-3-(2-1)
x = 8-7-6-5-4-(3-1)
x = 8-7-6-5-(4-2)
x = 8-7-6-(5-2)
x = 8-7-(6-3)
x = 8-(7-3)
x = (8-4)
x = 4

Answer 7

Para elaborar en mi comentario ...

La resta (a diferencia de la multiplicación y la suma, que explica por qué funcionan otros ejemplos) no es conmutativa, y la evaluación de JavaScript es de izquierda a derecha, mientras que su función lo hace de derecha a izquierda.

Para obtener el resultado correcto con su código existente, puede usar el hecho de que una resta es una suma de un número negativo. En la cadena, solo el número más a la izquierda es positivo. Reutilizando su función de suma :

function sub(num) {
return num - sum(num - 1)
}

Una solución de función única puramente recursiva requeriría un argumento adicional para saber dónde detenerse (a partir de cero) o para crear un caso especial para la primera llamada (sumar en lugar de restar, excepto esa primera llamada).

Por supuesto, si no le importa hacer trampa con aritmética, puede linealizarse para

function sub(num){ return num - (num*(num-1)/2) }