/*
 Flippo

 Dit programma vindt oplossingen van de 'Flippo' puzzeltjes
 Van 4 getallen moet je 24 maken, door ze allen precies 1 keer
 te gebruiken in een sommetje met slechts + - * /

 Het probeert gewoon alles uit. En vaak zelfs te veel doordat het niet rekening
 houdt met:
 -commutativiteit en associativiteit van + en *
 -vaker voorkomen van hetzelfde cijfer
  (8 8 3 3 geeft zodoende 4 gelijke oplossingen)

 6 (7) februari 1996
*/

import java.applet.Applet;
import java.awt.*;

public class flippo extends Applet 
  {  int in[]={8,8,3,3};
     int uit=24;
     double fout=0.01;

     public double op(double x, double y, int o)
         { switch (o)
           { case 0: return x+y;
             case 1: return x-y;
             case 2: return x*y;
             case 3: if (y!=0) return x/y; else return 10000;
             default: return 0;
           }
         }
     
     char ops[]={'+','-','*','/'};

     public double abs(double x) { return x<0 ? -x : x;  }
     
     TextField tf1,tf2,tf3,tf4,tf5;   
     Button b;

     public void init()
      { tf1= new TextField(String.valueOf(in[0]),5); 
        tf2= new TextField(String.valueOf(in[1]),5);
        tf3= new TextField(String.valueOf(in[2]),5);
        tf4= new TextField(String.valueOf(in[3]),5);
        tf5= new TextField(String.valueOf(uit),5);
        add(tf1); add(tf2); add(tf3); add(tf4); add(tf5);
        b = new Button("reken");
        add(b);
      }

    public boolean action(Event e, Object arg)
          { Object target=e.target;
            if(target==b) { in[0]=Integer.parseInt(tf1.getText().trim());
                            in[1]=Integer.parseInt(tf2.getText().trim());
                            in[2]=Integer.parseInt(tf3.getText().trim());
                            in[3]=Integer.parseInt(tf4.getText().trim());
                            uit=Integer.parseInt(tf5.getText().trim());
                       // dit begrijp ik niet (afgekeken)
                          
                            repaint(); 
                            return true;
                          }
             return false;
           }                            
  
     public void paint(Graphics g) 
           {
 /*
   Te verkoming van gepruts en ter nutte van de snelheid hier alle
   permutaties van 4 getallen.
   Jammer dat dit slecht te generaliseren is tot bv. 5 getallen.....
   (dan toch beter loops bedenken)
 */
              int perm[][]={{0,1,2,3},
                   {0,1,3,2},
                   {0,2,1,3},
                   {0,2,3,1},
                   {0,3,1,2},
                   {0,3,2,1},
                   {1,0,2,3},
                   {1,0,3,2},
                   {1,2,0,3},
                   {1,2,3,0},
                   {1,3,0,2},
                   {1,3,2,0},
                   {2,0,1,3},
                   {2,0,3,1},
                   {2,1,0,3},
                   {2,1,3,0},
                   {2,3,0,1},
                   {2,3,1,0},
                   {3,0,1,2},
                   {3,0,2,1},
                   {3,1,0,2},
                   {3,1,2,0},
                   {3,2,0,1},
                   {3,2,1,0}};

             int n[] = new int[4]; //hier staat de permutatie van de getallen in die bekeken wordt.
             int i,j; // i: permutaties j: el. van permutatie
             int o1,o2,o3; //: waarden van de 3 operatoren. 4^3 mogelelijkheden.
             double u1,u2,u3,u4,u5; //:uitkomsten bij de 5 verschillende haakjesplaatsingen.
             int ra=13;
             int r=6;
             
             g.drawString("gevonden oplossingen:",0,r*ra); r++;
              for (i=0; i<24; i++)
               { for(j=0; j<4; j++) n[j]=in[perm[i][j]];
                 for (o1=0; o1<4; o1++)
                 for (o2=0; o2<4; o2++)
                 for (o3=0; o3<4; o3++)
                 { u1=op(op(op(n[0],n[1],o1),n[2],o2),n[3],o3);
                   if (abs(u1-uit)<fout)
                              {   g.drawString("((" +n[0] + ops[o1] +n[1] + ")"
                                            +ops[o2] + n[2] +")" + ops[o3] +  n[3] +"=" +u1,0,r*ra); 
                                  r++;
                              }
                   u2=op(op(n[0],op(n[1],n[2],o2),o1),n[3],o3);
                   if (abs(u2-uit)<fout)
                               {  g.drawString("(" + n[0] +ops[o1] + "(" +n[1]
                                                +ops[o2] + n[2] + "))" + ops[o3] +n[3] +"=" + u2,0,r*ra);
                                  r++;
                                }
                   u3=op(op(n[0],n[1],o1),op(n[2],n[3],o3),o2);
                   if (abs(u3-uit)<fout)
                                { g.drawString("("+ n[0] + ops[o1] + n[1] +")"+ ops[o2] 
                                 +  "(" + n[2] +  ops[o3] + n[3] +") =" +u3,0,r*ra); r++;}
                   u4=op(n[0],op(op(n[1],n[2],o2),n[3],o3),o1);
                   if (abs(u4-uit)<fout)
                                 {g.drawString("" + n[0] + ops[o1]+"((" + n[1] + ops[o2] +n[2] +")" + 
                        ops[o3]  + n[3] +") = " + u4,0,r*ra); r++;}
                   u5=op(n[0],op(n[1],op(n[2],n[3],o3),o2),o1);
                   if (abs(u5-uit)<fout)
                                 {g.drawString("" + n[0] + ops[o1] +"(" + n[1] + ops[o2]
                                  +"("+ n[2] + ops[o3] + n[3] + ")) = " + u5,0,r*ra);r++;}

                }
              }
          g.drawString(".",0,r*ra);r++;
          resize(200,r*ra);
}}