• La primera: Una calculadora recursiva que Suma, Resta, Multiplica y Divide pero sin hacer uso de pilas de procesos (operaciones pendientes).
• La segunda: Una calculadora recursiva que solo Suma y Resta haciendo uso de operaciones pendientes (manteniendo una pila en espera).

Primero…

¿Qué es la recursividad?

Para saber que es la recursividad primero necesitamos saber que es la recursividad!

Una función o método recursivo es aquel que se invoca a si mismo (en alguna parte de su código éste hace llamado a si mismo) y depende de una condición propia para continuar invocándose o terminar el proceso y retornar un valor.

Ejemplo: Mostrar N numeros mayores a 0 de manera recursiva

int algoRecursivo(int n)
{
  Console.WriteLine(n);
  if (n > 0) { return algoRecursivo(n-1); }
  else { return 0; }
 }

Con ello mostramos los números y preguntamos si N es mayor que 0, si se cumple esa condicion volvemos a llamar a la misma funcion pero le entregamos el valor de N-1, sino retornamos 0, y como 0 no es mayor que 0, la recursividad termina!

Calculadorita que… Suma, resta, multiplica y divide!

Nuestra calculadora recursiva!

Éste método (función o procedimiento) recursivo (recurrente) recibe 1 parámetro para empezar su recurrencia y procesa de la siguiente manera…

• Se recibe un número entero >> N
• Se pregunta por un operador de tipo char ( ‘+’, ‘*’, ‘-’, ‘/’ ) >> OP
• Si el operador ingresado es ‘=’ el método devuelve el número recibido >> N
• Sino, se pregunta por un número entero >> NU
• Iniciamos un conmutador (switch) con la variable OP
• Caso ‘+’, si OP es + entonces RESP será N+NU;
• Caso ‘-’, si OP es – entonces RESP será N-NU;
• Caso ‘*’, si OP es * entonces RESP será N*NU;
• Caso ‘/’, si OP es /, si NU es diferente de 0, entonces RESP será N/NU; sino RESP será N y mostraremos error de división entre cero;
• Fin del conmutador
• Mostramos el resultado >> RESP
• El método se llama a si mismo (recursividad) enviándose el resultado >> RESP

La recursividad del método termina cuando el caracter ingresado es ‘=’, ya que retorna un valor y no hace recurrencia (no se vuelve a llamar a si mismo), el código del método es el siguiente:

static int calc(int n)
{
 int resp = 0;
 Console.Write("Operador > ");
 char op = char.Parse(Console.ReadLine());
 if (op == '=') return n;
 else
 {
   Console.Write("Numero  -> ");
   int nu = int.Parse(Console.ReadLine());
   switch (op)
   {
      case '+': resp = n + nu; break;
      case '-': resp = n - nu; break;
      case '*': resp = n * nu; break;
      case '/': if (nu != 0) { resp = n / nu; }
                else { errorCero(); resp = n; };
                break;
      default: Console.WriteLine("Operador desconocido"); resp = n; break;
   }
   Console.WriteLine("Respuesta: {0}", resp);
   Console.Beep(1760, 200);
   return calc(resp);
 }
}

El método errorCero(); no retorna ningun valor pero si muestra “un error” demasiado llamativo , llamamos a éste metodo cuando se produce una división entre 0!

Podemos encontrar todo el código listo para compilar en ésta direccion >> Calculadora Recursiva C#; necesitamos Visual Studio, MonoDevelop o algun compilador de C# para poder compilar el código!

Calculadorita con uso de Stack (operaciones pendientes)

Otra forma de hacer una calculadora recursiva es mediante stack (pilas de operaciones pendientes), de esta forma la calculadora solo funcionaría correctamente con Suma y Resta, ya que si mantenemos en stack la multiplicacion y división los resultados no serían los esperados (ya que operaría de atras hacia delante y no como debería ser), el algoritmo recursivo es el siguiente:

static int recur(int n)
{
  Console.Write("OP: ");
  char oo = char.Parse(Console.ReadLine());
  if (oo == '=') { return n; }
  else
  {
    Console.Write("N : ");
    int nn = int.Parse(Console.ReadLine());
    switch (oo)
    {
     case '+': return n + recur(nn);
     case '-': return n - recur(nn);
     default:
       Console.WriteLine("Esta calculadora solo Suma y Resta");
       return recur(n);
    }
  }
}

Con este otro algoritmo recursivo mantenemos “en espera” el resultado de recur(nn), cuando recur(nn) devuelva un valor, recién operaremos dicho resultado. Si aplicamos esta recursión con operaciones de multiplicación y división, dichas operaciones se ejecutarian en orden inverso y los resultados no serían verídicos!

