Nullable Blog [Ignoranto.Info]

Vamos a ver dos maneras de programar una simple calculadora:

• 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