Subversion Repositories wimsdev

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. #include<stdio.h>
  2. #include<string.h>
  3.  
  4. /* Entrees :
  5.         argv[1] = nom du prog
  6.         argv[2] = \a
  7.         argv[3] = \b
  8.         argv[4] = \c
  9.         argv[5] = \comparaison1
  10.         argv[6] = \vrai1
  11.         argv[7] = \faux1
  12.         argv[8] = \branchement1
  13.         argv[9] = \comparaison2
  14.         argv[10]= \vrai2
  15.         argv[11]= \faux2
  16.         argv[12]= \branchement2
  17.         argv[13]= \comparaison3
  18.         argv[14]= \confparm1
  19. */
  20. int main(argc,argv)
  21.         int argc;
  22.         char *argv[];
  23. {
  24.        
  25.         int a;
  26.         int b;
  27.         int c;
  28.         int vrai1;
  29.         int faux1;
  30.         int branchement1;
  31.         int vrai2;
  32.         int faux2;
  33.         int branchement2;
  34.         int niveau;
  35.         char comparaison1[7];
  36.         char comparaison2[7];
  37.         char comparaison3[7];
  38.        
  39.         sscanf(argv[2],"%d",&a);
  40.         sscanf(argv[3],"%d",&b);
  41.         sscanf(argv[4],"%d",&c);
  42.         strcpy(comparaison1,argv[5]);
  43.         sscanf(argv[6],"%d",&vrai1);
  44.         sscanf(argv[7],"%d",&faux1);
  45.         sscanf(argv[8],"%d",&branchement1);
  46.         strcpy(comparaison2,argv[9]);
  47.         sscanf(argv[10],"%d",&vrai2);
  48.         sscanf(argv[11],"%d",&faux2);
  49.         sscanf(argv[12],"%d",&branchement2);
  50.         strcpy(comparaison3,argv[13]);
  51.         sscanf(argv[14],"%d",&niveau);
  52.        
  53.         int cmp1 = ((strcmp(comparaison1,"&#62")==0) ? 0 : -1) ;
  54.         int cmp2 = ((strcmp(comparaison2,"&#60")==0) ? 0 : 1) ;
  55.         int cmp3 = ((strcmp(comparaison3,"&#60")==0) ? 0 : 1) ;
  56.  
  57.         if (niveau==1)
  58.         {
  59.                 if (b>a+cmp1)
  60.                         b=b+vrai1;
  61.         }
  62.        
  63.         else if (niveau==2)
  64.         {
  65.                 if (b>a+cmp1)
  66.                         b=b+vrai1;
  67.                 else
  68.                         a=a+faux1;
  69.         }
  70.        
  71.         else if (niveau==3)
  72.         {
  73.                 if (b>a+cmp1)
  74.                 {
  75.                         b=b+vrai1;
  76.                         if (branchement1==1)
  77.                         {
  78.                                 if (a<c+cmp2 && b<c+cmp2)
  79.                                         c=c-vrai2;             
  80.                         }
  81.                 }
  82.                 else
  83.                 {
  84.                         a=a+faux1;
  85.                         if (branchement1==0)
  86.                         {
  87.                                 if (a<c+cmp2 && b<c+cmp2)
  88.                                         c=c-vrai2;             
  89.                         }
  90.  
  91.                 }
  92.         }
  93.        
  94.        
  95.         else if (niveau==4)
  96.         {
  97.                 if (b>a+cmp1)
  98.                 {
  99.                         b=b+vrai1;
  100.                         if (branchement1==1)
  101.                         {
  102.                                 if (a<c+cmp2 && b<c+cmp2)
  103.                                         c=c-vrai2;
  104.                                 else
  105.                                 {
  106.                                         c=c+faux2;
  107.                                         a++;
  108.                                 }              
  109.                         }
  110.                 }
  111.                 else
  112.                 {
  113.                         a=a+faux1;
  114.                         if (branchement1==0)
  115.                         {
  116.                                 if (a<c+cmp2 && b<c+cmp2)
  117.                                         c=c-vrai2;     
  118.                                 else
  119.                                 {
  120.                                         c=c+faux2;
  121.                                         a++;
  122.                                 }              
  123.        
  124.                         }
  125.  
  126.                 }
  127.         }      
  128.        
  129.        
  130.         else if (niveau==5)
  131.         {
  132.                 if (b>a+cmp1)
  133.                 {
  134.                         b=b+vrai1;
  135.                         if (branchement1==1)
  136.                         {
  137.                                 if (a<c+cmp2 && b<c+cmp2)
  138.                                 {
  139.                                         c=c-vrai2;
  140.                                         if (branchement2==1)
  141.                                         {
  142.                                                 if ( a+b<c+cmp3 || b-a < cmp3+c-b )
  143.                                                 {
  144.                                                         a++;
  145.                                                         b++;
  146.                                                 }
  147.                                         }
  148.                                 }
  149.                                 else
  150.                                 {
  151.                                         c=c+faux2;
  152.                                         a++;
  153.                                         if (branchement2==0)
  154.                                         {
  155.                                                 if ( a+b<c+cmp3 || b-a < cmp3+c-b )
  156.                                                 {
  157.                                                         a++;
  158.                                                         b++;
  159.                                                 }
  160.                                         }
  161.                                 }              
  162.                         }
  163.                 }
  164.                 else
  165.                 {
  166.                         a=a+faux1;
  167.                         if (branchement1==0)
  168.                         {
  169.                                 if (a<c+cmp2 && b<c+cmp2)
  170.                                 {
  171.                                         c=c-vrai2;
  172.                                         if (branchement2==1)
  173.                                         {
  174.                                                 if ( a+b<c+cmp3 || b-a < cmp3+c-b )
  175.                                                 {
  176.                                                         a++;
  177.                                                         b++;
  178.                                                 }
  179.                                         }
  180.                                 }
  181.                                 else
  182.                                 {
  183.                                         c=c+faux2;
  184.                                         a++;
  185.                                         if (branchement2==0)
  186.                                         {
  187.                                                 if ( a+b<c+cmp3 || b-a < cmp3+c-b )
  188.                                                 {
  189.                                                         a++;
  190.                                                         b++;
  191.                                                 }
  192.                                         }
  193.                                 }              
  194.                         }
  195.                 }
  196.         }
  197.        
  198.         else if (niveau==6)
  199.         {
  200.                 if (b>a+cmp1)
  201.                 {
  202.                         b=b+vrai1;
  203.                         if (branchement1==1)
  204.                         {
  205.                                 if (a<c+cmp2 && b<c+cmp2)
  206.                                 {
  207.                                         c=c-vrai2;
  208.                                         if (branchement2==1)
  209.                                         {
  210.                                                 if ( a+b<c+cmp3 || b-a < cmp3+c-b )
  211.                                                 {
  212.                                                         a++;
  213.                                                         b++;
  214.                                                 }
  215.                                                 else
  216.                                                 {
  217.                                                         a--;
  218.                                                         b--;
  219.                                                 }
  220.                                         }
  221.                                 }
  222.                                 else
  223.                                 {
  224.                                         c=c+faux2;
  225.                                         a++;
  226.                                         if (branchement2==0)
  227.                                         {
  228.                                                 if ( a+b<c+cmp3 || b-a < cmp3+c-b )
  229.                                                 {
  230.                                                         a++;
  231.                                                         b++;
  232.                                                 }
  233.                                                 else
  234.                                                 {
  235.                                                         a--;
  236.                                                         b--;
  237.                                                 }
  238.                                         }
  239.                                 }              
  240.                         }
  241.                 }
  242.                 else
  243.                 {
  244.                         a=a+faux1;
  245.                         if (branchement1==0)
  246.                         {
  247.                                 if (a<c+cmp2 && b<c+cmp2)
  248.                                 {
  249.                                         c=c-vrai2;
  250.                                         if (branchement2==1)
  251.                                         {
  252.                                                 if ( a+b<c+cmp3 || b-a < cmp3+c-b )
  253.                                                 {
  254.                                                         a++;
  255.                                                         b++;
  256.                                                 }
  257.                                                 else
  258.                                                 {
  259.                                                         a--;
  260.                                                         b--;
  261.                                                 }
  262.                                         }
  263.                                 }
  264.                                 else
  265.                                 {
  266.                                         c=c+faux2;
  267.                                         a++;
  268.                                         if (branchement2==0)
  269.                                         {
  270.                                                 if ( a+b<c+cmp3 || b-a < cmp3+c-b )
  271.                                                 {
  272.                                                         a++;
  273.                                                         b++;
  274.                                                 }
  275.                                                 else
  276.                                                 {
  277.                                                         a--;
  278.                                                         b--;
  279.                                                 }
  280.                                         }
  281.                                 }
  282.                         }
  283.                 }
  284.         }
  285.  
  286.         printf("%d,%d,%d\n",a,b,c);
  287.   return 0;
  288.  
  289. }
  290.