Subversion Repositories wimsdev

Rev

Rev 795 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 795 Rev 17893
Line 9... Line 9...
9
        argv[5] = \comparaison1
9
        argv[5] = \comparaison1
10
        argv[6] = \vrai1
10
        argv[6] = \vrai1
11
        argv[7] = \faux1
11
        argv[7] = \faux1
12
        argv[8] = \branchement1
12
        argv[8] = \branchement1
13
        argv[9] = \comparaison2
13
        argv[9] = \comparaison2
14
        argv[10]= \vrai2
14
        argv[10]= \vrai2
15
        argv[11]= \faux2
15
        argv[11]= \faux2
16
        argv[12]= \branchement2
16
        argv[12]= \branchement2
17
        argv[13]= \comparaison3
17
        argv[13]= \comparaison3
18
        argv[14]= \confparm1
18
        argv[14]= \confparm1
19
*/
19
*/
20
int main(argc,argv)
20
int main(int argc,char *argv[])
21
        int argc;
-
 
22
        char *argv[];
-
 
23
{
21
{
24
       
-
 
25
        int a;
22
        int a;
26
        int b;
23
        int b;
27
        int c;
24
        int c;
28
        int vrai1;
25
        int vrai1;
29
        int faux1;
26
        int faux1;
30
        int branchement1;
27
        int branchement1;
31
        int vrai2;
28
        int vrai2;
32
        int faux2;
29
        int faux2;
33
        int branchement2;
30
        int branchement2;
34
        int niveau;
31
        int niveau;
35
        char comparaison1[7];
32
        char comparaison1[7];
36
        char comparaison2[7];
33
        char comparaison2[7];
37
        char comparaison3[7];
34
        char comparaison3[7];
38
       
35
 
39
        sscanf(argv[2],"%d",&a);
36
        sscanf(argv[2],"%d",&a);
40
        sscanf(argv[3],"%d",&b);
37
        sscanf(argv[3],"%d",&b);
41
        sscanf(argv[4],"%d",&c);
38
        sscanf(argv[4],"%d",&c);
42
        strcpy(comparaison1,argv[5]);
39
        strcpy(comparaison1,argv[5]);
43
        sscanf(argv[6],"%d",&vrai1);
40
        sscanf(argv[6],"%d",&vrai1);
Line 47... Line 44...
47
        sscanf(argv[10],"%d",&vrai2);
44
        sscanf(argv[10],"%d",&vrai2);
48
        sscanf(argv[11],"%d",&faux2);
45
        sscanf(argv[11],"%d",&faux2);
49
        sscanf(argv[12],"%d",&branchement2);
46
        sscanf(argv[12],"%d",&branchement2);
50
        strcpy(comparaison3,argv[13]);
47
        strcpy(comparaison3,argv[13]);
51
        sscanf(argv[14],"%d",&niveau);
48
        sscanf(argv[14],"%d",&niveau);
52
       
49
 
53
        int cmp1 = ((strcmp(comparaison1,"&#62")==0) ? 0 : -1) ;
50
        int cmp1 = ((strcmp(comparaison1,"&#62")==0) ? 0 : -1) ;
54
        int cmp2 = ((strcmp(comparaison2,"&#60")==0) ? 0 : 1) ;
51
        int cmp2 = ((strcmp(comparaison2,"&#60")==0) ? 0 : 1) ;
55
        int cmp3 = ((strcmp(comparaison3,"&#60")==0) ? 0 : 1) ;
52
        int cmp3 = ((strcmp(comparaison3,"&#60")==0) ? 0 : 1) ;
56
 
53
 
57
        if (niveau==1)
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)
58
        {
93
        {
59
                if (b>a+cmp1)
94
                if (b>a+cmp1)
-
 
95
                {
60
                        b=b+vrai1;
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
                }
61
        }
124
        }
-
 
125
 
62
       
126
 
63
        else if (niveau==2)
127
        else if (niveau==5)
64
        {
128
        {
65
                if (b>a+cmp1)
129
                if (b>a+cmp1)
-
 
130
                {
66
                        b=b+vrai1;
131
                        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)
132
                        if (branchement1==1)
77
                        {
133
                        {
78
                                if (a<c+cmp2 && b<c+cmp2)
134
                                if (a<c+cmp2 && b<c+cmp2)
-
 
135
                                {
79
                                        c=c-vrai2;             
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
                                }
80
                        }
159
                        }
81
                }
160
                }
82
                else
161
                else
83
                {
162
                {
84
                        a=a+faux1;
163
                        a=a+faux1;
85
                        if (branchement1==0)
164
                        if (branchement1==0)
86
                        {
165
                        {
87
                                if (a<c+cmp2 && b<c+cmp2)
166
                                if (a<c+cmp2 && b<c+cmp2)
-
 
167
                                {
88
                                        c=c-vrai2;             
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
                                }
89
                        }
191
                        }
-
 
192
                }
-
 
193
        }
90
 
194
 
91
                }
