SHARE
TWEET

Untitled

a guest Feb 17th, 2019 64 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. namespace Tecuceanu_Esprressione
  2. {
  3.     public partial class Form1 : Form
  4.     {
  5.         static string Trovaparentesi(string espressione)
  6.         {
  7.             int posizioneparentesiaperta = 0, posizioneparentesichiusa = 0;
  8.             string contenutoparentesi = "";
  9.             for (int i = espressione.Length - 1; i >= 0; i--)
  10.             {
  11.                 if (espressione[i] == '(')
  12.                 {
  13.                     posizioneparentesiaperta = i;
  14.                     break;
  15.                 }
  16.             }
  17.             posizioneparentesichiusa = espressione.IndexOf(')', posizioneparentesiaperta);
  18.             contenutoparentesi = espressione.Substring(posizioneparentesiaperta , posizioneparentesichiusa - posizioneparentesiaperta+1 );
  19.  
  20.             return contenutoparentesi;
  21.         }
  22.         public string Pdpm(string contenuto)
  23.         {
  24.             int operazioniprimarie = 0, operazionisecondarie = 0, operazioni = 0;
  25.             for (int i = 0; i < contenuto.Length; i++)
  26.             {
  27.  
  28.                 if (contenuto[i] == '/' || contenuto[i] == '*')
  29.                 {
  30.                     operazioniprimarie++;
  31.                 }
  32.                 if (contenuto[i] == '+' || contenuto[i] == '-')
  33.                 {
  34.                     operazionisecondarie++;
  35.                 }
  36.             }
  37.             operazioni = operazioniprimarie + operazionisecondarie;
  38.             int indicediviso = 0, indiceper = 0,indicepiù=0,indicemeno=0;
  39.             int primadelsimbolo = 0, dopodelsimbolo = 0;
  40.             double risultatodiviso = 0;
  41.             string contenutoprima = "", contenutodopo = "", contrario = "", contenutod = "";
  42.             char[] simboli = new char[] { '+', '*', '/', '-', '(', ')' };
  43.             if (operazioni > 0)
  44.             {
  45.                 if (operazioniprimarie > 0)
  46.                 {
  47.                     for (int i = 0; i < contenuto.Length; i++)
  48.                     {
  49.                         if (contenuto[i] == '/')
  50.                         {
  51.                             indicediviso = i;
  52.                             break;
  53.                         }
  54.                         if (contenuto[i] == '*')
  55.                         {
  56.                             indiceper = i;
  57.                             break;
  58.                         }
  59.                     }
  60.                     if (indicediviso == 0) { indicediviso = indiceper + 1; }
  61.                     if (indiceper == 0) { indiceper = indicediviso + 1; }
  62.                     if (indicediviso < indiceper)
  63.                     {
  64.                         for (int i = indicediviso - 1; i >= 0; i--)
  65.                         {
  66.                             for (int j = 0; j < 5; j++)
  67.                             {
  68.                                 if (contenuto[i] == simboli[j])
  69.                                 {
  70.                                     primadelsimbolo = i;
  71.                                     break;
  72.                                 }
  73.                                 if (primadelsimbolo != 0)
  74.                                 {
  75.                                     break;
  76.                                 }
  77.                             }
  78.  
  79.  
  80.                         }
  81.                         for (int i = indicediviso + 1; i < contenuto.Length; i++)
  82.                         {
  83.                             for (int j = 0; j <= 5; j++)
  84.                             {
  85.                                 if (contenuto[i] == simboli[j])
  86.                                 {
  87.                                     dopodelsimbolo = i;
  88.                                     break;
  89.                                 }
  90.                             }
  91.                             if (dopodelsimbolo != 0)
  92.                             {
  93.                                 break;
  94.                             }
  95.                         }
  96.                         for (int k = indicediviso + 1; k < dopodelsimbolo; k++)
  97.                         {
  98.                             contenutodopo = contenutodopo + contenuto[k];
  99.  
  100.                         }
  101.                         if (contenutodopo.Length == 1) { contenutod = contenutodopo; }
  102.                         else
  103.                         {
  104.                             for (int i = contenutodopo.Length; i > 0; i--)
  105.  
  106.                             {
  107.                                 contenutod = contenutod + contenutoprima[i - 1];
  108.                             }
  109.                         }
  110.                         for (int i = indicediviso - 1; i > primadelsimbolo; i--)
  111.                         {
  112.                             contenutoprima = contenutoprima + contenuto[i]
  113. ;
  114.                         }
  115.  
  116.                         for (int i = contenutoprima.Length; i > 0; i--)
  117.                         {
  118.                             contrario = contrario + contenutoprima[i - 1];
  119.                         }
  120.                         contenutoprima = contrario;
  121.                         contenutodopo = contenutod;
  122.                         primadelsimbolo = Convert.ToInt32(contenutoprima);
  123.                         dopodelsimbolo = Convert.ToInt32(contenutodopo);
  124.                         risultatodiviso = Convert.ToDouble(primadelsimbolo) / Convert.ToDouble(dopodelsimbolo);
  125.                         contrario = Convert.ToString(risultatodiviso);
  126.                         return contrario;
  127.                     }
  128.  
  129.                     else
  130.                     {
  131.                         for (int i = indiceper - 1; i >= 0; i--)
  132.                         {
  133.                             for (int j = 0; j < 5; j++)
  134.                             {
  135.                                 if (contenuto[i] == simboli[j])
  136.                                 {
  137.                                     primadelsimbolo = i;
  138.                                     break;
  139.                                 }
  140.                                 if (primadelsimbolo != 0)
  141.                                 {
  142.                                     break;
  143.                                 }
  144.                             }
  145.  
  146.  
  147.                         }
  148.                         for (int i = indiceper + 1; i < contenuto.Length; i++)
  149.                         {
  150.                             for (int j = 0; j <= 5; j++)
  151.                             {
  152.                                 if (contenuto[i] == simboli[j])
  153.                                 {
  154.                                     dopodelsimbolo = i;
  155.                                     break;
  156.                                 }
  157.                             }
  158.                             if (dopodelsimbolo != 0)
  159.                             {
  160.                                 break;
  161.                             }
  162.                         }
  163.                         for (int k = indiceper + 1; k < dopodelsimbolo; k++)
  164.                         {
  165.                             contenutodopo = contenutodopo + contenuto[k];
  166.  
  167.                         }
  168.                         if (contenutodopo.Length == 1) { contenutod = contenutodopo; }
  169.                         else
  170.                         {
  171.                             for (int i = contenutodopo.Length; i > 0; i--)
  172.  
  173.                             {
  174.                                 contenutod = contenutod + contenutoprima[i - 1];
  175.                             }
  176.                         }
  177.                         for (int i = indiceper - 1; i > primadelsimbolo; i--)
  178.                         {
  179.                             contenutoprima = contenutoprima + contenuto[i];
  180.                         }
  181.  
  182.                         for (int i = contenutoprima.Length; i > 0; i--)
  183.                         {
  184.                             contrario = contrario + contenutoprima[i - 1];
  185.                         }
  186.                         contenutoprima = contrario;
  187.                         contenutodopo = contenutod;
  188.                         primadelsimbolo = Convert.ToInt32(contenutoprima);
  189.                         dopodelsimbolo = Convert.ToInt32(contenutodopo);
  190.                         risultatodiviso = Convert.ToDouble(primadelsimbolo) * Convert.ToDouble(dopodelsimbolo);
  191.                         contrario = Convert.ToString(risultatodiviso);
  192.                         return contrario;
  193.                     }
  194.                 }
  195.                 //________________________________________________-------------------------------------________________
  196.                 else if (operazionisecondarie > 0)
  197.                 {
  198.                     for (int i = 0; i < contenuto.Length; i++)
  199.                     {
  200.                         if (contenuto[i] == '+')
  201.                         {
  202.                             indicepiù = i;
  203.                             break;
  204.                         }
  205.                         if (contenuto[i] == '-')
  206.                         {
  207.                             indicemeno = i;
  208.                             break;
  209.                         }
  210.                     }
  211.                     if (indicepiù == 0) { indicepiù = indicemeno + 1; }
  212.                     if (indicemeno == 0) { indicemeno = indicepiù + 1; }
  213.                     if (indicepiù < indicemeno)
  214.                     {
  215.                         for (int i = indicepiù - 1; i >= 0; i--)
  216.                         {
  217.                             for (int j = 0; j < 5; j++)
  218.                             {
  219.                                 if (contenuto[i] == simboli[j])
  220.                                 {
  221.                                     primadelsimbolo = i;
  222.                                     break;
  223.                                 }
  224.                                 if (primadelsimbolo != 0)
  225.                                 {
  226.                                     break;
  227.                                 }
  228.                             }
  229.  
  230.  
  231.                         }
  232.                         for (int i = indicepiù + 1; i < contenuto.Length; i++)
  233.                         {
  234.                             for (int j = 0; j <= 5; j++)
  235.                             {
  236.                                 if (contenuto[i] == simboli[j])
  237.                                 {
  238.                                     dopodelsimbolo = i;
  239.                                     break;
  240.                                 }
  241.                             }
  242.                             if (dopodelsimbolo != 0)
  243.                             {
  244.                                 break;
  245.                             }
  246.                         }
  247.                         for (int k = indicepiù + 1; k < dopodelsimbolo; k++)
  248.                         {
  249.                             contenutodopo = contenutodopo + contenuto[k];
  250.  
  251.                         }
  252.                         if (contenutodopo.Length == 1) { contenutod = contenutodopo; }
  253.                         else
  254.                         {
  255.                             for (int i = contenutodopo.Length; i > 0; i--)
  256.  
  257.                             {
  258.                                 contenutod = contenutod + contenutoprima[i - 1];
  259.                             }
  260.                         }
  261.                         for (int i = indicepiù - 1; i > primadelsimbolo; i--)
  262.                         {
  263.                             contenutoprima = contenutoprima + contenuto[i]
  264. ;
  265.                         }
  266.  
  267.                         for (int i = contenutoprima.Length; i > 0; i--)
  268.                         {
  269.                             contrario = contrario + contenutoprima[i - 1];
  270.                         }
  271.                         contenutoprima = contrario;
  272.                         contenutodopo = contenutod;
  273.                         primadelsimbolo = Convert.ToInt32(contenutoprima);
  274.                         dopodelsimbolo = Convert.ToInt32(contenutodopo);
  275.                         risultatodiviso = Convert.ToDouble(primadelsimbolo) + Convert.ToDouble(dopodelsimbolo);
  276.                         contrario = Convert.ToString(risultatodiviso);
  277.                         return contrario;
  278.                     }
  279.  
  280.                     else
  281.                     {
  282.                         for (int i = indicemeno - 1; i >= 0; i--)
  283.                         {
  284.                             for (int j = 0; j < 5; j++)
  285.                             {
  286.                                 if (contenuto[i] == simboli[j])
  287.                                 {
  288.                                     primadelsimbolo = i;
  289.                                     break;
  290.                                 }
  291.                                 if (primadelsimbolo != 0)
  292.                                 {
  293.                                     break;
  294.                                 }
  295.                             }
  296.  
  297.  
  298.                         }
  299.                         for (int i = indicemeno + 1; i < contenuto.Length; i++)
  300.                         {
  301.                             for (int j = 0; j <= 5; j++)
  302.                             {
  303.                                 if (contenuto[i] == simboli[j])
  304.                                 {
  305.                                     dopodelsimbolo = i;
  306.                                     break;
  307.                                 }
  308.                             }
  309.                             if (dopodelsimbolo != 0)
  310.                             {
  311.                                 break;
  312.                             }
  313.                         }
  314.                         for (int k = indicemeno + 1; k < dopodelsimbolo; k++)
  315.                         {
  316.                             contenutodopo = contenutodopo + contenuto[k];
  317.  
  318.                         }
  319.                         if (contenutodopo.Length == 1) { contenutod = contenutodopo; }
  320.                         else
  321.                         {
  322.                             for (int i = contenutodopo.Length; i > 0; i--)
  323.  
  324.                             {
  325.                                 contenutod = contenutod + contenutoprima[i - 1];
  326.                             }
  327.                         }
  328.                         for (int i = indicemeno - 1; i > primadelsimbolo; i--)
  329.                         {
  330.                             contenutoprima = contenutoprima + contenuto[i];
  331.                         }
  332.  
  333.                         for (int i = contenutoprima.Length; i > 0; i--)
  334.                         {
  335.                             contrario = contrario + contenutoprima[i - 1];
  336.                         }
  337.                         contenutoprima = contrario;
  338.                         contenutodopo = contenutod;
  339.                         primadelsimbolo = Convert.ToInt32(contenutoprima);
  340.                         dopodelsimbolo = Convert.ToInt32(contenutodopo);
  341.                         risultatodiviso = Convert.ToDouble(primadelsimbolo) - Convert.ToDouble(dopodelsimbolo);
  342.                         contrario = Convert.ToString(risultatodiviso);
  343.                         return contrario;
  344.                     }
  345.                 }
  346.             return contenutoprima;
  347.             }
  348.             string es = contenuto;
  349.             return es;
  350.         }
  351.        
  352.         public Form1(){
  353.             InitializeComponent();
  354.         }
  355.         private void lbltitolo_Click(object sender, EventArgs e){
  356.         }
  357.         private void txtespressione_TextChanged(object sender, EventArgs e){
  358.         }
  359.         private void lblerrore_Click(object sender, EventArgs e){
  360.         }
  361.         private void lblrisultato_Click(object sender, EventArgs e){
  362.         }
  363.         private void btnrisolvi_Click(object sender, EventArgs e)
  364.         {
  365.             string apoggio = "";
  366.             int contaparentesi = 0;
  367.             string espressione = txtespressione.Text;
  368.             apoggio = "(" + espressione + ")";
  369.             espressione = apoggio;
  370.             for (int i = 0; i < espressione.Length; i++)
  371.             {
  372.                 if (espressione[i] == '+'|| espressione[i] == '-' || espressione[i] == '*' || espressione[i] == '/' )
  373.                 {
  374.                     contaparentesi++;
  375.                 }
  376.             }
  377.             while (contaparentesi != 0)
  378.             {
  379.                 espressione = apoggio;
  380.                 apoggio = espressione;
  381.                 string contenutoparentesi = "";
  382.                 string contenuto = Trovaparentesi(espressione);
  383.                 string risultatoperazione = Pdpm(contenuto);
  384.                 int posizioneparentesiaperta = 0, posizioneparentesichiusa = 0;
  385.                 for (int i = espressione.Length - 1; i > 0; i--)
  386.                 {
  387.                     if (espressione[i] == '(')
  388.                     {
  389.                         posizioneparentesiaperta = i;
  390.                         break;
  391.                     }
  392.                 }
  393.                 posizioneparentesichiusa = espressione.IndexOf(')', posizioneparentesiaperta);
  394.                 contenutoparentesi = apoggio.Substring(posizioneparentesiaperta, posizioneparentesichiusa - posizioneparentesiaperta + 1);
  395.                 espressione = espressione.Remove(posizioneparentesiaperta, contenutoparentesi.Length);
  396.                 espressione = espressione.Insert(posizioneparentesiaperta, risultatoperazione);
  397.                 contaparentesi--;
  398.             }
  399.             lblerrore.Text = Convert.ToString(espressione);
  400.         }
  401.     }
  402. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top