calculadora por jerarquia ()*/+- ...C#...

[clipto]

es una calculadora basica lo unico que hace es operaciones por jerarquia como las calculadoras de mano donde primero resuelve las operaciones dentro de los parentesis en su orden de jerarquia */+- y asi va destruyendo parentesis hasta desmenusar todo lo digitado, para mayor funcionalidad lee toda la expresion de una vez.

orden primero las multiplciaiciones y diviciones y luego las sumas y las resta



codigo

Código [Seleccionar] Expandir


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace comienzo
{
   class parte3
   {
       
       public void imprimir(string [] operacion)
       {
           /*Console.Clear();
           byte posx = 5;
           for (int i = 0; i <= 19; i++)
           {
               Console.SetCursorPosition(posx, 6); Console.WriteLine(operacion[i]);
               posx += 1;
           }*/

           Console.SetCursorPosition(18,6); Console.WriteLine("Resultado = " + operacion[1]);
           Console.ReadKey();
       }///fin  public void imprimir
     
   }

   class partedos
   {
     

       public void buscaresp(byte pcdo, byte pato, string[] operacion)///busca los espacion dentro del parentesis
       {
           string cambio;
           pcdo -= 2;
           
           for (; pato <= pcdo; pato++) ////for 1-3
           {
               if (operacion[pato] == " ")////if 1-3
               {
                    pato += 2;
                    cambio = operacion[pato];
                    pato -= 2;
                    operacion[pato] = cambio;
                    pato += 2;
                    operacion[pato] = " ";
                    pato -= 2;
               }///fin if 1-3
           }////fin for 1-3

           

           //Console.WriteLine(operacion[2]);
       
       }///fin buscaresp


       public void organiza(byte pcdo, byte pato, string[] operacion)////organiza toda la expresion quitando los espacios en blanco
       {
           byte ultimo = 0; string cambio; byte posb =0;
           pcdo = 19;
           while (pcdo >= 1)
           {
               ultimo = pcdo;
               while (ultimo >= 1)
               {
                   posb = Convert.ToByte(ultimo - 1);
                   if (posb != 255)
                   {
                       while ( ((posb != 255) &&(posb >= 0) ) && (operacion[posb] == " ") )
                       {
                           cambio = operacion[ultimo];
                           operacion[posb] = cambio;
                           operacion[ultimo] = " ";
                           posb--;
                       }///fin while que bsuca las posiciones vacias
                   }
                   ultimo--;

               }///fin while que busca desde el ultimo      

               pcdo--;
           }///fin pcdo

          // Console.WriteLine(operacion[2]);
       }///fin opublic void organiza

       
       public void parentesis (string [] operacion, byte pfin)
       {
           byte abierto = 0, pcdo = 0, pato = 0,a,b,k,contar;  ///k revisa la operacion antes del aprentesis
           double x=0, y=0, resultado=0;
           partedos organizar = new partedos();
           partedos acomodar = new partedos();

           while(abierto==0)///while1---crear un siclo que busque lso parentesis si no los hay coloca el abierto en 0
           {
               for (byte i = 0; i <=pfin ; i++)///for que recorre////cambiar por un while
               {
                   if ( (operacion[i] == "(") )//if-1
                   {
                       pato = i; pcdo = i; pcdo += 1;
                       while( (operacion[pcdo] !="(") && (operacion[pcdo]!=")"))//while que busca la termiancion dle aprentesis
                       {
                           pcdo += 1;
                       }///fin while que bsuca la termiancion del aprentesis

                       if (operacion[pcdo] != "(")
                       {
                           byte j=Convert.ToByte (pato + 1);
                           for (; j <= pcdo;j++ )///for-2 como primeor se realizan las * & / hago este for
                           {
                               if (operacion[j] == "*")//if-2
                               {
                                   a = j; b = j;
                                   a -= 1; b += 1;
                                   x = Convert.ToDouble(operacion[a]); y = Convert.ToDouble(operacion[b]);
                                   resultado = x * y;

                                   //// ahora escribo el resultado en la posicion  anteriro al asterisco
                                   //// & borro las otras dos posiciones                            /**/
                                   /**/ a = j; b = j;                                              /**/
                                   /**/ a -= 1; b += 1;                                           /**/
                                   /**/ operacion[a] = Convert.ToString(resultado);              /**/
                                   /**/ operacion[j] = " "; operacion[b] = " ";                 /**/
                                   ////////////////////////////////////////////////////////////////
                                   j = a;
                                   organizar.buscaresp(pcdo, pato, operacion);
                                   acomodar.organiza(pcdo, pato, operacion);
                                   pcdo -= 2;
                               }//fin if-2
                               else
                               {
                                   if (operacion[j] == "/")//if-3
                                   {
                                       a = j; b = j;
                                       a -= 1; b += 1;
                                       x = Convert.ToDouble(operacion[a]); y = Convert.ToDouble(operacion[b]);
                                       resultado = x / y;

                                       //// ahora escribo el resultado en la posicion  anteriro al asterisco
                                       //// & borro las otras dos posiciones                            /**/
                                       /**/ a = j; b = j;                                              /**/
                                       /**/ a -= 1; b += 1;                                           /**/
                                       /**/ operacion[a] = Convert.ToString(resultado);              /**/
                                       /**/ operacion[j] = " "; operacion[b] = " ";                 /**/
                                       ////////////////////////////////////////////////////////////////
                                       j = a;
                                       organizar.buscaresp(pcdo, pato, operacion);
                                       acomodar.organiza(pcdo, pato, operacion);

                                       pcdo -= 2;
                                   }//fin if-3
                                   
                               }///fin else que em conduce a la divicion
                               
                           
                           }///fin for-2
                            ///



                           ////////////////operaciones segundarias
                           j = Convert.ToByte(pato + 1);
                           for (; j <= pcdo; j++)///for-3 con este for realizo las operaciones segundarias
                           {
                               if (operacion[j] == "+")//if-4
                               {
                                   a = j; b = j;
                                   a -= 1; b += 1;
                                   x = Convert.ToDouble(operacion[a]); y = Convert.ToDouble(operacion[b]);
                                   resultado = x + y;

                                   //// ahora escribo el resultado en la posicion  anteriro al asterisco
                                   //// & borro las otras dos posiciones                            /**/
                                   /**/ a = j; b = j;
                                   /**/ a -= 1; b += 1;                                           /**/
                                   /**/ operacion[a] = Convert.ToString(resultado);              /**/
                                   /**/ operacion[j] = " "; operacion[b] = " ";                 /**/
                                   ////////////////////////////////////////////////////////////////
                                   j = a;
                                   organizar.buscaresp(pcdo, pato, operacion);
                                   acomodar.organiza(pcdo, pato, operacion);
                                   pcdo -= 2;
                               }//fin if-4
                               else
                               {
                                   if (operacion[j] == "-")//if-5
                                   {
                                       a = j; b = j;
                                       a -= 1; b += 1;
                                       x = Convert.ToDouble(operacion[a]); y = Convert.ToDouble(operacion[b]);
                                       resultado = x - y;

                                       //// ahora escribo el resultado en la posicion  anteriro al asterisco
                                       //// & borro las otras dos posiciones                            /**/
                                       /**/ a = j; b = j;                                              /**/
                                       /**/ a -= 1; b += 1;                                           /**/
                                       /**/ operacion[a] = Convert.ToString(resultado);              /**/
                                       /**/ operacion[j] = " "; operacion[b] = " ";                 /**/
                                       ////////////////////////////////////////////////////////////////
                                       j = a;
                                       organizar.buscaresp(pcdo, pato, operacion);
                                       acomodar.organiza(pcdo, pato, operacion);
                                       pcdo -= 2;
                                   }//fin if-5

                               }///fin else que em conduce a la divicion


                           }///fin for-2
                           ///


                           ///////////////fin for-3
                           if (pato >= 1)
                           {
                               k = Convert.ToByte(pato - 1);
                               if (operacion[k] == "+" || operacion[k] == "(" || operacion[k] == ")" || operacion[k] == "-" || operacion[k] == "*" || operacion[k] == "/")
                               {
                                   operacion[pato] = " "; operacion[pcdo] = " ";
                                   acomodar.organiza(pcdo, pato, operacion);

                               }
                               else
                               {
                                   operacion[pato] = "*"; operacion[pcdo] = " ";
                                   acomodar.organiza(pcdo, pato, operacion);
                               }
                           }///fin pto>=1
                             
                              //Console.SetCursorPosition(15, 12); Console.WriteLine(operacion[0]);
                           contar=0;
                           for (int z = 0; z <= 19; z++)///for que busca haber cuantos parentesis hay
                           {
                               if (operacion[z] == "(")
                               {
                                   contar++;
                               }
                           }///fin for que busca haber cuantos parentesis hay

                           if (contar == 1)  abierto = 1;

                       }///fin si del parentesis != abierto
                        ///


                       ///como termino las operaciones dentro de los parentesis los borro
                       
                   }///fin if-1
               }///fin for que recorre
           }///fin while1

       }///fin public void parentesis
   
   }///fin class partedos

   class parteuno
   {
       static void Main(string[] args)
       {
           Console.Title = ("calculadora jerarquica----Clipto");
           string [] operacion = new string[23];
           byte pos = 1,pfin=0;
           string temp1,temp2=" ";
           partedos enviar = new partedos();
           parte3 final = new parte3();

           operacion[0] = "("; operacion[19] = ")";

           do
           {
               temp1 = Convert.ToString(Console.ReadKey().KeyChar);

               if (temp1 != "\r")
               {
                   if (temp2 == " ")
                   {

                       if (temp1 == "+" || temp1 == "(" || temp1 == ")" || temp1 == "-" || temp1 == "*" || temp1 == "/")
                       {
                           operacion[pos] = temp1;
                           pos++;

                       }
                       else
                       {
                           operacion[pos] = operacion[pos] + temp1;
                       }

                   }///fin temp2==" "
                   else
                   {
                       if (temp1 == "+" || temp1 == "(" || temp1 == ")" || temp1 == "-" || temp1 == "*" || temp1 == "/")
                       {
                           if (temp2 == "+" || temp2 == "(" || temp2 == ")" || temp2 == "-" || temp2 == "*" || temp2 == "/")
                           {
                               operacion[pos] = temp1;
                               pos++;
                           }
                           else
                           {
                               pos++; operacion[pos] = temp1; pos++;
                           }

                       }
                       else
                       {
                           operacion[pos] = operacion[pos] + temp1;
                       }
                   }//fin else de temp2==" "


               }///fin temp1 != /r
               else
               {
                   pfin = pos;
               }

               temp2 = Convert.ToString(Console.ReadKey().KeyChar);
               if (temp2 != "\r")
               {
                   if (temp2 == "+" || temp2 == "(" || temp2 == ")" || temp2 == "-" || temp2 == "*" || temp2 == "/")
                   {
                       if (temp1 == "+" || temp1 == "(" || temp1 == ")" || temp1 == "-" || temp1 == "*" || temp1 == "/")
                       {
                           operacion[pos] = temp2;
                           pos++;
                       }
                       else
                       {
                           pos++; operacion[pos] = temp2; pos++;
                       }

                   }
                   else
                   {
                       operacion[pos] = operacion[pos] + temp2;
                   }


               }///fin temp2 != /r
               else
               {
                   pfin = pos;
               }

           } while ((pos < 19) && (temp1 != "\r") && (temp2 != "\r"));

          /* Console.SetCursorPosition(2, 4);Console.WriteLine(" ------ ");
           for (int i = 0; i <= 9; i++)
           {
               
               Console.WriteLine(operacion[i]);

           }*/


           enviar.parentesis(operacion,pfin);
           final.imprimir(operacion);

           Console.Clear();
           byte posx = 5;
           for (int m = 0; m <= 19; m++)
           {
               Console.SetCursorPosition(posx, 6); Console.WriteLine(operacion[m]);
               posx += 1;
           }
           //Console.ReadKey();
       }///fin main
   }///fin class
}///fin namespace