-
 
92
        }
-
 
93
       
-
 
94
       
-
 
95
        else if (niveau==4)
195
        else if (niveau==6)
96
        {
196
        {
97
                if (b>a+cmp1)
197
                if (b>a+cmp1)
98
                {
198
                {
99
                        b=b+vrai1;
199
                        b=b+vrai1;
100
                        if (branchement1==1)
200
                        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
                        {
201
                        {
137
                                if (a<c+cmp2 && b<c+cmp2)
202
                                if (a<c+cmp2 && b<c+cmp2)
138
                                {
203
                                {
139
                                        c=c-vrai2;
204
                                        c=c-vrai2;
140
                                        if (branchement2==1)
205
                                        if (branchement2==1)
141
                                        {
206
                                        {
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 )
207
                                                if ( a+b<c+cmp3 || b-a < cmp3+c-b )
156
                                                {
208
                                                {
157
                                                        a++;
209
                                                        a++;
158
                                                        b++;
210
                                                        b++;
159
                                                }
211
                                                }
160
                                        }
-
 
161
                                }              
-
 
162
                        }
-
 
163
                }
-
 
164
                else
212
                                                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
                                                {
213
                                                {
176
                                                        a++;
214
                                                        a--;
177
                                                        b++;
215
                                                        b--;
178
                                                }
216
                                                }
179
                                        }
217
                                        }
180
                                }
218
                                }
181
                                else
219
                                else
182
                                {
220
                                {
183
                                        c=c+faux2;
221
                                        c=c+faux2;
184
                                        a++;
222
                                        a++;
185
                                        if (branchement2==0)
223
                                        if (branchement2==0)
186
                                        {
224
                                        {
187
                                                if ( a+b<c+cmp3 || b-a < cmp3+c-b )
225
                                                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
                                                {
226
                                                {
212
                                                        a++;
227
                                                        a++;
213
                                                        b++;
228
                                                        b++;
214
                                                }
229
                                                }
215
                                                else
230
                                                else
Line 217... Line 232...
217
                                                        a--;
232
                                                        a--;
218
                                                        b--;
233
                                                        b--;
219
                                                }
234
                                                }
220
                                        }
235
                                        }
221
                                }
236
                                }
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
                        }
237
                        }
241
                }
238
                }
242
                else
239
                else
243
                {
240
                {
244
                        a=a+faux1;
241
                        a=a+faux1;
245
                        if (branchement1==0)
242
                        if (branchement1==0)
246
                        {
243
                        {
247
                                if (a<c+cmp2 && b<c+cmp2)
244
                                if (a<c+cmp2 && b<c+cmp2)
248
                                {
245
                                {
249
                                        c=c-vrai2;
246
                                        c=c-vrai2;
250
                                        if (branchement2==1)
247
                                        if (branchement2==1)
251
                                        {
248
                                        {
252
                                                if ( a+b<c+cmp3 || b-a < cmp3+c-b )
249
                                                if ( a+b<c+cmp3 || b-a < cmp3+c-b )
253
                                                {
250
                                                {
254
                                                        a++;
251
                                                        a++;
255
                                                        b++;
252
                                                        b++;
256
                                                }
253
                                                }
257
                                                else
254
                                                else
Line 263... Line 260...
263
                                }
260
                                }
264
                                else
261
                                else
265
                                {
262
                                {
266
                                        c=c+faux2;
263
                                        c=c+faux2;
267
                                        a++;
264
                                        a++;
268
                                        if (branchement2==0)
265
                                        if (branchement2==0)
269
                                        {
266
                                        {
270
                                                if ( a+b<c+cmp3 || b-a < cmp3+c-b )
267
                                                if ( a+b<c+cmp3 || b-a < cmp3+c-b )
271
                                                {
268
                                                {
272
                                                        a++;
269
                                                        a++;
273
                                                        b++;
270
                                                        b++;
274
                                                }
271
                                                }
275
                                                else
272
                                                else