Puedes conseguir este otro código listo para compilar aquí > Otra Calculadora Recursiva

Importante: Estas NO SON las únicas forma de hacer calculadoras recursivas, existen muchas formas el problema es descubrirlas

1+(4*(7-2))

¿Cómo harías para extraer los valores de los últimos parentesis?
No es muy dificil, primero necesitamos saber la ULTIMA posición del ULTIMO parentesis de APERTURA! » ” ( ” y luego saber la PRIMERA posición del PRIMER paréntesis de CIERRE! » ” ) “;

Y … ¿Cómo lo hago?
En PHP tenemos la función STRPOS que nos devuelve la posición de cualquier caracter que busquemos dentro de una cadena de texto. Tenemos también STRRPOS (nótese de una R adicional) que nos devuelve la última posición de un caracter en particular!

// ejemplo
$txt =
 "a(b(c))";
//0123456 las posiciones del texto!
echo $p01 = strpos ( $txt, ")" ); // nos devuelve 5
echo $p02 = strrpos( $txt, "(" ); // nos devuelve 3

Con el ejemplo anterior hacemos que PHP nos muestre la posición de los parentesis () que están dentro de los otros parentesis ()!

Ahora extraeremos el contenido de dichos paréntesis!

// ejemplo
$txt =
 "a(b(c))";
//0123456 las posiciones del texto!
echo $p01 = strpos ( $txt, ")" ); // nos devuelve 5
echo $p02 = strrpos( $txt, "(" ); // nos devuelve 3
// substr (texto, posicion, ncaracteres)
// $p02 - $p01 nos da la longitud de cadena a extraer!
// $p02 es 3, entonces comenzará a extraer desde la pos 3
// $p01 es 5, pero solo queremos 1 caracter!
echo substr ( $txt, $p02 , $p01-$p02);
// para solo extraer la letra C, seria asi:
echo substr ( $txt, $p02+1 , $p01-$p02-1);

Eso es todo! ahora a probar! Como es sabido, todo esto se encuentra aquí; lamentablemente por ahora no encuentro la manera de descargar el código PHP, pronto implementaré algun script para poder descargar el código PHP contenido en develop.ignoranto.info!

El problema Syracuse o Conjetura de Collatz es una función recursiva y las condiciones son las siguientes:

Si N es par, lo dividimos [N/2];
Si N es impar, lo multiplicamos por 3 y sumamos +1 [3N+1];

Siendo N un numero entero positivo; es necesario que N sea un numero entero positivo ya que si fuese real (con coma decimal) nuestro ordenador no podría saber si es “par o impar” debido a que una de las formas de saber si un número es par o impar es mediante el “módulo” el cual halla el residuo de una división, si el residuo de N y 2 es 0, entonces N es par!.

Comencemos:
Necesitamos crear una funcion recursiva, nuestra función se llamará syr(), el parámetro de entrada es una variable de tipo entero (por que si fuera double o float simplemente no existiría el módulo (residuo)), obviamente nuestra función syr() devuelve un valor entero!

Si N es 1, retornamos 1;
Sino, Si el módulo (residuo) de N y 2 es 0, retornamos N/2;
Sino, retornamos 3*N+1;

Veamos lo que pasa si N valiese 5:
5 % 2 == 0 ?? NO!
entonces >> n = 3*5 + 1, [n = 16];
16% 2 == 0 ?? SI!
entonces >> n = 16/2, [n = 8];
8% 2 == 0?? SI!
entonces >> n = 8/2, [n = 4];
4 % 2 == 0?? SI!
entonces >> n = 4/2, [n = 2];
2%2 == 0?? SI!
entonces >> n = 2/2. [n= 1]
1 == 1?? SI!
Fin de la secuencia, llegamos a 1!

EN PHP sería de la siguiente manera:

syr($n)
{
  echo $n; //mostramos $n
  if ($n == 1) //si $n es 1, devolvemos 1
    return 1;
  else //sino ...
  {
    if ($n%2 == 0) // si es par
      return syr($n/2); // lo dividimos
    else //sino
      return syr(3*n+1); // multiplicamos por 3 y sumamos 1;
  }
}

El código ignoranto tiene el algoritmo escrito en C# y PHP; también podemos probar la Serie de Syracuse solo con números enteros menores de 1e5 (sino se sobre carga el server)!

Caminar ()
{
 Mientras (direccion exista)
 {
   si (pie izquierdo esta delante)
   {
     pie derecho avanzar;
   }
   sino
   {
      pie izquierdo avanzar;
   }
 }
}

Con este algoritmo podemos avanzar siempre y cuando tengamos una dirección de destino!