Nota: para hacerlo ultilice vectores no se me ocurrio +nada, si alguien sabe de otro metodo me comenta

[Meta]

Interesante.

¿Sabes ahcerlo en modo Visual?

Saludo.

[raul338]

   

interesante, justo tenia que armarme una de estas, pero no que resuelva, sino que simplemente devuelva variables boleanas. (Seria como comprobar la formula SI de excel, solo que en lugar de celdas, hay variables  )

[clipto]

Interesante.

¿Sabes ahcerlo en modo Visual?

Saludo.

es casi lo mismo si le colocas un modo grafico seria tener unos botones como los que tiene la calc de windows u otra, y lo que vas ahcer es que en partes como

temp1 = Convert.ToString(Console.ReadKey().KeyChar);

dices que temp1 es igual ala tecla a la cual se le hizo click asi mismo sera con temp2 solo tienes que organizar eso, y como maneja vectores el proceso seria el mismo osea se deja igual, para el resultado o las partes donde imprime ejemplo

Console.SetCursorPosition(18,6); Console.WriteLine("Resultado = " + operacion[1]);
            Console.ReadKey();

dises que limpie la caja de texto y que coloque ahi el resultado solamente

[h0oke]

Para hacerlo en modo visual, no bastaría con leer el contenido en una caja de texto?

