API tools faq
paste
Advertisement
Pavle_nis

Moj Broj C#

Pavle_nis
Dec 17th, 2016
476
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 43.11 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace Igra_Moj_Broj
  8. {
  9.     class Program
  10.     {
  11.         int najbl;
  12.         int u, pok, zad, a;
  13.         int l;
  14.         int[] niz = new int[946686];
  15.         bool[] uzet = new bool[6];
  16.         string w;
  17.         bool lpl;
  18.         static void Main(string[] args)
  19.         {
  20.             Program prog = new Program();
  21.             prog.zad = Convert.ToInt32(Console.ReadLine());
  22.             for (prog.u = 1; prog.u < 6; prog.u++)
  23.             {
  24.                 prog.niz[prog.u] = Console.Read();
  25.                 if (prog.niz[prog.u] == prog.zad)
  26.                 {
  27.                     Console.WriteLine(prog.zad);
  28.                     Console.WriteLine(prog.zad);
  29.                     Console.ReadKey();
  30.                     return;
  31.                 }
  32.             }
  33.             prog.pok = 7;
  34.             prog.w = "";
  35.             for (prog.u = 1; prog.u < 209406; prog.u++)
  36.                 prog.uradi(prog.u);
  37.             prog.najbl = 0;
  38.             prog.resi_6();
  39.             prog.resi_3_3();
  40.             prog.resi_2_2_2();
  41.             Console.WriteLine(prog.najbl);
  42.             Console.WriteLine(prog.w);
  43.             Console.ReadKey();
  44.         }
  45.         int abs2(int x)
  46.         {
  47.             int abs;
  48.             if (x > 0) abs = x;
  49.             else abs = -x;
  50.  
  51.             return x;
  52.         }
  53.         string num2str2(int y)
  54.         {
  55.             string num2str = "";
  56.             do
  57.             {
  58.                 num2str = (y % 10 + 48).ToString() + num2str;
  59.                 y = y / 10;
  60.             }
  61.             while (y == 0);
  62.  
  63.             return num2str;
  64.         }
  65.         void inc_uzet()
  66.         {
  67.             byte ss;
  68.             for (ss = 1; ss < 6; ss++)
  69.                 uzet[ss] = false;
  70.         }
  71.         void oznaci_po_redu(int s)
  72.         {
  73.             l = 0;
  74.             while (s > 0)
  75.             {
  76.                 l++;
  77.                 if (!uzet[l]) s--;
  78.             }
  79.             uzet[l] = true;
  80.         }
  81.         void dekodiraj(int i)
  82.         {
  83.             if (i < 7)
  84.                 uzet[i] = true;
  85.             else if (i < 127)
  86.             {
  87.                 dekodiraj((i - 7) / 4 / 5 + 1);
  88.                 oznaci_po_redu((i - 7) / 4 - (i - 7) / 4 / 5 * 5 + 1);
  89.             }
  90.             else if (i < 2047)
  91.             {
  92.                 dekodiraj((i - 127) / 4 / 4 + 7);
  93.                 oznaci_po_redu((i - 127) / 4 - (i - 127) / 4 / 4 * 4 + 1);
  94.             }
  95.             else if (i < 25087)
  96.             {
  97.                 dekodiraj((i - 2047) / 4 / 3 + 127);
  98.                 oznaci_po_redu((i - 2047) / 4 - (i - 2047) / 4 / 3 * 3 + 1);
  99.             }
  100.             else if (i < 209407)
  101.             {
  102.                 dekodiraj((i - 25087) / 4 / 2 + 2047);
  103.                 oznaci_po_redu((i - 25087) / 4 - (i - 25087) / 4 / 2 * 2 + 1);
  104.             }
  105.             else
  106.             {
  107.                 dekodiraj((i - 209407) / 4 + 25087);
  108.                 oznaci_po_redu(1);
  109.             }
  110.         }
  111.         void dekodiraj1(int i)
  112.         {
  113.             int a;
  114.             if (i < 7)
  115.             {
  116.                 uzet[i] = true;
  117.                 w = w + num2str2(niz[i]);
  118.                 lpl = false;
  119.             }
  120.             else
  121.             {
  122.                 if (i < 127)
  123.                 {
  124.                     a = (i - 7) / 4 / 5 + 1;
  125.                     dekodiraj1(a);
  126.                     oznaci_po_redu((i - 7) / 4 - 5 * (a - 1) + 1);
  127.                 }
  128.                 else if (i < 2047)
  129.                 {
  130.                     a = (i - 127) / 4 / 4 + 7;
  131.                     dekodiraj1(a);
  132.                     oznaci_po_redu((i - 127) / 4 - 4 * (a - 7) + 1);
  133.                 }
  134.                 else if (i < 25087)
  135.                 {
  136.                     a = (i - 2047) / 4 / 3 + 127;
  137.                     dekodiraj1(a);
  138.                     oznaci_po_redu((i - 2047) / 4 - 3 * (a - 127) + 1);
  139.                 }
  140.                 else if (i < 209407)
  141.                 {
  142.                     a = (i - 25087) / 4 / 2 + 2047;
  143.                     dekodiraj1(a);
  144.                     oznaci_po_redu((i - 25087) / 4 - 2 * (a - 2047) + 1);
  145.                 }
  146.                 else
  147.                 {
  148.                     a = (i - 209407) / 4 + 25087;
  149.                     dekodiraj1(a);
  150.                     oznaci_po_redu(1);
  151.                 }
  152.                 switch ((i + 1) % 4)
  153.                 {
  154.                     case 0:
  155.                         {
  156.                             w = w + '+' + num2str2(niz[l]);
  157.                             lpl = true;
  158.                             break;
  159.                         }
  160.                     case 1:
  161.                         {
  162.                             if (niz[a] > niz[l])
  163.                                 w = w + '-' + num2str2(niz[l]);
  164.                             else
  165.                             {
  166.                                 if (!lpl)
  167.                                     w = num2str2(niz[l]) + '-' + w;
  168.                                 else
  169.                                     w = num2str2(niz[l]) + "-(' + w + ')";
  170.                             }
  171.                             lpl = true;
  172.                             break;
  173.                         }
  174.                     case 2:
  175.                         {
  176.                             if (lpl)
  177.                                 w = "(' + w + ')*" + num2str2(niz[l]);
  178.                             else
  179.                                 w = w + '*' + num2str2(niz[l]);
  180.                             lpl = false;
  181.                             break;
  182.                         }
  183.                     case 3:
  184.                         {
  185.                             if (niz[a] > niz[l])
  186.                             {
  187.                                 if (lpl)
  188.                                     w = "(' + w + ')/" + num2str2(niz[l]);
  189.                                 else
  190.                                     w = w + '/' + num2str2(niz[l]);
  191.                             }
  192.                             else
  193.                             {
  194.                                 if (i < 127)
  195.                                     w = num2str2(niz[l]) + '/' + w;
  196.                                 else
  197.                                     w = num2str2(niz[l]) + "/(' + w + ')";
  198.                             }
  199.                             lpl = false;
  200.                             break;
  201.                         }
  202.                 }
  203.             }
  204.         }
  205.         void ispisi()
  206.         {
  207.             Console.WriteLine(zad);
  208.             Console.WriteLine(w);
  209.             Console.ReadKey();
  210.             return;
  211.         }
  212.         void kraj()
  213.         {
  214.             if (niz[pok] == zad)
  215.             {
  216.                 inc_uzet();
  217.                 dekodiraj1(pok);
  218.                 ispisi();
  219.             }
  220.         }
  221.         void uradi(int k)
  222.         {
  223.             int j;
  224.             inc_uzet();
  225.             dekodiraj(k);
  226.             for (j = 1; j < 6; j++)
  227.                 if (!uzet[j])
  228.                 {
  229.                     niz[pok] = niz[k] + niz[j];
  230.                     kraj();
  231.                     pok++;
  232.                     niz[pok] = abs2(niz[k] - niz[j]);
  233.                     kraj();
  234.                     pok++;
  235.                     niz[pok] = niz[k] * niz[j];
  236.                     kraj();
  237.                     pok++;
  238.                     niz[pok] = 0;
  239.                     if (niz[k] % niz[j] == 0)
  240.                         niz[pok] = niz[k] / niz[j];
  241.                     else if (niz[k] > 0)
  242.                         if (niz[j] % niz[k] == 0)
  243.                             niz[pok] = niz[j] / niz[k];
  244.                     kraj();
  245.                     pok++;
  246.                 }
  247.         }
  248.         void resi_6()
  249.         {
  250.             for (u = 1; u < 946686; u++)
  251.                 if (abs2(niz[u] - zad) < abs2(najbl - zad))
  252.                 {
  253.                     najbl = niz[u];
  254.                     pok = u;
  255.                 }
  256.             inc_uzet();
  257.             dekodiraj1(pok);
  258.             if (najbl == zad)
  259.                 ispisi();
  260.         }
  261.         void resi_3_3()
  262.         {
  263.             int v;
  264.             string w1;
  265.             bool[] uzet1 = new bool[6];
  266.             for (u = 7; u < 2045; u++)
  267.                 for (v = u + 1; v < 2046; v++)
  268.                 {
  269.                     inc_uzet();
  270.                     dekodiraj(v);
  271.                     for (pok = 1; pok < 6; pok++)
  272.                         uzet1[pok] = uzet[pok];
  273.                     inc_uzet();
  274.                     dekodiraj(u);
  275.                     if (!(uzet[1] && uzet1[1]) || (uzet[2] && uzet1[2]) || (uzet[3] && uzet1[3]) || (uzet[4] && uzet1[4]) || (uzet[5] && uzet1[5]) || (uzet[6] && uzet1[6]))
  276.                     {
  277.                         if (abs2(niz[u] + niz[v] - zad) < abs2(najbl - zad))
  278.                         {
  279.                             najbl = niz[u] + niz[v];
  280.                             w = "";
  281.                             inc_uzet();
  282.                             dekodiraj1(v);
  283.                             w1 = w;
  284.                             w = "";
  285.                             inc_uzet();
  286.                             dekodiraj1(u);
  287.                             w = w + '+' + w1;
  288.                             if (najbl == zad)
  289.                                 ispisi();
  290.                         }
  291.                         if (abs2(abs2(niz[u] - niz[v]) - zad) < abs2(najbl - zad))
  292.                         {
  293.                             najbl = abs2(niz[u] - niz[v]);
  294.                             w = "";
  295.                             inc_uzet();
  296.                             if (niz[u] > niz[v])
  297.                             {
  298.                                 dekodiraj1(v);
  299.                                 if (lpl)
  300.                                     w1 = '(' + w + ')';
  301.                                 else
  302.                                     w1 = w;
  303.                                 w = "";
  304.                                 inc_uzet();
  305.                                 dekodiraj1(u);
  306.                             }
  307.                             else
  308.                             {
  309.                                 dekodiraj1(u);
  310.                                 if (lpl)
  311.                                     w1 = '(' + w + ')';
  312.                                 else
  313.                                     w1 = w;
  314.                                 w = "";
  315.                                 inc_uzet();
  316.                                 dekodiraj1(v);
  317.                             }
  318.                             w = w + '-' + w1;
  319.                             if (najbl == zad)
  320.                                 ispisi();
  321.                         }
  322.                         if (abs2(niz[u] * niz[v] - zad) < abs2(najbl - zad))
  323.                         {
  324.                             najbl = niz[u] * niz[v];
  325.                             w = "";
  326.                             inc_uzet();
  327.                             dekodiraj1(v);
  328.                             if (lpl)
  329.                                 w1 = '(' + w + ')';
  330.                             else
  331.                                 w1 = w;
  332.                             w = "";
  333.                             inc_uzet();
  334.                             dekodiraj1(u);
  335.                             if (lpl)
  336.                                 w = "(' + w + ')*" + w1;
  337.                             else
  338.                                 w = w + '*' + w1;
  339.                             if (najbl == zad)
  340.                                 ispisi();
  341.                         }
  342.                         if ((niz[v] > 0) && (niz[u] % niz[v] == 0))
  343.                             if (abs2(niz[u] / niz[v] - zad) < abs2(najbl - zad))
  344.                             {
  345.                                 najbl = niz[u] / niz[v];
  346.                                 w = "";
  347.                                 inc_uzet();
  348.                                 dekodiraj1(v);
  349.                                 w1 = '(' + w + ')';
  350.                                 w = "";
  351.                                 inc_uzet();
  352.                                 dekodiraj1(u);
  353.                                 if (lpl)
  354.                                     w = "(' + w + ')/" + w1;
  355.                                 else w = w + '/' + w1;
  356.                                 if (najbl == zad)
  357.                                     ispisi();
  358.                             }
  359.                             else;
  360.                         else
  361.                         if ((niz[u] > 0) && (niz[v] % niz[u] == 0))
  362.                             if (abs2(niz[v] / niz[u] - zad) < abs2(najbl - zad))
  363.                             {
  364.                                 najbl = niz[v] / niz[u];
  365.                                 w = "";
  366.                                 inc_uzet();
  367.                                 dekodiraj1(u);
  368.                                 w1 = '(' + w + ')';
  369.                                 w = "";
  370.                                 inc_uzet();
  371.                                 dekodiraj1(v);
  372.                                 if (lpl)
  373.                                     w = "(' + w + ')/" + w1;
  374.                                 else
  375.                                     w = w + '/' + w1;
  376.                                 if (najbl == zad)
  377.                                     ispisi();
  378.                             }
  379.                     }
  380.                 }
  381.         }
  382.         void resi_2_2_2()
  383.         {
  384.             int v, v1;
  385.             string w1;
  386.             bool[] uzet1 = new bool[6];
  387.             for (u = 7; u < 126; u++)
  388.                 for (v = 7; v < 126; v++)
  389.                 {
  390.                     inc_uzet();
  391.                     dekodiraj(v);
  392.                     for (pok = 1; pok < 6; pok++)
  393.                         uzet1[pok] = uzet[pok];
  394.                     inc_uzet();
  395.                     dekodiraj(u);
  396.                     if (!(uzet[1] && uzet1[1]) || (uzet[2] && uzet1[2]) || (uzet[3] && uzet1[3]) || (uzet[4] && uzet1[4]) || (uzet[5] && uzet1[5]) || (uzet[6] && uzet1[6]))
  397.                     {
  398.                         for (pok = 1; pok < 6; pok++)
  399.                             uzet1[pok] = uzet[pok] || uzet1[pok];
  400.                         for (v1 = 1; v1 < 126; v1++)
  401.                         {
  402.                             inc_uzet();
  403.                             dekodiraj(v1);
  404.                             if (!(uzet[1] && uzet1[1]) || (uzet[2] && uzet1[2]) || (uzet[3] && uzet1[3]) || (uzet[4] && uzet1[4]) || (uzet[5] && uzet1[5]) || (uzet[6] && uzet1[6]))
  405.                             {
  406.                                 //prvu dvojicu sabiramo
  407.                                 if (abs2(niz[u] + niz[v] + niz[v1] - zad) < abs2(najbl - zad))
  408.                                 {
  409.                                     najbl = niz[u] + niz[v] + niz[v1];
  410.                                     w = "";
  411.                                     inc_uzet();
  412.                                     dekodiraj1(v1);
  413.                                     w1 = w;
  414.                                     w = "";
  415.                                     inc_uzet();
  416.                                     dekodiraj1(v);
  417.                                     w1 = w + '+' + w1;
  418.                                     w = "";
  419.                                     inc_uzet();
  420.                                     dekodiraj1(u);
  421.                                     w = w + '+' + w1;
  422.                                     if (najbl == zad)
  423.                                         ispisi();
  424.                                 }
  425.                                 if (abs2(abs2(niz[u] + niz[v] - niz[v1]) - zad) < abs2(najbl - zad))
  426.                                 {
  427.                                     najbl = abs2(niz[u] + niz[v] - niz[v1]);
  428.                                     w = "";
  429.                                     inc_uzet();
  430.                                     if (niz[u] + niz[v] > niz[v1])
  431.                                     {
  432.                                         dekodiraj1(v1);
  433.                                         if (lpl)
  434.                                             w1 = '(' + w + ')';
  435.                                         else w1 = w;
  436.                                         w = "";
  437.                                         inc_uzet();
  438.                                         dekodiraj1(v);
  439.                                         w1 = w + '-' + w1;
  440.                                         w = "";
  441.                                         inc_uzet();
  442.                                         dekodiraj1(u);
  443.                                         w = w + '+' + w1;
  444.                                     }
  445.                                     else
  446.                                     {
  447.                                         dekodiraj1(v);
  448.                                         w1 = w;
  449.                                         w = "";
  450.                                         inc_uzet();
  451.                                         dekodiraj1(u);
  452.                                         w1 = '(' + w + '+' + w1 + ')';
  453.                                         w = "";
  454.                                         inc_uzet();
  455.                                         dekodiraj1(v1);
  456.                                         w = w + '-' + w1;
  457.                                     }
  458.                                     if (najbl == zad)
  459.                                         ispisi();
  460.                                 }
  461.                                 if (abs2((niz[u] + niz[v]) * niz[v1] - zad) < abs2(najbl - zad))
  462.                                 {
  463.                                     najbl = (niz[u] + niz[v]) * niz[v1];
  464.                                     w = "";
  465.                                     inc_uzet();
  466.                                     dekodiraj1(v1);
  467.                                     if (lpl)
  468.                                         w1 = '(' + w + ')';
  469.                                     else w1 = w;
  470.                                     w = "";
  471.                                     inc_uzet();
  472.                                     dekodiraj1(v);
  473.                                     w1 = w + ")*" + w1;
  474.                                     w = "";
  475.                                     inc_uzet();
  476.                                     dekodiraj1(u);
  477.                                     w = '(' + w + '+' + w1;
  478.                                     if (najbl == zad)
  479.                                         ispisi();
  480.                                 }
  481.                                 if ((niz[v1] > 0) && ((niz[u] + niz[v]) % niz[v1] == 0))
  482.                                     if (abs2((niz[u] + niz[v]) / niz[v1] - zad) < abs2(najbl - zad))
  483.                                     {
  484.                                         najbl = (niz[u] + niz[v]) / niz[v1];
  485.                                         w = "";
  486.                                         inc_uzet();
  487.                                         dekodiraj1(v1);
  488.                                         if (v1 < 7)
  489.                                             w1 = w;
  490.                                         else
  491.                                             w1 = '(' + w + ')';
  492.                                         w = "";
  493.                                         inc_uzet();
  494.                                         dekodiraj1(v);
  495.                                         w1 = w + ")/" + w1;
  496.                                         w = "";
  497.                                         inc_uzet();
  498.                                         dekodiraj1(u);
  499.                                         w = '(' + w + '+' + w1;
  500.                                         if (najbl == zad)
  501.                                             ispisi();
  502.                                     }
  503.                                     else;
  504.                                 else if ((niz[u] + niz[v] > 0) && (niz[v1] % (niz[u] + niz[v]) == 0))
  505.                                     if (abs2(niz[v1] / (niz[u] + niz[v]) - zad) < abs2(najbl - zad))
  506.                                     {
  507.                                         najbl = niz[v] / (niz[u] + niz[v]);
  508.                                         w = "";
  509.                                         inc_uzet();
  510.                                         dekodiraj1(v);
  511.                                         w1 = w + ')';
  512.                                         w = "";
  513.                                         inc_uzet();
  514.                                         dekodiraj1(u);
  515.                                         w1 = '(' + w + '+' + w1;
  516.                                         w = "";
  517.                                         inc_uzet();
  518.                                         dekodiraj1(v1);
  519.                                         if (lpl)
  520.                                             w = "(' + w + ')/" + w1;
  521.                                         else
  522.                                             w = w + '/' + w1;
  523.                                         if (najbl == zad)
  524.                                             ispisi();
  525.                                     }
  526.                                 if (abs2(abs2(niz[u] - niz[v]) * niz[v1] - zad) < abs2(najbl - zad))
  527.                                 {
  528.                                     najbl = abs2(niz[u] - niz[v]) * niz[v1];
  529.                                     w = "";
  530.                                     inc_uzet();
  531.                                     dekodiraj1(v1);
  532.                                     if (lpl)
  533.                                         w1 = '(' + w + ')';
  534.                                     else w1 = w;
  535.                                     w = "";
  536.                                     inc_uzet();
  537.                                     if (niz[u] > niz[v])
  538.                                     {
  539.                                         dekodiraj1(v);
  540.                                         if (lpl)
  541.                                             w1 = "(' + w + '))*" + w1;
  542.                                         else
  543.                                             w1 = w + ")*" + w1;
  544.                                         w = "";
  545.                                         inc_uzet();
  546.                                         dekodiraj1(u);
  547.                                     }
  548.                                     else
  549.                                     {
  550.                                         dekodiraj1(v);
  551.                                         if (lpl)
  552.                                             w1 = "(' + w + '))*" + w1;
  553.                                         else w1 = w + ")*" + w1;
  554.                                         w = "";
  555.                                         inc_uzet();
  556.                                         dekodiraj1(u);
  557.                                     }
  558.                                     w = '(' + w + '-' + w1;
  559.                                     if (najbl == zad)
  560.                                         ispisi();
  561.                                 }
  562.                                 if ((niz[v1] > 0) && (abs2(niz[u] - niz[v]) % niz[v1] == 0))
  563.                                     if (abs2(abs2(niz[u] - niz[v]) / niz[v1] - zad) < abs2(najbl - zad))
  564.                                     {
  565.                                         najbl = abs2(niz[u] - niz[v]) / niz[v1];
  566.                                         w = "";
  567.                                         inc_uzet();
  568.                                         dekodiraj1(v1);
  569.                                         if (v1 < 7)
  570.                                             w1 = w;
  571.                                         else w1 = '(' + w + ')';
  572.                                         w = "";
  573.                                         inc_uzet();
  574.                                         if (niz[u] > niz[v])
  575.                                         {
  576.                                             dekodiraj1(v);
  577.                                             if (lpl)
  578.                                                 w1 = "(' + w + '))/" + w1;
  579.                                             else
  580.                                                 w1 = w + ")/" + w1;
  581.                                             w = "";
  582.                                             inc_uzet();
  583.                                             dekodiraj1(u);
  584.                                         }
  585.                                         else
  586.                                         {
  587.                                             dekodiraj1(u);
  588.                                             if (lpl)
  589.                                                 w1 = "(' + w + '))/" + w1;
  590.                                             else
  591.                                                 w1 = w + ")/" + w1;
  592.                                             w = "";
  593.                                             inc_uzet();
  594.                                             dekodiraj1(v);
  595.                                         }
  596.                                         w = '(' + w + '-' + w1;
  597.                                         if (najbl == zad)
  598.                                             ispisi();
  599.                                     }
  600.                                     else;
  601.                                 else if ((abs2(niz[u] - niz[v]) > 0) && (niz[v1] % abs2(niz[u] - niz[v]) == 0))
  602.                                     if (abs2(niz[v1] / abs2(niz[u] - niz[v]) - zad) < abs2(najbl - zad))
  603.                                     {
  604.                                         najbl = niz[v1] / abs2(niz[u] - niz[v]);
  605.                                         w = "";
  606.                                         inc_uzet();
  607.                                         if (niz[u] > niz[v])
  608.                                         {
  609.                                             dekodiraj1(v);
  610.                                             if (lpl)
  611.                                                 w1 = "(' + w + '))";
  612.                                             else
  613.                                                 w1 = w + ')';
  614.                                             w = "";
  615.                                             inc_uzet();
  616.                                             dekodiraj1(u);
  617.                                         }
  618.                                         else
  619.                                         {
  620.                                             dekodiraj1(u);
  621.                                             if (lpl)
  622.                                                 w1 = "(' + w + '))";
  623.                                             else
  624.                                                 w1 = w + ')';
  625.                                             w = "";
  626.                                             inc_uzet();
  627.                                             dekodiraj1(v);
  628.                                         }
  629.                                         w1 = '(' + w + '-' + w1;
  630.                                         w = "";
  631.                                         inc_uzet();
  632.                                         dekodiraj1(v1);
  633.                                         if (lpl)
  634.                                             w = "(' + w + ')/" + w1;
  635.                                         else
  636.                                             w = w + '/' + w1;
  637.                                         if (najbl == zad)
  638.                                             ispisi();
  639.                                     }
  640.                                 if (abs2(niz[u] * niz[v] + niz[v1] - zad) < abs2(najbl - zad))
  641.                                 {
  642.                                     najbl = niz[u] * niz[v] + niz[v1];
  643.                                     w = "";
  644.                                     inc_uzet();
  645.                                     dekodiraj1(v1);
  646.                                     w1 = w;
  647.                                     w = "";
  648.                                     inc_uzet();
  649.                                     dekodiraj1(v);
  650.                                     if (lpl)
  651.                                         w1 = "(' + w + ')+" + w1;
  652.                                     else
  653.                                         w1 = w + '+' + w1;
  654.                                     w = "";
  655.                                     inc_uzet();
  656.                                     dekodiraj1(u);
  657.                                     if (lpl)
  658.                                         w = "(' + w + ')*" + w1;
  659.                                     else
  660.                                         w = w + '*' + w1;
  661.                                     if (najbl == zad)
  662.                                         ispisi();
  663.                                 }
  664.                                 if (abs2(abs2(niz[u] * niz[v] - niz[v1]) - zad) < abs2(najbl - zad))
  665.                                 {
  666.                                     najbl = abs2(niz[u] * niz[v] - niz[v1]);
  667.                                     w = "";
  668.                                     inc_uzet();
  669.                                     if (niz[u] * niz[v] > niz[v1])
  670.                                     {
  671.                                         dekodiraj1(v1);
  672.                                         if (lpl)
  673.                                             w1 = '(' + w + ')';
  674.                                         else
  675.                                             w1 = w;
  676.                                         w = "";
  677.                                         inc_uzet();
  678.                                         dekodiraj1(v);
  679.                                         if (lpl)
  680.                                             w1 = "(' + w + ')-" + w1;
  681.                                         else
  682.                                             w1 = w + '-' + w1;
  683.                                         w = "";
  684.                                         inc_uzet();
  685.                                         dekodiraj1(u);
  686.                                         if (lpl)
  687.                                             w = "(' + w + ')*" + w1;
  688.                                         else
  689.                                             w = w + '*' + w1;
  690.                                     }
  691.                                     else
  692.                                     {
  693.                                         dekodiraj1(v);
  694.                                         if (lpl)
  695.                                             w1 = '(' + w + ')';
  696.                                         else
  697.                                             w1 = w;
  698.                                         w = "";
  699.                                         inc_uzet();
  700.                                         dekodiraj1(u);
  701.                                         if (lpl)
  702.                                             w1 = "(' + w + ')*" + w1;
  703.                                         else
  704.                                             w1 = w + '*' + w1;
  705.                                         w = "";
  706.                                         inc_uzet();
  707.                                         dekodiraj1(v1);
  708.                                         w = w + '-' + w1;
  709.                                     }
  710.                                     if (najbl == zad)
  711.                                         ispisi();
  712.                                 }
  713.                                 if (abs2(niz[u] * niz[v] * niz[v1] - zad) < abs2(najbl - zad))
  714.                                 {
  715.                                     najbl = niz[u] * niz[v] * niz[v1];
  716.                                     w = "";
  717.                                     inc_uzet();
  718.                                     dekodiraj1(v1);
  719.                                     if (lpl)
  720.                                         w1 = '(' + w + ')';
  721.                                     else
  722.                                         w1 = w;
  723.                                     w = "";
  724.                                     inc_uzet();
  725.                                     dekodiraj1(v);
  726.                                     if (lpl)
  727.                                         w1 = "(' + w + ')*" + w1;
  728.                                     else
  729.                                         w1 = w + '*' + w1;
  730.                                     w = "";
  731.                                     inc_uzet();
  732.                                     dekodiraj1(u);
  733.                                     if (lpl)
  734.                                         w = "(' + w + ')*" + w1;
  735.                                     else
  736.                                         w = w + '*' + w1;
  737.                                     if (najbl == zad)
  738.                                         ispisi();
  739.                                 }
  740.                                 if ((niz[v1] > 0) && (niz[u] * niz[v] % niz[v1] == 0))
  741.                                     if (abs2(niz[u] * niz[v] / niz[v1] - zad) < abs2(najbl - zad))
  742.                                     {
  743.                                         najbl = niz[u] * niz[v] / niz[v1];
  744.                                         w = "";
  745.                                         inc_uzet();
  746.                                         dekodiraj1(v1);
  747.                                         if (v1 < 7)
  748.                                             w1 = w;
  749.                                         else
  750.                                             w1 = '(' + w + ')';
  751.                                         w = "";
  752.                                         inc_uzet();
  753.                                         dekodiraj1(v);
  754.                                         if (lpl)
  755.                                             w1 = "(' + w + ')/" + w1;
  756.                                         else
  757.                                             w1 = w + '/' + w1;
  758.                                         w = "";
  759.                                         inc_uzet();
  760.                                         dekodiraj1(u);
  761.                                         if (lpl)
  762.                                             w = "(' + w + ')*" + w1;
  763.                                         else
  764.                                             w = w + '*' + w1;
  765.                                         if (najbl == zad)
  766.                                             ispisi();
  767.                                     }
  768.                                     else;
  769.                                 else if ((niz[u] * niz[v] > 0) && (niz[v1] % (niz[u] * niz[v]) == 0))
  770.                                     if (abs2(niz[v1] / (niz[u] * niz[v]) - zad) < abs2(najbl - zad))
  771.                                     {
  772.                                         najbl = niz[v] / (niz[u] * niz[v]);
  773.                                         w = "";
  774.                                         inc_uzet();
  775.                                         dekodiraj1(v);
  776.                                         if (lpl)
  777.                                             w1 = "(' + w + '))";
  778.                                         else
  779.                                             w1 = w + ')';
  780.                                         w = "";
  781.                                         inc_uzet();
  782.                                         dekodiraj1(u);
  783.                                         if (lpl)
  784.                                             w1 = "((' + w + ')*" + w1;
  785.                                         else
  786.                                             w1 = '(' + w + '*' + w1;
  787.                                         w = "";
  788.                                         inc_uzet();
  789.                                         dekodiraj1(v1);
  790.                                         if (lpl)
  791.                                             w = "(' + w + ')/" + w1;
  792.                                         else
  793.                                             w = w + '/' + w1;
  794.                                         if (najbl == zad)
  795.                                             ispisi();
  796.                                     }
  797.                                 if ((niz[v] > 0) && (niz[u] % niz[v] == 0))
  798.                                 {
  799.                                     if (abs2(niz[u] / niz[v] + niz[v1] - zad) < abs2(najbl - zad))
  800.                                     {
  801.                                         najbl = niz[u] / niz[v] + niz[v1];
  802.                                         w = "";
  803.                                         inc_uzet();
  804.                                         dekodiraj1(v1);
  805.                                         w1 = w;
  806.                                         w = "";
  807.                                         inc_uzet();
  808.                                         dekodiraj1(v);
  809.                                         w1 = "(' + w + ')+" + w1;
  810.                                         w = "";
  811.                                         inc_uzet();
  812.                                         dekodiraj1(u);
  813.                                         if (lpl)
  814.                                             w = "(' + w + ')/" + w1;
  815.                                         else
  816.                                             w = w + '/' + w1;
  817.                                         if (najbl == zad)
  818.                                             ispisi();
  819.                                     }
  820.                                     if (abs2(abs2(niz[u] / niz[v] - niz[v1]) - zad) < abs2(najbl - zad))
  821.                                     {
  822.                                         najbl = abs2(niz[u] / niz[v] - niz[v1]);
  823.                                         w = "";
  824.                                         inc_uzet();
  825.                                         if (niz[u] / niz[v] > niz[v1])
  826.                                         {
  827.                                             dekodiraj1(v1);
  828.                                             if (lpl)
  829.                                                 w1 = '(' + w + ')';
  830.                                             else
  831.                                                 w1 = w;
  832.                                             w = "";
  833.                                             inc_uzet();
  834.                                             dekodiraj1(v);
  835.                                             w1 = "(' + w + ')-" + w1;
  836.                                             w = "";
  837.                                             inc_uzet();
  838.                                             dekodiraj1(u);
  839.                                             if (lpl)
  840.                                                 w = "(' + w + ')/" + w1;
  841.                                             else
  842.                                                 w = w + '/' + w1;
  843.                                         }
  844.                                         else
  845.                                         {
  846.                                             dekodiraj1(v);
  847.                                             w1 = '(' + w + ')';
  848.                                             w = "";
  849.                                             inc_uzet();
  850.                                             dekodiraj1(u);
  851.                                             if (lpl)
  852.                                                 w1 = "(' + w + ')/" + w1;
  853.                                             else
  854.                                                 w1 = w + '/' + w1;
  855.                                             w = "";
  856.                                             inc_uzet();
  857.                                             dekodiraj1(v1);
  858.                                             w = w + '-' + w1;
  859.                                         }
  860.                                         if (najbl == zad)
  861.                                             ispisi();
  862.                                     }
  863.                                 }
  864.                                 else if ((niz[u] > 0) && (niz[v] % niz[u] == 0))
  865.                                 {
  866.                                     if (abs2(niz[v] / niz[u] + niz[v1] - zad) < abs2(najbl - zad))
  867.                                     {
  868.                                         najbl = niz[v] / niz[u] + niz[v1];
  869.                                         w = "";
  870.                                         inc_uzet();
  871.                                         dekodiraj1(v1);
  872.                                         w1 = w;
  873.                                         w = "";
  874.                                         inc_uzet();
  875.                                         dekodiraj1(u);
  876.                                         w1 = "(' + w + ')+" + w1;
  877.                                         w = "";
  878.                                         inc_uzet();
  879.                                         dekodiraj1(v);
  880.                                         if (lpl)
  881.                                             w = "(' + w + ')/" + w1;
  882.                                         else
  883.                                             w = w + '/' + w1;
  884.                                         if (najbl == zad)
  885.                                             ispisi();
  886.                                     }
  887.                                     if (abs2(abs2(niz[v] / niz[u] - niz[v1]) - zad) < abs2(najbl - zad))
  888.                                     {
  889.                                         najbl = abs2(niz[v] / niz[u] - niz[v1]);
  890.                                         w = "";
  891.                                         inc_uzet();
  892.                                         if (niz[v] / niz[u] > niz[v1])
  893.                                         {
  894.                                             dekodiraj1(v1);
  895.                                             if (lpl)
  896.                                                 w1 = '(' + w + ')';
  897.                                             else
  898.                                                 w1 = w;
  899.                                             w = "";
  900.                                             inc_uzet();
  901.                                             dekodiraj1(u);
  902.                                             w1 = "(' + w + ')-" + w1;
  903.                                             w = "";
  904.                                             inc_uzet();
  905.                                             dekodiraj1(v);
  906.                                             if (lpl)
  907.                                                 w = "(' + w + ')/" + w1;
  908.                                             else
  909.                                                 w = w + '/' + w1;
  910.                                         }
  911.                                         else
  912.                                         {
  913.                                             dekodiraj1(u);
  914.                                             w1 = '(' + w + ')';
  915.                                             w = "";
  916.                                             inc_uzet();
  917.                                             dekodiraj1(v);
  918.                                             if (lpl)
  919.                                                 w1 = "(' + w + ')/" + w1;
  920.                                             else
  921.                                                 w1 = w + '/' + w1;
  922.                                             w = "";
  923.                                             inc_uzet();
  924.                                             dekodiraj1(v1);
  925.                                             w = w + '-' + w1;
  926.                                         }
  927.                                         if (najbl == zad)
  928.                                             ispisi();
  929.                                     }
  930.                                 }
  931.                             }
  932.                         }
  933.                     }
  934.                 }
  935.         }
  936.     }
  937. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!