Subversion Repositories wimsdev

Rev

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