[raul338]

Para hacerlo en modo visual, no bastaría con leer el contenido en una caja de texto?

no porque el codigo va leyendo cada caracter que se ingresa y va armando la esctructura (o al menos eso veo a simple vista, no lo probe ni lo vi bien todavia, es dificil ver e imaginar exactamente como funciona el codigo estando en blanco y negro xD xD). el "do" que esta en el void Main se tendria que poner en otro bucle que vaya recorriendo letra x letra de un textbox (aunque es algo arreglado con alambres xD, lo mejor seria rehacer eso en una clase utilzable, aunque seria mas costoso creo  )

[clipto]

pues tambien lo podrias hacer, lo que hace este en modo consola es que cada cosa que se digite la guarde en una posicion de un vector, para asi trabajar en segundo plano y empezar a resolver desde el parentesis mas interno al mas externo teniendo en cuenta la jerarquia de signos */+-, por eso le plante a Meta qeu podia hacerlo asi y no tenia que hacer tantas modificaciones del codigo fuente

[h0oke]

Para hacerlo en modo visual, no bastaría con leer el contenido en una caja de texto?

no porque el codigo va leyendo cada caracter que se ingresa y va armando la esctructura (o al menos eso veo a simple vista, no lo probe ni lo vi bien todavia, es dificil ver e imaginar exactamente como funciona el codigo estando en blanco y negro xD xD). el "do" que esta en el void Main se tendria que poner en otro bucle que vaya recorriendo letra x letra de un textbox (aunque es algo arreglado con alambres xD, lo mejor seria rehacer eso en una clase utilzable, aunque seria mas costoso creo  )

