API tools faq
paste
Advertisement
Pavle_nis

Moj Broj

Pavle_nis
Dec 13th, 2016
1,235
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Pascal 59.85 KB | None | 0 0
raw download clone embed print report
  1. uses crt;
  2. var najbl:int64;
  3.     u,pok,zad,a:longint;
  4.     l:integer;
  5.     niz:array[1..946686] of int64;
  6.     uzet:array[1..6] of boolean;
  7.     w:string;
  8.     lpl:boolean;
  9. function abs(x:int64):int64;
  10. begin
  11.  if x>0 then abs:=x
  12.         else abs:=-x;
  13. end;
  14. function num2str(y:integer):string;
  15. begin
  16.  num2str:='';
  17.  repeat
  18.   num2str:=chr(y mod 10+48)+num2str;
  19.   y:=y div 10
  20.  until y=0;
  21. end;
  22. procedure inc_uzet;
  23. var ss:byte;
  24. begin
  25.  for ss:=1 to 6 do
  26.    uzet[ss]:=false;
  27. end;
  28. procedure oznaci_po_redu(s:integer);
  29. begin
  30.  l:=0;
  31.  while (s>0) do
  32.     begin
  33.      inc(l);
  34.      if not(uzet[l]) then dec(s);
  35.     end;
  36.  uzet[l]:=true;
  37. end;
  38. procedure dekodiraj(i:longint);
  39. begin
  40.  if i<7 then uzet[i]:=true
  41.         else if i<127 then begin
  42.                             dekodiraj((i-7) div 4 div 5 + 1);
  43.                             oznaci_po_redu((i-7) div 4 - (i-7) div 4 div 5 * 5 + 1);
  44.                            end
  45.         else if i<2047 then begin
  46.                              dekodiraj((i-127) div 4 div 4 + 7);
  47.                              oznaci_po_redu((i-127) div 4 - (i-127) div 4 div 4 * 4 + 1);
  48.                             end
  49.         else if i<25087 then begin
  50.                               dekodiraj((i-2047) div 4 div 3 + 127);
  51.                               oznaci_po_redu((i-2047) div 4 - (i-2047) div 4 div 3 * 3 + 1);
  52.                              end
  53.         else if i<209407 then begin
  54.                                dekodiraj((i-25087) div 4 div 2 + 2047);
  55.                                oznaci_po_redu((i-25087) div 4 - (i-25087) div 4 div 2 * 2 + 1);
  56.                               end
  57.         else begin
  58.               dekodiraj((i-209407)div 4 + 25087);
  59.               oznaci_po_redu(1);
  60.              end;
  61. end;
  62. procedure dekodiraj1(i:longint);
  63. var a:longint;
  64. begin
  65.  if i<7 then begin
  66.               uzet[i]:=true;
  67.               w:=w+num2str(niz[i]);
  68.               lpl:=false;
  69.              end
  70.         else begin
  71.               if i<127 then begin
  72.                              a:=(i-7) div 4 div 5 + 1;
  73.                              dekodiraj1(a);
  74.                              oznaci_po_redu((i-7) div 4 - 5*(a-1)+1);
  75.                             end
  76.                        else if i<2047 then begin
  77.                                             a:=(i-127) div 4 div 4 + 7;
  78.                                             dekodiraj1(a);
  79.                                             oznaci_po_redu((i-127) div 4 - 4*(a-7)+1);
  80.                                            end
  81.                        else if i<25087 then begin
  82.                                              a:=(i-2047) div 4 div 3 + 127;
  83.                                              dekodiraj1(a);
  84.                                              oznaci_po_redu((i-2047) div 4 - 3*(a-127)+1);
  85.                                             end
  86.                        else if i<209407 then begin
  87.                                               a:=(i-25087) div 4 div 2 + 2047;
  88.                                               dekodiraj1(a);
  89.                                               oznaci_po_redu((i-25087) div 4 - 2*(a-2047)+1);
  90.                                              end
  91.                        else begin
  92.                              a:=(i-209407)div 4 + 25087;
  93.                              dekodiraj1(a);
  94.                              oznaci_po_redu(1);
  95.                             end;
  96.               case ((i+1) mod 4) of
  97.                 0: begin
  98.                     w:=w+'+'+num2str(niz[l]);
  99.                     lpl:=true;
  100.                    end;
  101.                 1: begin
  102.                     if niz[a]>niz[l] then begin
  103.                                            w:=w+'-'+num2str(niz[l]);
  104.                                           end
  105.                                      else begin
  106.                                            if not(lpl) then w:=num2str(niz[l])+'-'+w
  107.                                                        else w:=num2str(niz[l])+'-('+w+')';
  108.                                           end;
  109.                     lpl:=true;
  110.                    end;
  111.                 2: begin
  112.                     if lpl then w:='('+w+')*'+num2str(niz[l])
  113.                            else w:=w+'*'+num2str(niz[l]);
  114.                     lpl:=false;
  115.                    end;
  116.                 3: begin
  117.                     if niz[a]>niz[l] then begin
  118.                                            if lpl then w:='('+w+')/'+num2str(niz[l])
  119.                                                   else w:=w+'/'+num2str(niz[l]);
  120.                                           end
  121.                                      else begin
  122.                                            if i<127 then w:=num2str(niz[l])+'/'+w
  123.                                                     else w:=num2str(niz[l])+'/('+w+')';
  124.                                           end;
  125.                     lpl:=false;
  126.                    end;
  127.               end;
  128.              end;
  129. end;
  130. procedure ispisi;
  131. begin
  132.  writeln(zad);
  133.  writeln(w);
  134.  repeat until keypressed;
  135.  halt(0);
  136. end;
  137. procedure kraj;
  138. begin
  139.  if niz[pok]=zad then begin
  140.                        inc_uzet;
  141.                        dekodiraj1(pok);
  142.                        ispisi;
  143.                       end;
  144. end;
  145. procedure uradi(k:longint);
  146. var j:integer;
  147. begin
  148.  inc_uzet;
  149.  dekodiraj(k);
  150.  for j:=1 to 6 do
  151.    if not(uzet[j]) then begin
  152.                          niz[pok]:=niz[k]+niz[j];
  153.                          kraj;
  154.                          inc(pok);
  155.                          niz[pok]:=abs(niz[k]-niz[j]);
  156.                          kraj;
  157.                          inc(pok);
  158.                          niz[pok]:=niz[k]*niz[j];
  159.                          kraj;
  160.                          inc(pok);
  161.                          niz[pok]:=0;
  162.                          if niz[k] mod niz[j]=0 then niz[pok]:=niz[k] div niz[j]
  163.                                                 else if niz[k]>0 then if niz[j] mod niz[k]=0 then niz[pok]:=niz[j] div niz[k];
  164.                          kraj;
  165.                          inc(pok);
  166.                         end;
  167. end;
  168. procedure resi_6;
  169. begin
  170.  for u:=1 to 946686 do
  171.    if abs(niz[u]-zad)<abs(najbl-zad) then begin
  172.                                            najbl:=niz[u];
  173.                                            pok:=u;
  174.                                           end;
  175.  inc_uzet;
  176.  dekodiraj1(pok);
  177.  if najbl=zad then ispisi;
  178. end;
  179. procedure resi_3_3;
  180. var v:longint;
  181.     w1:string;
  182.     uzet1:array[1..6] of boolean;
  183. begin
  184.  for u:=7 to 2045 do
  185.    for v:=u+1 to 2046 do
  186.      begin
  187.       inc_uzet;
  188.       dekodiraj(v);
  189.       for pok:=1 to 6 do
  190.         uzet1[pok]:=uzet[pok];
  191.       inc_uzet;
  192.       dekodiraj(u);
  193.       if not((uzet[1] and uzet1[1])or(uzet[2] and uzet1[2])or(uzet[3] and uzet1[3])or(uzet[4] and uzet1[4])or(uzet[5] and uzet1[5])or(uzet[6] and uzet1[6]))
  194.            then begin
  195.                  if abs(niz[u]+niz[v]-zad)<abs(najbl-zad) then begin
  196.                                                                 najbl:=niz[u]+niz[v];
  197.                                                                 w:='';
  198.                                                                 inc_uzet;
  199.                                                                 dekodiraj1(v);
  200.                                                                 w1:=w;
  201.                                                                 w:='';
  202.                                                                 inc_uzet;
  203.                                                                 dekodiraj1(u);
  204.                                                                 w:=w+'+'+w1;
  205.                                                                 if najbl=zad then ispisi;
  206.                                                                end;
  207.                  if abs(abs(niz[u]-niz[v])-zad)<abs(najbl-zad) then begin
  208.                                                                      najbl:=abs(niz[u]-niz[v]);
  209.                                                                      w:='';
  210.                                                                      inc_uzet;
  211.                                                                      if niz[u]>niz[v] then begin
  212.                                                                                             dekodiraj1(v);
  213.                                                                                             if lpl then w1:='('+w+')'
  214.                                                                                                    else w1:=w;
  215.                                                                                             w:='';
  216.                                                                                             inc_uzet;
  217.                                                                                             dekodiraj1(u);
  218.                                                                                            end
  219.                                                                                       else begin
  220.                                                                                             dekodiraj1(u);
  221.                                                                                             if lpl then w1:='('+w+')'
  222.                                                                                                    else w1:=w;
  223.                                                                                             w:='';
  224.                                                                                             inc_uzet;
  225.                                                                                             dekodiraj1(v);
  226.                                                                                            end;
  227.                                                                      w:=w+'-'+w1;
  228.                                                                      if najbl=zad then ispisi;
  229.                                                                     end;
  230.                  if abs(niz[u]*niz[v]-zad)<abs(najbl-zad) then begin
  231.                                                                 najbl:=niz[u]*niz[v];
  232.                                                                 w:='';
  233.                                                                 inc_uzet;
  234.                                                                 dekodiraj1(v);
  235.                                                                 if lpl then w1:='('+w+')'
  236.                                                                        else w1:=w;
  237.                                                                 w:='';
  238.                                                                 inc_uzet;
  239.                                                                 dekodiraj1(u);
  240.                                                                 if lpl then w:='('+w+')*'+w1
  241.                                                                        else w:=w+'*'+w1;
  242.                                                                 if najbl=zad then ispisi;
  243.                                                                end;
  244.                  if (niz[v]>0) and (niz[u] mod niz[v]=0) then
  245.                  if abs(niz[u] div niz[v]-zad)<abs(najbl-zad) then begin
  246.                                                                     najbl:=niz[u] div niz[v];
  247.                                                                     w:='';
  248.                                                                     inc_uzet;
  249.                                                                     dekodiraj1(v);
  250.                                                                     w1:='('+w+')';
  251.                                                                     w:='';
  252.                                                                     inc_uzet;
  253.                                                                     dekodiraj1(u);
  254.                                                                     if lpl then w:='('+w+')/'+w1
  255.                                                                            else w:=w+'/'+w1;
  256.                                                                     if najbl=zad then ispisi;
  257.                                                                    end
  258.                                                               else
  259.                                                          else
  260.                  if (niz[u]>0) and (niz[v] mod niz[u]=0) then
  261.                  if abs(niz[v] div niz[u]-zad)<abs(najbl-zad) then begin
  262.                                                                     najbl:=niz[v] div niz[u];
  263.                                                                     w:='';
  264.                                                                     inc_uzet;
  265.                                                                     dekodiraj1(u);
  266.                                                                     w1:='('+w+')';
  267.                                                                     w:='';
  268.                                                                     inc_uzet;
  269.                                                                     dekodiraj1(v);
  270.                                                                     if lpl then w:='('+w+')/'+w1
  271.                                                                            else w:=w+'/'+w1;
  272.                                                                     if najbl=zad then ispisi;
  273.                                                                    end;
  274.                 end;
  275.      end;
  276. end;
  277. procedure resi_2_2_2;
  278. var v,v1:longint;
  279.     w1:string;
  280.     uzet1:array[1..6] of boolean;
  281. begin
  282.  for u:=7 to 126 do
  283.    for v:=7 to 126 do
  284.      begin
  285.       inc_uzet;
  286.       dekodiraj(v);
  287.       for pok:=1 to 6 do
  288.         uzet1[pok]:=uzet[pok];
  289.       inc_uzet;
  290.       dekodiraj(u);
  291.       if not((uzet[1] and uzet1[1])or(uzet[2] and uzet1[2])or(uzet[3] and uzet1[3])or(uzet[4] and uzet1[4])or(uzet[5] and uzet1[5])or(uzet[6] and uzet1[6]))
  292.            then begin
  293.                  for pok:=1 to 6 do
  294.                    uzet1[pok]:=uzet[pok] or uzet1[pok];
  295.                  for v1:=1 to 126 do
  296.                    begin
  297.                     inc_uzet;
  298.                     dekodiraj(v1);
  299.                     if not((uzet[1] and uzet1[1])or(uzet[2] and uzet1[2])or(uzet[3] and uzet1[3])or(uzet[4] and uzet1[4])or(uzet[5] and uzet1[5])or(uzet[6] and uzet1[6]))
  300.                          then begin
  301. //prvu dvojicu sabiramo
  302.                                if abs(niz[u]+niz[v]+niz[v1]-zad)<abs(najbl-zad) then begin
  303.                                                                                       najbl:=niz[u]+niz[v]+niz[v1];
  304.                                                                                       w:='';
  305.                                                                                       inc_uzet;
  306.                                                                                       dekodiraj1(v1);
  307.                                                                                       w1:=w;
  308.                                                                                       w:='';
  309.                                                                                       inc_uzet;
  310.                                                                                       dekodiraj1(v);
  311.                                                                                       w1:=w+'+'+w1;
  312.                                                                                       w:='';
  313.                                                                                       inc_uzet;
  314.                                                                                       dekodiraj1(u);
  315.                                                                                       w:=w+'+'+w1;
  316.                                                                                       if najbl=zad then ispisi;
  317.                                                                                      end;
  318.                                if abs(abs(niz[u]+niz[v]-niz[v1])-zad)<abs(najbl-zad) then begin
  319.                                                                                       najbl:=abs(niz[u]+niz[v]-niz[v1]);
  320.                                                                                       w:='';
  321.                                                                                       inc_uzet;
  322.                                                                                       if niz[u]+niz[v]>niz[v1] then begin
  323.                                                                                                                      dekodiraj1(v1);
  324.                                                                                                                      if lpl then w1:='('+w+')'
  325.                                                                                                                             else w1:=w;
  326.                                                                                                                      w:='';
  327.                                                                                                                      inc_uzet;
  328.                                                                                                                      dekodiraj1(v);
  329.                                                                                                                      w1:=w+'-'+w1;
  330.                                                                                                                      w:='';
  331.                                                                                                                      inc_uzet;
  332.                                                                                                                      dekodiraj1(u);
  333.                                                                                                                      w:=w+'+'+w1;
  334.                                                                                                                     end
  335.                                                                                                                else begin
  336.                                                                                                                      dekodiraj1(v);
  337.                                                                                                                      w1:=w;
  338.                                                                                                                      w:='';
  339.                                                                                                                      inc_uzet;
  340.                                                                                                                      dekodiraj1(u);
  341.                                                                                                                      w1:='('+w+'+'+w1+')';
  342.                                                                                                                      w:='';
  343.                                                                                                                      inc_uzet;
  344.                                                                                                                      dekodiraj1(v1);
  345.                                                                                                                      w:=w+'-'+w1;
  346.                                                                                                                     end;
  347.                                                                                       if najbl=zad then ispisi;
  348.                                                                                      end;
  349.                                if abs((niz[u]+niz[v])*niz[v1]-zad)<abs(najbl-zad) then begin
  350.                                                                                       najbl:=(niz[u]+niz[v])*niz[v1];
  351.                                                                                       w:='';
  352.                                                                                       inc_uzet;
  353.                                                                                       dekodiraj1(v1);
  354.                                                                                       if lpl then w1:='('+w+')'
  355.                                                                                              else w1:=w;
  356.                                                                                       w:='';
  357.                                                                                       inc_uzet;
  358.                                                                                       dekodiraj1(v);
  359.                                                                                       w1:=w+')*'+w1;
  360.                                                                                       w:='';
  361.                                                                                       inc_uzet;
  362.                                                                                       dekodiraj1(u);
  363.                                                                                       w:='('+w+'+'+w1;
  364.                                                                                       if najbl=zad then ispisi;
  365.                                                                                      end;
  366.                                if (niz[v1]>0) and ((niz[u]+niz[v]) mod niz[v1]=0) then
  367.                                if abs((niz[u]+niz[v]) div niz[v1]-zad)<abs(najbl-zad) then begin
  368.                                                                                       najbl:=(niz[u]+niz[v]) div niz[v1];
  369.                                                                                       w:='';
  370.                                                                                       inc_uzet;
  371.                                                                                       dekodiraj1(v1);
  372.                                                                                       if v1<7 then w1:=w
  373.                                                                                               else w1:='('+w+')';
  374.                                                                                       w:='';
  375.                                                                                       inc_uzet;
  376.                                                                                       dekodiraj1(v);
  377.                                                                                       w1:=w+')/'+w1;
  378.                                                                                       w:='';
  379.                                                                                       inc_uzet;
  380.                                                                                       dekodiraj1(u);
  381.                                                                                       w:='('+w+'+'+w1;
  382.                                                                                       if najbl=zad then ispisi;
  383.                                                                                      end
  384.                                                                                       else
  385.                                                                                   else
  386.                                if (niz[u]+niz[v]>0) and (niz[v1] mod (niz[u]+niz[v])=0) then
  387.                                if abs(niz[v1] div (niz[u]+niz[v])-zad)<abs(najbl-zad) then begin
  388.                                                                                       najbl:=niz[v] div (niz[u]+niz[v]);
  389.                                                                                       w:='';
  390.                                                                                       inc_uzet;
  391.                                                                                       dekodiraj1(v);
  392.                                                                                       w1:=w+')';
  393.                                                                                       w:='';
  394.                                                                                       inc_uzet;
  395.                                                                                       dekodiraj1(u);
  396.                                                                                       w1:='('+w+'+'+w1;
  397.                                                                                       w:='';
  398.                                                                                       inc_uzet;
  399.                                                                                       dekodiraj1(v1);
  400.                                                                                       if lpl then w:='('+w+')/'+w1
  401.                                                                                              else w:=w+'/'+w1;
  402.                                                                                       if najbl=zad then ispisi;
  403.                                                                                      end;
  404. //prvu dvojicu oduzimamo
  405.                                if abs(abs(niz[u]-niz[v])*niz[v1]-zad)<abs(najbl-zad) then begin
  406.                                                                                       najbl:=abs(niz[u]-niz[v])*niz[v1];
  407.                                                                                       w:='';
  408.                                                                                       inc_uzet;
  409.                                                                                       dekodiraj1(v1);
  410.                                                                                       if lpl then w1:='('+w+')'
  411.                                                                                              else w1:=w;
  412.                                                                                       w:='';
  413.                                                                                       inc_uzet;
  414.                                                                                       if niz[u]>niz[v] then begin
  415.                                                                                                              dekodiraj1(v);
  416.                                                                                                              if lpl then w1:='('+w+'))*'+w1
  417.                                                                                                                     else w1:=w+')*'+w1;
  418.                                                                                                              w:='';
  419.                                                                                                              inc_uzet;
  420.                                                                                                              dekodiraj1(u);
  421.                                                                                                             end
  422.                                                                                                        else begin
  423.                                                                                                              dekodiraj1(u);
  424.                                                                                                              if lpl then w1:='('+w+'))*'+w1
  425.                                                                                                                     else w1:=w+')*'+w1;
  426.                                                                                                              w:='';
  427.                                                                                                              inc_uzet;
  428.                                                                                                              dekodiraj1(v);
  429.                                                                                                             end;
  430.                                                                                       w:='('+w+'-'+w1;
  431.                                                                                       if najbl=zad then ispisi;
  432.                                                                                      end;
  433.                                if (niz[v1]>0) and (abs(niz[u]-niz[v]) mod niz[v1]=0) then
  434.                                if abs(abs(niz[u]-niz[v]) div niz[v1]-zad)<abs(najbl-zad) then begin
  435.                                                                                       najbl:=abs(niz[u]-niz[v]) div niz[v1];
  436.                                                                                       w:='';
  437.                                                                                       inc_uzet;
  438.                                                                                       dekodiraj1(v1);
  439.                                                                                       if v1<7 then w1:=w
  440.                                                                                               else w1:='('+w+')';
  441.                                                                                       w:='';
  442.                                                                                       inc_uzet;
  443.                                                                                       if niz[u]>niz[v] then begin
  444.                                                                                                              dekodiraj1(v);
  445.                                                                                                              if lpl then w1:='('+w+'))/'+w1
  446.                                                                                                                     else w1:=w+')/'+w1;
  447.                                                                                                              w:='';
  448.                                                                                                              inc_uzet;
  449.                                                                                                              dekodiraj1(u);
  450.                                                                                                             end
  451.                                                                                                        else begin
  452.                                                                                                              dekodiraj1(u);
  453.                                                                                                              if lpl then w1:='('+w+'))/'+w1
  454.                                                                                                                     else w1:=w+')/'+w1;
  455.                                                                                                              w:='';
  456.                                                                                                              inc_uzet;
  457.                                                                                                              dekodiraj1(v);
  458.                                                                                                             end;
  459.                                                                                       w:='('+w+'-'+w1;
  460.                                                                                       if najbl=zad then ispisi;
  461.                                                                                      end
  462.                                                                                       else
  463.                                                                                   else
  464.                                if (abs(niz[u]-niz[v])>0) and (niz[v1] mod abs(niz[u]-niz[v])=0) then
  465.                                if abs(niz[v1] div abs(niz[u]-niz[v])-zad)<abs(najbl-zad) then begin
  466.                                                                                       najbl:=niz[v1] div abs(niz[u]-niz[v]);
  467.                                                                                       w:='';
  468.                                                                                       inc_uzet;
  469.                                                                                       if niz[u]>niz[v] then begin
  470.                                                                                                              dekodiraj1(v);
  471.                                                                                                              if lpl then w1:='('+w+'))'
  472.                                                                                                                     else w1:=w+')';
  473.                                                                                                              w:='';
  474.                                                                                                              inc_uzet;
  475.                                                                                                              dekodiraj1(u);
  476.                                                                                                             end
  477.                                                                                                        else begin
  478.                                                                                                              dekodiraj1(u);
  479.                                                                                                              if lpl then w1:='('+w+'))'
  480.                                                                                                                     else w1:=w+')';
  481.                                                                                                              w:='';
  482.                                                                                                              inc_uzet;
  483.                                                                                                              dekodiraj1(v);
  484.                                                                                                             end;
  485.                                                                                       w1:='('+w+'-'+w1;
  486.                                                                                       w:='';
  487.                                                                                       inc_uzet;
  488.                                                                                       dekodiraj1(v1);
  489.                                                                                       if lpl then w:='('+w+')/'+w1
  490.                                                                                              else w:=w+'/'+w1;
  491.                                                                                       if najbl=zad then ispisi;
  492.                                                                                      end;
  493. //prvu dvojicu mnozimo
  494.                                if abs(niz[u]*niz[v]+niz[v1]-zad)<abs(najbl-zad) then begin
  495.                                                                                       najbl:=niz[u]*niz[v]+niz[v1];
  496.                                                                                       w:='';
  497.                                                                                       inc_uzet;
  498.                                                                                       dekodiraj1(v1);
  499.                                                                                       w1:=w;
  500.                                                                                       w:='';
  501.                                                                                       inc_uzet;
  502.                                                                                       dekodiraj1(v);
  503.                                                                                       if lpl then w1:='('+w+')+'+w1
  504.                                                                                              else w1:=w+'+'+w1;
  505.                                                                                       w:='';
  506.                                                                                       inc_uzet;
  507.                                                                                       dekodiraj1(u);
  508.                                                                                       if lpl then w:='('+w+')*'+w1
  509.                                                                                              else w:=w+'*'+w1;
  510.                                                                                       if najbl=zad then ispisi;
  511.                                                                                      end;
  512.                                if abs(abs(niz[u]*niz[v]-niz[v1])-zad)<abs(najbl-zad) then begin
  513.                                                                                       najbl:=abs(niz[u]*niz[v]-niz[v1]);
  514.                                                                                       w:='';
  515.                                                                                       inc_uzet;
  516.                                                                                       if niz[u]*niz[v]>niz[v1] then begin
  517.                                                                                                                      dekodiraj1(v1);
  518.                                                                                                                      if lpl then w1:='('+w+')'
  519.                                                                                                                             else w1:=w;
  520.                                                                                                                      w:='';
  521.                                                                                                                      inc_uzet;
  522.                                                                                                                      dekodiraj1(v);
  523.                                                                                                                      if lpl then w1:='('+w+')-'+w1
  524.                                                                                                                             else w1:=w+'-'+w1;
  525.                                                                                                                      w:='';
  526.                                                                                                                      inc_uzet;
  527.                                                                                                                      dekodiraj1(u);
  528.                                                                                                                      if lpl then w:='('+w+')*'+w1
  529.                                                                                                                             else w:=w+'*'+w1;
  530.                                                                                                                     end
  531.                                                                                                                else begin
  532.                                                                                                                      dekodiraj1(v);
  533.                                                                                                                      if lpl then w1:='('+w+')'
  534.                                                                                                                             else w1:=w;
  535.                                                                                                                      w:='';
  536.                                                                                                                      inc_uzet;
  537.                                                                                                                      dekodiraj1(u);
  538.                                                                                                                      if lpl then w1:='('+w+')*'+w1
  539.                                                                                                                             else w1:=w+'*'+w1;
  540.                                                                                                                      w:='';
  541.                                                                                                                      inc_uzet;
  542.                                                                                                                      dekodiraj1(v1);
  543.                                                                                                                      w:=w+'-'+w1;
  544.                                                                                                                     end;
  545.                                                                                       if najbl=zad then ispisi;
  546.                                                                                      end;
  547.                                if abs(niz[u]*niz[v]*niz[v1]-zad)<abs(najbl-zad) then begin
  548.                                                                                       najbl:=niz[u]*niz[v]*niz[v1];
  549.                                                                                       w:='';
  550.                                                                                       inc_uzet;
  551.                                                                                       dekodiraj1(v1);
  552.                                                                                       if lpl then w1:='('+w+')'
  553.                                                                                              else w1:=w;
  554.                                                                                       w:='';
  555.                                                                                       inc_uzet;
  556.                                                                                       dekodiraj1(v);
  557.                                                                                       if lpl then w1:='('+w+')*'+w1
  558.                                                                                              else w1:=w+'*'+w1;
  559.                                                                                       w:='';
  560.                                                                                       inc_uzet;
  561.                                                                                       dekodiraj1(u);
  562.                                                                                       if lpl then w:='('+w+')*'+w1
  563.                                                                                              else w:=w+'*'+w1;
  564.                                                                                       if najbl=zad then ispisi;
  565.                                                                                      end;
  566.                                if (niz[v1]>0) and (niz[u]*niz[v] mod niz[v1]=0) then
  567.                                if abs(niz[u]*niz[v] div niz[v1]-zad)<abs(najbl-zad) then begin
  568.                                                                                       najbl:=niz[u]*niz[v] div niz[v1];
  569.                                                                                       w:='';
  570.                                                                                       inc_uzet;
  571.                                                                                       dekodiraj1(v1);
  572.                                                                                       if v1<7 then w1:=w
  573.                                                                                               else w1:='('+w+')';
  574.                                                                                       w:='';
  575.                                                                                       inc_uzet;
  576.                                                                                       dekodiraj1(v);
  577.                                                                                       if lpl then w1:='('+w+')/'+w1
  578.                                                                                              else w1:=w+'/'+w1;
  579.                                                                                       w:='';
  580.                                                                                       inc_uzet;
  581.                                                                                       dekodiraj1(u);
  582.                                                                                       if lpl then w:='('+w+')*'+w1
  583.                                                                                              else w:=w+'*'+w1;
  584.                                                                                       if najbl=zad then ispisi;
  585.                                                                                      end
  586.                                                                                       else
  587.                                                                                   else
  588.                                if (niz[u]*niz[v]>0) and (niz[v1] mod (niz[u]*niz[v])=0) then
  589.                                if abs(niz[v1] div (niz[u]*niz[v])-zad)<abs(najbl-zad) then begin
  590.                                                                                       najbl:=niz[v] div (niz[u]*niz[v]);
  591.                                                                                       w:='';
  592.                                                                                       inc_uzet;
  593.                                                                                       dekodiraj1(v);
  594.                                                                                       if lpl then w1:='('+w+'))'
  595.                                                                                              else w1:=w+')';
  596.                                                                                       w:='';
  597.                                                                                       inc_uzet;
  598.                                                                                       dekodiraj1(u);
  599.                                                                                       if lpl then w1:='(('+w+')*'+w1
  600.                                                                                              else w1:='('+w+'*'+w1;
  601.                                                                                       w:='';
  602.                                                                                       inc_uzet;
  603.                                                                                       dekodiraj1(v1);
  604.                                                                                       if lpl then w:='('+w+')/'+w1
  605.                                                                                              else w:=w+'/'+w1;
  606.                                                                                       if najbl=zad then ispisi;
  607.                                                                                      end;
  608. //prvu dvojicu delimo
  609.                                if (niz[v]>0) and (niz[u] mod niz[v]=0) then
  610.                               begin
  611.                                if abs(niz[u] div niz[v]+niz[v1]-zad)<abs(najbl-zad) then begin
  612.                                                                                       najbl:=niz[u] div niz[v]+niz[v1];
  613.                                                                                       w:='';
  614.                                                                                       inc_uzet;
  615.                                                                                       dekodiraj1(v1);
  616.                                                                                       w1:=w;
  617.                                                                                       w:='';
  618.                                                                                       inc_uzet;
  619.                                                                                       dekodiraj1(v);
  620.                                                                                       w1:='('+w+')+'+w1;
  621.                                                                                       w:='';
  622.                                                                                       inc_uzet;
  623.                                                                                       dekodiraj1(u);
  624.                                                                                       if lpl then w:='('+w+')/'+w1
  625.                                                                                              else w:=w+'/'+w1;
  626.                                                                                       if najbl=zad then ispisi;
  627.                                                                                      end;
  628.                                if abs(abs(niz[u] div niz[v]-niz[v1])-zad)<abs(najbl-zad) then begin
  629.                                                                                       najbl:=abs(niz[u] div niz[v]-niz[v1]);
  630.                                                                                       w:='';
  631.                                                                                       inc_uzet;
  632.                                                                                       if niz[u] div niz[v]>niz[v1] then begin
  633.                                                                                                                          dekodiraj1(v1);
  634.                                                                                                                          if lpl then w1:='('+w+')'
  635.                                                                                                                                 else w1:=w;
  636.                                                                                                                          w:='';
  637.                                                                                                                          inc_uzet;
  638.                                                                                                                          dekodiraj1(v);
  639.                                                                                                                          w1:='('+w+')-'+w1;
  640.                                                                                                                          w:='';
  641.                                                                                                                          inc_uzet;
  642.                                                                                                                          dekodiraj1(u);
  643.                                                                                                                          if lpl then w:='('+w+')/'+w1
  644.                                                                                                                                 else w:=w+'/'+w1;
  645.                                                                                                                         end
  646.                                                                                                                    else begin
  647.                                                                                                                          dekodiraj1(v);
  648.                                                                                                                          w1:='('+w+')';
  649.                                                                                                                          w:='';
  650.                                                                                                                          inc_uzet;
  651.                                                                                                                          dekodiraj1(u);
  652.                                                                                                                          if lpl then w1:='('+w+')/'+w1
  653.                                                                                                                                 else w1:=w+'/'+w1;
  654.                                                                                                                          w:='';
  655.                                                                                                                          inc_uzet;
  656.                                                                                                                          dekodiraj1(v1);
  657.                                                                                                                          w:=w+'-'+w1;
  658.                                                                                                                         end;
  659.                                                                                       if najbl=zad then ispisi;
  660.                                                                                      end;
  661.                               end
  662.                          else if (niz[u]>0) and (niz[v] mod niz[u]=0) then
  663.                               begin
  664.                                if abs(niz[v] div niz[u]+niz[v1]-zad)<abs(najbl-zad) then begin
  665.                                                                                       najbl:=niz[v] div niz[u]+niz[v1];
  666.                                                                                       w:='';
  667.                                                                                       inc_uzet;
  668.                                                                                       dekodiraj1(v1);
  669.                                                                                       w1:=w;
  670.                                                                                       w:='';
  671.                                                                                       inc_uzet;
  672.                                                                                       dekodiraj1(u);
  673.                                                                                       w1:='('+w+')+'+w1;
  674.                                                                                       w:='';
  675.                                                                                       inc_uzet;
  676.                                                                                       dekodiraj1(v);
  677.                                                                                       if lpl then w:='('+w+')/'+w1
  678.                                                                                              else w:=w+'/'+w1;
  679.                                                                                       if najbl=zad then ispisi;
  680.                                                                                      end;
  681.                                if abs(abs(niz[v] div niz[u]-niz[v1])-zad)<abs(najbl-zad) then begin
  682.                                                                                       najbl:=abs(niz[v] div niz[u]-niz[v1]);
  683.                                                                                       w:='';
  684.                                                                                       inc_uzet;
  685.                                                                                       if niz[v] div niz[u]>niz[v1] then begin
  686.                                                                                                                          dekodiraj1(v1);
  687.                                                                                                                          if lpl then w1:='('+w+')'
  688.                                                                                                                                 else w1:=w;
  689.                                                                                                                          w:='';
  690.                                                                                                                          inc_uzet;
  691.                                                                                                                          dekodiraj1(u);
  692.                                                                                                                          w1:='('+w+')-'+w1;
  693.                                                                                                                          w:='';
  694.                                                                                                                          inc_uzet;
  695.                                                                                                                          dekodiraj1(v);
  696.                                                                                                                          if lpl then w:='('+w+')/'+w1
  697.                                                                                                                                 else w:=w+'/'+w1;
  698.                                                                                                                         end
  699.                                                                                                                    else begin
  700.                                                                                                                          dekodiraj1(u);
  701.                                                                                                                          w1:='('+w+')';
  702.                                                                                                                          w:='';
  703.                                                                                                                          inc_uzet;
  704.                                                                                                                          dekodiraj1(v);
  705.                                                                                                                          if lpl then w1:='('+w+')/'+w1
  706.                                                                                                                                 else w1:=w+'/'+w1;
  707.                                                                                                                          w:='';
  708.                                                                                                                          inc_uzet;
  709.                                                                                                                          dekodiraj1(v1);
  710.                                                                                                                          w:=w+'-'+w1;
  711.                                                                                                                         end;
  712.                                                                                       if najbl=zad then ispisi;
  713.                                                                                      end;
  714.                               end;
  715.                               end;
  716.                    end;
  717.                 end;
  718.      end;
  719. end;
  720. begin
  721.  readln(zad);
  722.  for u:=1 to 6 do
  723.    begin
  724.     read(niz[u]);
  725.     if niz[u]=zad then begin
  726.                         writeln(zad);
  727.                         writeln(zad);
  728.                         repeat until keypressed;
  729.                         halt(0);
  730.                        end;
  731.    end;
  732.  pok:=7;
  733.  w:='';
  734.  for u:=1 to 209406 do
  735.    uradi(u);
  736.  najbl:=0;
  737.  resi_6;
  738.  resi_3_3;
  739.  resi_2_2_2;
  740.  writeln(najbl);
  741.  writeln(w);
  742.  repeat until keypressed;
  743. end.
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!