:O Disculpa, no he visto el código.

:S Primera vez que oigo un método así. ¿No sería mejor colocar toda la expresión ingresada, en "stack" y luego ir analizando?

[clipto]

no se, la verdad primera ves que escucho de stack solo soy un newbie y vi este reto en un foro donde se debia hacer esta calculadora desde cero con las cosas basicas que uno conoce sin ultilizar funciones del lenguaje donde se trabaje & quise hacerlo con las cosas basicas que conocia, pero te propongo que plantees el metodo para analizarlo, y ver como funciona por dentro, y tratar de generar uno igual.

[raul338]

depende a que te refieres con "stack" (la clase generica? o a la memoria en si xD, como "heap") si es en la clase, si seria lo mismo a la alternativa que mencione yo.

no se, la verdad primera ves que escucho de stack solo soy un newbie y vi este reto en un foro donde se debia hacer esta calculadora desde cero con las cosas basicas que uno conoce sin ultilizar funciones del lenguaje donde se trabaje & quise hacerlo con las cosas basicas que conocia, pero te propongo que plantees el metodo para analizarlo, y ver como funciona por dentro, y tratar de generar uno igual.

es un reto??? xD yo tengo que hacer uno igual, este me sirve a medias   (sin ofender, pero no es lo que busco). A mi se me ocurrio usar expresiones regulares, pero seria muuuy larga la expresion, asi que probare. Igual posteare el codigo