type
stringclasses 4
values | content_without_mask
stringlengths 610
1.37M
| content_masked
stringlengths 609
1.37M
| label
stringclasses 362
values | options
sequencelengths 5
5
| correct
stringclasses 5
values |
|---|---|---|---|---|---|
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int A [ ], int B [ ], int n ) {
unordered_set < int > mp;
int result = 0;
int curr_sum = 0, curr_begin = 0;
for ( int i = 0;
i < n;
++ i ) {
while ( mp . find ( A [ i ] ) != mp . end ( ) ) {
mp . erase ( A [ curr_begin ] );
curr_sum -= B [ curr_begin ];
curr_begin ++;
}
mp . insert ( A [ i ] );
curr_sum += B [ i ];
result = max ( result, curr_sum );
}
return result;
}
int f_filled ( int A [ ], int B [ ], int n ) {}
n ];
curr_begin ++;
}
mp . insert ( A [ i ] );
curr_sum += B [ i ];
result = max ( result, curr_sum );
}
return result;
}
int f_filled ( int A [ ], int B [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,8,10,10,16,23,33,36,43,47,50,55,56,72,84,85,86,86,88,90,92,99};
int param0_1[] = {48,-22,84,76,50,-14,-82,28,86,-50,-40,10,48,20,-48,-84,-64,-48,-32,-84,-32,10,42,-10,-68,-16,-94,-76,42,-96,16,-64,60,8,-88,-62,82,-24,-28,40,18,8};
int param0_2[] = {0,0,0,1};
int param0_3[] = {74,64,93,72,75,90,46,72,91,98,57,58,76,29,88,3,86,1,78,74,56,54,57,3,94,2,14,32,67,62,1,30,78,95,40};
int param0_4[] = {-94,-88,-68,-24,60,94};
int param0_5[] = {0,0,0,0,0,1,0,0,1,0,0,0,0,1,1,0,0,0,0,0,1,0,1,0,1,1,1,0,0};
int param0_6[] = {3,7,12,15,17,23,31,31,32,37,41,54,57,60,62,62,64,70,71,74,75,83,97,98};
int param0_7[] = {-2,26,-74,96,-70,56,92,-74,-38,-18,36,44,-10,-26,26,-22,-58,78,86,22,76,50,88,-86,-80,-36,-48,90,-34,62,46,-56,-32};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {86,30,87,99,8,1,24,46,12,21,43,73,28,3,35,49,14,37,63,98,65,43,86,69,27,60,45,88,25,86,11,9,86,73,40,70,49,50,95,69,94};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1_0[] = {8,26,30,35,45,47,55,56,59,61,64,66,67,69,73,77,78,81,82,85,86,99};
int param1_1[] = {82,94,34,12,18,-68,14,-16,-30,-16,6,74,-68,76,-76,52,-32,-38,78,64,-60,-46,82,-60,98,-70,-52,-96,-6,-44,66,-66,22,-42,-66,4,-2,-48,-94,72,56,88};
int param1_2[] = {0,0,1,1};
int param1_3[] = {9,50,22,60,36,46,76,48,90,64,16,24,41,12,36,36,93,52,26,38,68,5,55,19,35,5,7,96,67,64,24,85,6,33,7};
int param1_4[] = {-80,-72,-60,-42,-24,-6};
int param1_5[] = {1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,0,1,1,0,1,1,1,1,1,0};
int param1_6[] = {3,10,10,12,12,14,15,19,19,20,25,27,27,28,40,41,50,51,53,57,60,65,75,99};
int param1_7[] = {76,42,0,4,-96,-24,-50,-54,26,-8,-38,-46,42,-50,16,-2,-6,2,-8,56,64,-58,-96,2,-64,-66,-14,58,-76,-26,78,-96,48};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {27,66,77,34,98,75,43,27,79,32,54,40,29,47,63,15,23,33,59,76,27,31,92,43,12,20,97,67,11,12,83,79,52,46,51,36,87,96,90,6,62};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2[] = {20,30,2,20,4,22,22,17,39,34};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < [MASK] x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int A [ ], int B [ ], int n ) { unordered_set < int > mp; int result = 0; int curr_sum = 0, curr_begin = 0; for ( int i = 0; i < n; ++ i ) { while ( mp . find ( A [ i ] ) != mp . end ( ) ) { mp . erase ( A [ curr_begin ] ); curr_sum -= B [ curr_begin ]; curr_begin ++; } mp . insert ( A [ i ] ); curr_sum += B [ i ]; result = max ( result, curr_sum ); } return result; } int f_filled ( int A [ ], int B [ ], int n ) {}n ];
curr_begin ++;
}
mp . insert ( A [ i ] );
curr_sum += B [ i ];
result = max ( result, curr_sum );
}
return result;
}
int f_filled ( int A [ ], int B [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,8,10,10,16,23,33,36,43,47,50,55,56,72,84,85,86,86,88,90,92,99};
int param0_1[] = {48,-22,84,76,50,-14,-82,28,86,-50,-40,10,48,20,-48,-84,-64,-48,-32,-84,-32,10,42,-10,-68,-16,-94,-76,42,-96,16,-64,60,8,-88,-62,82,-24,-28,40,18,8};
int param0_2[] = {0,0,0,1};
int param0_3[] = {74,64,93,72,75,90,46,72,91,98,57,58,76,29,88,3,86,1,78,74,56,54,57,3,94,2,14,32,67,62,1,30,78,95,40};
int param0_4[] = {-94,-88,-68,-24,60,94};
int param0_5[] = {0,0,0,0,0,1,0,0,1,0,0,0,0,1,1,0,0,0,0,0,1,0,1,0,1,1,1,0,0};
int param0_6[] = {3,7,12,15,17,23,31,31,32,37,41,54,57,60,62,62,64,70,71,74,75,83,97,98};
int param0_7[] = {-2,26,-74,96,-70,56,92,-74,-38,-18,36,44,-10,-26,26,-22,-58,78,86,22,76,50,88,-86,-80,-36,-48,90,-34,62,46,-56,-32};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {86,30,87,99,8,1,24,46,12,21,43,73,28,3,35,49,14,37,63,98,65,43,86,69,27,60,45,88,25,86,11,9,86,73,40,70,49,50,95,69,94};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1_0[] = {8,26,30,35,45,47,55,56,59,61,64,66,67,69,73,77,78,81,82,85,86,99};
int param1_1[] = {82,94,34,12,18,-68,14,-16,-30,-16,6,74,-68,76,-76,52,-32,-38,78,64,-60,-46,82,-60,98,-70,-52,-96,-6,-44,66,-66,22,-42,-66,4,-2,-48,-94,72,56,88};
int param1_2[] = {0,0,1,1};
int param1_3[] = {9,50,22,60,36,46,76,48,90,64,16,24,41,12,36,36,93,52,26,38,68,5,55,19,35,5,7,96,67,64,24,85,6,33,7};
int param1_4[] = {-80,-72,-60,-42,-24,-6};
int param1_5[] = {1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,0,1,1,0,1,1,1,1,1,0};
int param1_6[] = {3,10,10,12,12,14,15,19,19,20,25,27,27,28,40,41,50,51,53,57,60,65,75,99};
int param1_7[] = {76,42,0,4,-96,-24,-50,-54,26,-8,-38,-46,42,-50,16,-2,-6,2,-8,56,64,-58,-96,2,-64,-66,-14,58,-76,-26,78,-96,48};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {27,66,77,34,98,75,43,27,79,32,54,40,29,47,63,15,23,33,59,76,27,31,92,43,12,20,97,67,11,12,83,79,52,46,51,36,87,96,90,6,62};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2[] = {20,30,2,20,4,22,22,17,39,34};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | y)? | [
"a) y)?",
"b) /",
"c) ;",
"d) ];",
"e) }"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int arr [ ], int n ) {
for ( int i = 0;
i <= ( n - 2 ) / 2;
i ++ ) {
if ( arr [ 2 * i + 1 ] > arr [ i ] ) return false;
if ( 2 * i + 2 < n && arr [ 2 * i + 2 ] > arr [ i ] ) return false;
}
return true;
}
bool f_filled ( int arr [ ], int n ) {}
++ ) {
if ( arr [ 2 * i + 1 ] > arr [ i ] ) return false;
if ( 2 * i + 2 < n && arr [ 2 * i + 2 ] > arr [ i ] ) return false;
}
return true;
}
bool f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,2,2,7,10,14,24,38,42,50,59,60,72,73,79,83,89};
int param0_1[] = {-48,98,96,-56,-2,58,52,-50,58,50,62,86,-26,-98,34,20,-28,56,-36};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {91,50,37};
int param0_4[] = {-80,-26,0,0,6,14,22,76,82,88,98};
int param0_5[] = {1,0};
int param0_6[] = {9,24,24,33,48,50,55,61,69,79,83};
int param0_7[] = {30,32,-82,-48,88,-24,74,2,90,98,68,82,32,-60,2,-94,18,14,46,50,-60,-74,-76,66,-76,-34,-20,82,-44,-62,34,48,-56,2,64,-78,-64,98,-10,-28,78,-42};
int param0_8[] = {0,0,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {38,74,99,75,44,75,24,70,78,74,60,59,34,27,7,23,19,95,4,35,38,22,46,1,44,20,52,1,96,57,5,76,49,1,37,35};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {9,9,20,2,10,1,8,27,6,31};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc [MASK] void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int arr [ ], int n ) { for ( int i = 0; i <= ( n - 2 ) / 2; i ++ ) { if ( arr [ 2 * i + 1 ] > arr [ i ] ) return false; if ( 2 * i + 2 < n && arr [ 2 * i + 2 ] > arr [ i ] ) return false; } return true; } bool f_filled ( int arr [ ], int n ) {} ++ ) {
if ( arr [ 2 * i + 1 ] > arr [ i ] ) return false;
if ( 2 * i + 2 < n && arr [ 2 * i + 2 ] > arr [ i ] ) return false;
}
return true;
}
bool f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,2,2,7,10,14,24,38,42,50,59,60,72,73,79,83,89};
int param0_1[] = {-48,98,96,-56,-2,58,52,-50,58,50,62,86,-26,-98,34,20,-28,56,-36};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {91,50,37};
int param0_4[] = {-80,-26,0,0,6,14,22,76,82,88,98};
int param0_5[] = {1,0};
int param0_6[] = {9,24,24,33,48,50,55,61,69,79,83};
int param0_7[] = {30,32,-82,-48,88,-24,74,2,90,98,68,82,32,-60,2,-94,18,14,46,50,-60,-74,-76,66,-76,-34,-20,82,-44,-62,34,48,-56,2,64,-78,-64,98,-10,-28,78,-42};
int param0_8[] = {0,0,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {38,74,99,75,44,75,24,70,78,74,60,59,34,27,7,23,19,95,4,35,38,22,46,1,44,20,52,1,96,57,5,76,49,1,37,35};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {9,9,20,2,10,1,8,27,6,31};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | (const | [
"a) c",
"b) if",
"c) .",
"d) (const",
"e) }"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n, int x, int k ) {
int i = 0;
while ( i < n ) {
if ( arr [ i ] == x ) return i;
i = i + max ( 1, abs ( arr [ i ] - x ) / k );
}
printf("number is not present!");
return - 1;
}
int f_filled ( int arr [ ], int n, int x, int k ) {}
if ( arr [ i ] == x ) return i;
i = i + max ( 1, abs ( arr [ i ] - x ) / k );
}
printf("number is not present!");
return - 1;
}
int f_filled ( int arr [ ], int n, int x, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,5,9,11,14,18,19,21,26,32,38,38,43,47,49,52,55,61,65,67,69,73,74,79,84,90,91,91,92,93,94,99};
int param0_1[] = {12,-86,-66,-50,-48,78,-92,-56,-2,66,64};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {10,87,39,87,45,33,5,37,70,69,88,78,90,3};
int param0_4[] = {-78,-70,-68,-60,-52,-34,-24,-4,12,18,58,58,64,76,84,94};
int param0_5[] = {0,1,0,1,1,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,1,0,0,1,1,1,0,1,0,1,0,0,1,1,0,0,1,0,1,0,1,0};
int param0_6[] = {5,5,7,11,11,15,22,23,28,38,41,53,54,57,59,68,71,89};
int param0_7[] = {-4,0,60,-14,-48,54,-96,-68,-40,64,-50,-74,-20,-22,48,-48,42,62,66,84,54,-52,-52,6,46,-90,-18,90};
int param0_8[] = {0,0,0,0,0,0,0,1,1,1,1,1};
int param0_9[] = {30,91,34,44,3,76,43,75,49,33,74,72,68,79,26,62,23,5,32,75,82,25,7,19,32,87,87,94,34,62,3,32,59};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {22,5,35,9,14,26,16,18,9,32};
int param2[] = {19,10,37,8,9,36,17,14,8,30};
int param3[] = {26,5,43,10,13,32,16,23,9,24};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("number is not present!");
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n, int x, int k ) { int i = 0; while ( i < n ) { if ( arr [ i ] == x ) return i; i = i + max ( 1, abs ( arr [ i ] - x ) / k ); } printf("number is not present!"); [MASK] - 1; } int f_filled ( int arr [ ], int n, int x, int k ) {}
if ( arr [ i ] == x ) return i;
i = i + max ( 1, abs ( arr [ i ] - x ) / k );
}
printf("number is not present!");
return - 1;
}
int f_filled ( int arr [ ], int n, int x, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,5,9,11,14,18,19,21,26,32,38,38,43,47,49,52,55,61,65,67,69,73,74,79,84,90,91,91,92,93,94,99};
int param0_1[] = {12,-86,-66,-50,-48,78,-92,-56,-2,66,64};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {10,87,39,87,45,33,5,37,70,69,88,78,90,3};
int param0_4[] = {-78,-70,-68,-60,-52,-34,-24,-4,12,18,58,58,64,76,84,94};
int param0_5[] = {0,1,0,1,1,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,1,0,0,1,1,1,0,1,0,1,0,0,1,1,0,0,1,0,1,0,1,0};
int param0_6[] = {5,5,7,11,11,15,22,23,28,38,41,53,54,57,59,68,71,89};
int param0_7[] = {-4,0,60,-14,-48,54,-96,-68,-40,64,-50,-74,-20,-22,48,-48,42,62,66,84,54,-52,-52,6,46,-90,-18,90};
int param0_8[] = {0,0,0,0,0,0,0,1,1,1,1,1};
int param0_9[] = {30,91,34,44,3,76,43,75,49,33,74,72,68,79,26,62,23,5,32,75,82,25,7,19,32,87,87,94,34,62,3,32,59};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {22,5,35,9,14,26,16,18,9,32};
int param2[] = {19,10,37,8,9,36,17,14,8,30};
int param3[] = {26,5,43,10,13,32,16,23,9,24};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("number is not present!");
return 0;
} | return | [
"a) [",
"b) int",
"c) :",
"d) return",
"e) ["
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( unsigned int n ) {
return n & ( n - 1 );
}
int f_filled ( unsigned int n ) {}
of (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( unsigned int n ) {
return n & ( n - 1 );
}
int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {9,54,60,32,41,64,4,51,57,92};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> [MASK] <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( unsigned int n ) { return n & ( n - 1 ); } int f_filled ( unsigned int n ) {}of (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( unsigned int n ) {
return n & ( n - 1 );
}
int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {9,54,60,32,41,64,4,51,57,92};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include | [
"a) <string>",
"b) )",
"c) #include",
"d) )",
"e) 1"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( string & isbn ) {
int n = strlen(isbn);
if ( n != 10 ) return false;
int sum = 0;
for ( int i = 0;
i < 9;
i ++ ) {
int digit = isbn [ i ] - '0';
if ( 0 > digit || 9 < digit ) return false;
sum += ( digit * ( 10 - i ) );
}
char last = isbn [ 9 ];
if ( last != 'X' && ( last < '0' || last > '9' ) ) return false;
sum += ( ( last == 'X' ) ? 10 : ( last - '0' ) );
return ( sum % 11 == 0 );
}
bool f_filled ( string & isbn ) {}
isbn [ 9 ];
if ( last != 'X' && ( last < '0' || last > '9' ) ) return false;
sum += ( ( last == 'X' ) ? 10 : ( last - '0' ) );
return ( sum % 11 == 0 );
}
bool f_filled ( string & isbn ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"007462542X","0112112425","0545010225","0552527408","424519151311","101011","9780552527408","2290344397","1473226406","DDdguSGiRr"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( string & isbn ) { int n = strlen(isbn); if ( n != [MASK] ) return false; int sum = 0; for ( int i = 0; i < 9; i ++ ) { int digit = isbn [ i ] - '0'; if ( 0 > digit || 9 < digit ) return false; sum += ( digit * ( 10 - i ) ); } char last = isbn [ 9 ]; if ( last != 'X' && ( last < '0' || last > '9' ) ) return false; sum += ( ( last == 'X' ) ? 10 : ( last - '0' ) ); return ( sum % 11 == 0 ); } bool f_filled ( string & isbn ) {}isbn [ 9 ];
if ( last != 'X' && ( last < '0' || last > '9' ) ) return false;
sum += ( ( last == 'X' ) ? 10 : ( last - '0' ) );
return ( sum % 11 == 0 );
}
bool f_filled ( string & isbn ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"007462542X","0112112425","0545010225","0552527408","424519151311","101011","9780552527408","2290344397","1473226406","DDdguSGiRr"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | 10 | [
"a) 10",
"b) )",
"c) (",
"d) f_filled",
"e) ["
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int arr [ ], int n ) {
int max = * max_element ( arr, arr + n );
int min = * min_element ( arr, arr + n );
int m = max - min + 1;
if ( m > n ) return false;
bool visited [ m ];
memset ( visited, false, sizeof ( visited ) );
for ( int i = 0;
i < n;
i ++ ) visited [ arr [ i ] - min ] = true;
for ( int i = 0;
i < m;
i ++ ) if ( visited [ i ] == false ) return false;
return true;
}
bool f_filled ( int arr [ ], int n ) {}
0;
i < n;
i ++ ) visited [ arr [ i ] - min ] = true;
for ( int i = 0;
i < m;
i ++ ) if ( visited [ i ] == false ) return false;
return true;
}
bool f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,4,19,25,65,72,75,83,90,92};
int param0_1[] = {46,2,28,-44,74,-36,-8,30,-96,60,52,-58,16,-38,78,38,-28,16,26,-42,48,40,6,72};
int param0_2[] = {0,1,1,1};
int param0_3[] = {50,21,9,29,86,2,82,49,34,18,77,83,44,67,85,58,15,85,22,3,39,67,42,37,6,35,18,57,41,32,39,30,41,68,84,36,64,36};
int param0_4[] = {-92,-82,-80,-78,-66,-66,-62,-58,-54,-52,-48,-30,-26,-22,-20,-20,-18,-14,-2,12,20,24,26,26,28,28,32,36,42,48,50,52,56,64,70,72,72,80,82,84,86,92};
int param0_5[] = {1,0,0,1,0,0,1,0,0,1,1,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,1,1,0,0,1,1,0,1,1,1,0,0,1,0,1,0,0,0,0};
int param0_6[] = {18,19,21,23,30,33,38,40,45,56,63,68,93,96};
int param0_7[] = {20,-90,-42,48,18,-46,82,-12,-88,82,62,24,20,64,-68,-34,-38,8,-54,-20,-92,34,-90,78,18,8,-6,10,98,-24,72,-92,76,-22,12,-44,2,68,-72,42,34,20,-48};
int param0_8[] = {0,0,0,0,0,1,1,1,1};
int param0_9[] = {81,25,50,48,35,38,49,21,47,94,94,55,23,45,92,23,93,33,64,9,90,64,81,17,2,73,8,7,35,36,72};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {8,14,2,23,26,43,8,34,8,27};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int arr [ ], int n ) { int max = * max_element ( arr, arr + n ); int min = * min_element ( arr, arr + n ); int m = max - min + 1; if ( m > n ) return false; bool visited [ m ]; memset ( visited, false, sizeof ( visited ) ); for ( int i = 0; i < [MASK] i ++ ) visited [ arr [ i ] - min ] = true; for ( int i = 0; i < m; i ++ ) if ( visited [ i ] == false ) return false; return true; } bool f_filled ( int arr [ ], int n ) {} 0;
i < n;
i ++ ) visited [ arr [ i ] - min ] = true;
for ( int i = 0;
i < m;
i ++ ) if ( visited [ i ] == false ) return false;
return true;
}
bool f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,4,19,25,65,72,75,83,90,92};
int param0_1[] = {46,2,28,-44,74,-36,-8,30,-96,60,52,-58,16,-38,78,38,-28,16,26,-42,48,40,6,72};
int param0_2[] = {0,1,1,1};
int param0_3[] = {50,21,9,29,86,2,82,49,34,18,77,83,44,67,85,58,15,85,22,3,39,67,42,37,6,35,18,57,41,32,39,30,41,68,84,36,64,36};
int param0_4[] = {-92,-82,-80,-78,-66,-66,-62,-58,-54,-52,-48,-30,-26,-22,-20,-20,-18,-14,-2,12,20,24,26,26,28,28,32,36,42,48,50,52,56,64,70,72,72,80,82,84,86,92};
int param0_5[] = {1,0,0,1,0,0,1,0,0,1,1,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,1,1,0,0,1,1,0,1,1,1,0,0,1,0,1,0,0,0,0};
int param0_6[] = {18,19,21,23,30,33,38,40,45,56,63,68,93,96};
int param0_7[] = {20,-90,-42,48,18,-46,82,-12,-88,82,62,24,20,64,-68,-34,-38,8,-54,-20,-92,34,-90,78,18,8,-6,10,98,-24,72,-92,76,-22,12,-44,2,68,-72,42,34,20,-48};
int param0_8[] = {0,0,0,0,0,1,1,1,1};
int param0_9[] = {81,25,50,48,35,38,49,21,47,94,94,55,23,45,92,23,93,33,64,9,90,64,81,17,2,73,8,7,35,36,72};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {8,14,2,23,26,43,8,34,8,27};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | n; | [
"a) (",
"b) )",
"c) if",
"d) +",
"e) n;"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char symb [ ], char oper [ ], int n ) {
int F [ n ] [ n ], T [ n ] [ n ];
for ( int i = 0;
i < n;
i ++ ) {
F [ i ] [ i ] = ( symb [ i ] == 'F' ) ? 1 : 0;
T [ i ] [ i ] = ( symb [ i ] == 'T' ) ? 1 : 0;
}
for ( int gap = 1;
gap < n;
++ gap ) {
for ( int i = 0, j = gap;
j < n;
++ i, ++ j ) {
T [ i ] [ j ] = F [ i ] [ j ] = 0;
for ( int g = 0;
g < gap;
g ++ ) {
int k = i + g;
int tik = T [ i ] [ k ] + F [ i ] [ k ];
int tkj = T [ k + 1 ] [ j ] + F [ k + 1 ] [ j ];
if ( oper [ k ] == '&' ) {
T [ i ] [ j ] += T [ i ] [ k ] * T [ k + 1 ] [ j ];
F [ i ] [ j ] += ( tik * tkj - T [ i ] [ k ] * T [ k + 1 ] [ j ] );
}
if ( oper [ k ] == '|' ) {
F [ i ] [ j ] += F [ i ] [ k ] * F [ k + 1 ] [ j ];
T [ i ] [ j ] += ( tik * tkj - F [ i ] [ k ] * F [ k + 1 ] [ j ] );
}
if ( oper [ k ] == '^' ) {
T [ i ] [ j ] += F [ i ] [ k ] * T [ k + 1 ] [ j ] + T [ i ] [ k ] * F [ k + 1 ] [ j ];
F [ i ] [ j ] += T [ i ] [ k ] * T [ k + 1 ] [ j ] + F [ i ] [ k ] * F [ k + 1 ] [ j ];
}
}
}
}
return T [ 0 ] [ n - 1 ];
}
int f_filled ( char symb [ ], char oper [ ], int n ) {}
] [ j ] += T [ i ] [ k ] * T [ k + 1 ] [ j ] + F [ i ] [ k ] * F [ k + 1 ] [ j ];
}
}
}
}
return T [ 0 ] [ n - 1 ];
}
int f_filled ( char symb [ ], char oper [ ], int n ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {
"TTFT",
"TFT",
"TFF",
"TTFT",
"TTFT",
"TTFT",
"TTFT",
"TTFT",
"TTFT",
"TTFT"
};
char param1[][100] = {
"|&^",
"^&",
"^|",
"|||",
"&&&",
"&&^",
"^&|",
"^^^",
"^||",
"|^|"
};
int param2[] = {4,3,3,4,4,4,4,4,4,4};
for(int i = 0; i < len(param0); ++i)
{
char* arr0 = new char[param0[i].length() + 1];
arr0 = strncpy(arr0, param0[i].c_str(), sizeof(arr0));
char* arr1 = new char[param1[i].length() + 1];
arr1 = strncpy(arr1, param1[i].c_str(), sizeof(arr1));
if(f_filled(arr0,arr1,param2[i]) == f_gold(arr0,arr1,param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char symb [ ], char oper [ ], int n ) { int F [ n ] [ n ], T [ n ] [ n ]; for ( int i = 0; i < n; i ++ ) { F [ i ] [ i ] = ( symb [ i ] == 'F' ) ? 1 : 0; T [ i ] [ i ] = ( symb [MASK] i ] == 'T' ) ? 1 : 0; } for ( int gap = 1; gap < n; ++ gap ) { for ( int i = 0, j = gap; j < n; ++ i, ++ j ) { T [ i ] [ j ] = F [ i ] [ j ] = 0; for ( int g = 0; g < gap; g ++ ) { int k = i + g; int tik = T [ i ] [ k ] + F [ i ] [ k ]; int tkj = T [ k + 1 ] [ j ] + F [ k + 1 ] [ j ]; if ( oper [ k ] == '&' ) { T [ i ] [ j ] += T [ i ] [ k ] * T [ k + 1 ] [ j ]; F [ i ] [ j ] += ( tik * tkj - T [ i ] [ k ] * T [ k + 1 ] [ j ] ); } if ( oper [ k ] == '|' ) { F [ i ] [ j ] += F [ i ] [ k ] * F [ k + 1 ] [ j ]; T [ i ] [ j ] += ( tik * tkj - F [ i ] [ k ] * F [ k + 1 ] [ j ] ); } if ( oper [ k ] == '^' ) { T [ i ] [ j ] += F [ i ] [ k ] * T [ k + 1 ] [ j ] + T [ i ] [ k ] * F [ k + 1 ] [ j ]; F [ i ] [ j ] += T [ i ] [ k ] * T [ k + 1 ] [ j ] + F [ i ] [ k ] * F [ k + 1 ] [ j ]; } } } } return T [ 0 ] [ n - 1 ]; } int f_filled ( char symb [ ], char oper [ ], int n ) {}] [ j ] += T [ i ] [ k ] * T [ k + 1 ] [ j ] + F [ i ] [ k ] * F [ k + 1 ] [ j ];
}
}
}
}
return T [ 0 ] [ n - 1 ];
}
int f_filled ( char symb [ ], char oper [ ], int n ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {
"TTFT",
"TFT",
"TFF",
"TTFT",
"TTFT",
"TTFT",
"TTFT",
"TTFT",
"TTFT",
"TTFT"
};
char param1[][100] = {
"|&^",
"^&",
"^|",
"|||",
"&&&",
"&&^",
"^&|",
"^^^",
"^||",
"|^|"
};
int param2[] = {4,3,3,4,4,4,4,4,4,4};
for(int i = 0; i < len(param0); ++i)
{
char* arr0 = new char[param0[i].length() + 1];
arr0 = strncpy(arr0, param0[i].c_str(), sizeof(arr0));
char* arr1 = new char[param1[i].length() + 1];
arr1 = strncpy(arr1, param1[i].c_str(), sizeof(arr1));
if(f_filled(arr0,arr1,param2[i]) == f_gold(arr0,arr1,param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | [ | [
"a) [",
"b) i",
"c) )",
"d) )",
"e) import"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char s [ ], char t [ ] ) {
int count = 0;
for ( int i = 0;
i < strlen ( t );
i ++ ) {
if ( count == strlen ( s ) ) break;
if ( t [ i ] == s [ count ] ) count ++;
}
return count;
}
int f_filled ( char s [ ], char t [ ] ) {}
or ( int i = 0;
i < strlen ( t );
i ++ ) {
if ( count == strlen ( s ) ) break;
if ( t [ i ] == s [ count ] ) count ++;
}
return count;
}
int f_filled ( char s [ ], char t [ ] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"nObYIOjEQZ","84574","1010001010010","DjZtAfUudk","550","1110","GywyxwH","67318370914755","11011000000101","G"};
char param1[][100] = {"uARTDTQbmGI","8538229","11","OewGm","132744553919","0101","LPQqEqrDZiwY","9928","00000","V"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(¶m0[i].front(),¶m1[i].front()) == f_gold(¶m0[i].front(),¶m1[i].front()))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char s [ ], char t [ ] ) { int count = 0; for ( int i = 0; i < strlen ( t ); i ++ ) [MASK] if ( count == strlen ( s ) ) break; if ( t [ i ] == s [ count ] ) count ++; } return count; } int f_filled ( char s [ ], char t [ ] ) {}or ( int i = 0;
i < strlen ( t );
i ++ ) {
if ( count == strlen ( s ) ) break;
if ( t [ i ] == s [ count ] ) count ++;
}
return count;
}
int f_filled ( char s [ ], char t [ ] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"nObYIOjEQZ","84574","1010001010010","DjZtAfUudk","550","1110","GywyxwH","67318370914755","11011000000101","G"};
char param1[][100] = {"uARTDTQbmGI","8538229","11","OewGm","132744553919","0101","LPQqEqrDZiwY","9928","00000","V"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(¶m0[i].front(),¶m1[i].front()) == f_gold(¶m0[i].front(),¶m1[i].front()))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | { | [
"a) arr",
"b) );",
"c) x:",
"d) {",
"e) ="
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int N, int insert, int remove, int copy ) {
if ( N == 0 ) return 0;
if ( N == 1 ) return insert;
int dp [ N + 1 ];
memset ( dp, 0, sizeof ( dp ) );
for ( int i = 1;
i <= N;
i ++ ) {
if ( i % 2 == 0 ) dp [ i ] = min ( dp [ i - 1 ] + insert, dp [ i / 2 ] + copy );
else dp [ i ] = min ( dp [ i - 1 ] + insert, dp [ ( i + 1 ) / 2 ] + copy + remove );
}
return dp [ N ];
}
int f_filled ( int N, int insert, int remove, int copy ) {}
p [ i / 2 ] + copy );
else dp [ i ] = min ( dp [ i - 1 ] + insert, dp [ ( i + 1 ) / 2 ] + copy + remove );
}
return dp [ N ];
}
int f_filled ( int N, int insert, int remove, int copy ) {}
int main(void) {
int n_success = 0;
int param0[] = {59,66,98,63,99,45,60,11,96,54};
int param1[] = {75,68,55,4,37,28,53,96,95,6};
int param2[] = {12,32,69,41,98,59,40,50,48,50};
int param3[] = {45,41,5,12,55,7,52,50,84,82};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > [MASK] x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int N, int insert, int remove, int copy ) { if ( N == 0 ) return 0; if ( N == 1 ) return insert; int dp [ N + 1 ]; memset ( dp, 0, sizeof ( dp ) ); for ( int i = 1; i <= N; i ++ ) { if ( i % 2 == 0 ) dp [ i ] = min ( dp [ i - 1 ] + insert, dp [ i / 2 ] + copy ); else dp [ i ] = min ( dp [ i - 1 ] + insert, dp [ ( i + 1 ) / 2 ] + copy + remove ); } return dp [ N ]; } int f_filled ( int N, int insert, int remove, int copy ) {}p [ i / 2 ] + copy );
else dp [ i ] = min ( dp [ i - 1 ] + insert, dp [ ( i + 1 ) / 2 ] + copy + remove );
}
return dp [ N ];
}
int f_filled ( int N, int insert, int remove, int copy ) {}
int main(void) {
int n_success = 0;
int param0[] = {59,66,98,63,99,45,60,11,96,54};
int param1[] = {75,68,55,4,37,28,53,96,95,6};
int param2[] = {12,32,69,41,98,59,40,50,48,50};
int param3[] = {45,41,5,12,55,7,52,50,84,82};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | y)? | [
"a) y)?",
"b) return",
"c) (",
"d) )",
"e) )"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n, int num, int maxLimit ) {
int ind;
int val;
int dp [ n ] [ maxLimit + 1 ];
for ( ind = 0;
ind < n;
ind ++ ) {
for ( val = 0;
val <= maxLimit;
val ++ ) {
if ( ind == 0 ) {
if ( num - arr [ ind ] == val || num + arr [ ind ] == val ) {
dp [ ind ] [ val ] = 1;
}
else {
dp [ ind ] [ val ] = 0;
}
}
else {
if ( val - arr [ ind ] >= 0 && val + arr [ ind ] <= maxLimit ) {
dp [ ind ] [ val ] = dp [ ind - 1 ] [ val - arr [ ind ] ] || dp [ ind - 1 ] [ val + arr [ ind ] ];
}
else if ( val - arr [ ind ] >= 0 ) {
dp [ ind ] [ val ] = dp [ ind - 1 ] [ val - arr [ ind ] ];
}
else if ( val + arr [ ind ] <= maxLimit ) {
dp [ ind ] [ val ] = dp [ ind - 1 ] [ val + arr [ ind ] ];
}
else {
dp [ ind ] [ val ] = 0;
}
}
}
}
for ( val = maxLimit;
val >= 0;
val -- ) {
if ( dp [ n - 1 ] [ val ] ) {
return val;
}
}
return - 1;
}
int f_filled ( int arr [ ], int n, int num, int maxLimit ) {}
}
}
for ( val = maxLimit;
val >= 0;
val -- ) {
if ( dp [ n - 1 ] [ val ] ) {
return val;
}
}
return - 1;
}
int f_filled ( int arr [ ], int n, int num, int maxLimit ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,4,5,8,9,10,10,11,13,15,17,19,27,31,34,35,36,36,36,38,41,46,48,49,50,53,56,57,60,62,63,64,66,67,69,69,81,82,83,89,92,93,95,99};
int param0_1[] = {-44,-14,36,12,-12,-6,-84,46,72,-26,-50,-6};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1};
int param0_3[] = {9,67,80,48,75,21,5,39,6,93,2,81,75,69,75,30,46,60,51,61};
int param0_4[] = {-98,-82,-74,-70,-66,-62,-54,-52,-50,-34,-34,-30,-22,-20,-16,-16,-14,-4,-4,-2,0,6,10,10,12,12,14,16,18,32,38,38,48,54,58,66,66,68,78,82,86,86,88,92,96};
int param0_5[] = {0,0,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,0,1,1,1,1,0,1,1,0,1,1,0,1,0,0,1,0,0,1,0};
int param0_6[] = {5,7,8,10,15,16,16,21,25,29,31,34,36,39,41,41,44,45,48,59,64,74,78,81,85,93,97};
int param0_7[] = {-28,44,-16,-42,58,-98,22,48,66,-60,74,24,-78,-62,86,-24,20,-64,74,-66,16,24,80,-4,-22,80,-88,0,54,-26,-26,-80,-96,-98,52,-32,86,-10,-82,-64,14};
int param0_8[] = {0,1,1};
int param0_9[] = {6,87,85,44,87,42,76,23,94,53,23,88,49,10,78,61,94,11,55,47,16,96,51,26,75,33,25,85,13,85,14,17,22,18,20,72,55};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {25,10,9,19,26,24,25,25,1,22};
int param2[] = {39,11,6,15,23,26,25,37,1,19};
int param3[] = {42,10,9,11,32,30,24,30,1,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: [MASK] } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n, int num, int maxLimit ) { int ind; int val; int dp [ n ] [ maxLimit + 1 ]; for ( ind = 0; ind < n; ind ++ ) { for ( val = 0; val <= maxLimit; val ++ ) { if ( ind == 0 ) { if ( num - arr [ ind ] == val || num + arr [ ind ] == val ) { dp [ ind ] [ val ] = 1; } else { dp [ ind ] [ val ] = 0; } } else { if ( val - arr [ ind ] >= 0 && val + arr [ ind ] <= maxLimit ) { dp [ ind ] [ val ] = dp [ ind - 1 ] [ val - arr [ ind ] ] || dp [ ind - 1 ] [ val + arr [ ind ] ]; } else if ( val - arr [ ind ] >= 0 ) { dp [ ind ] [ val ] = dp [ ind - 1 ] [ val - arr [ ind ] ]; } else if ( val + arr [ ind ] <= maxLimit ) { dp [ ind ] [ val ] = dp [ ind - 1 ] [ val + arr [ ind ] ]; } else { dp [ ind ] [ val ] = 0; } } } } for ( val = maxLimit; val >= 0; val -- ) { if ( dp [ n - 1 ] [ val ] ) { return val; } } return - 1; } int f_filled ( int arr [ ], int n, int num, int maxLimit ) {} }
}
for ( val = maxLimit;
val >= 0;
val -- ) {
if ( dp [ n - 1 ] [ val ] ) {
return val;
}
}
return - 1;
}
int f_filled ( int arr [ ], int n, int num, int maxLimit ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,4,5,8,9,10,10,11,13,15,17,19,27,31,34,35,36,36,36,38,41,46,48,49,50,53,56,57,60,62,63,64,66,67,69,69,81,82,83,89,92,93,95,99};
int param0_1[] = {-44,-14,36,12,-12,-6,-84,46,72,-26,-50,-6};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1};
int param0_3[] = {9,67,80,48,75,21,5,39,6,93,2,81,75,69,75,30,46,60,51,61};
int param0_4[] = {-98,-82,-74,-70,-66,-62,-54,-52,-50,-34,-34,-30,-22,-20,-16,-16,-14,-4,-4,-2,0,6,10,10,12,12,14,16,18,32,38,38,48,54,58,66,66,68,78,82,86,86,88,92,96};
int param0_5[] = {0,0,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,0,1,1,1,1,0,1,1,0,1,1,0,1,0,0,1,0,0,1,0};
int param0_6[] = {5,7,8,10,15,16,16,21,25,29,31,34,36,39,41,41,44,45,48,59,64,74,78,81,85,93,97};
int param0_7[] = {-28,44,-16,-42,58,-98,22,48,66,-60,74,24,-78,-62,86,-24,20,-64,74,-66,16,24,80,-4,-22,80,-88,0,54,-26,-26,-80,-96,-98,52,-32,86,-10,-82,-64,14};
int param0_8[] = {0,1,1};
int param0_9[] = {6,87,85,44,87,42,76,23,94,53,23,88,49,10,78,61,94,11,55,47,16,96,51,26,75,33,25,85,13,85,14,17,22,18,20,72,55};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {25,10,9,19,26,24,25,25,1,22};
int param2[] = {39,11,6,15,23,26,25,37,1,19};
int param3[] = {42,10,9,11,32,30,24,30,1,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | y; | [
"a) f_gold",
"b) y;",
"c) ]",
"d) mat",
"e) f_gold"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int ans = 0, temp = 0, num;
for ( int i = 1;
i <= n && temp < n;
i ++ ) {
temp = i - 1;
num = 1;
while ( temp < n ) {
if ( temp + i <= n ) ans += ( i * num );
else ans += ( ( n - temp ) * num );
temp += i;
num ++;
}
}
return ans;
}
int f_filled ( int n ) {}
while ( temp < n ) {
if ( temp + i <= n ) ans += ( i * num );
else ans += ( ( n - temp ) * num );
temp += i;
num ++;
}
}
return ans;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {35,93,7,81,80,47,7,41,59,34};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} [MASK] f_gold ( int n ) { int ans = 0, temp = 0, num; for ( int i = 1; i <= n && temp < n; i ++ ) { temp = i - 1; num = 1; while ( temp < n ) { if ( temp + i <= n ) ans += ( i * num ); else ans += ( ( n - temp ) * num ); temp += i; num ++; } } return ans; } int f_filled ( int n ) {} while ( temp < n ) {
if ( temp + i <= n ) ans += ( i * num );
else ans += ( ( n - temp ) * num );
temp += i;
num ++;
}
}
return ans;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {35,93,7,81,80,47,7,41,59,34};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | int | [
"a) y)",
"b) ;",
"c) {",
"d) :",
"e) int"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int N, int k ) {
int MS [ N ];
MS [ N - 1 ] = arr [ N - 1 ];
for ( int i = N - 2;
i >= 0;
i -- ) {
if ( i + k + 1 >= N ) MS [ i ] = max ( arr [ i ], MS [ i + 1 ] );
else MS [ i ] = max ( arr [ i ] + MS [ i + k + 1 ], MS [ i + 1 ] );
}
return MS [ 0 ];
}
int f_filled ( int arr [ ], int N, int k ) {}
1 >= N ) MS [ i ] = max ( arr [ i ], MS [ i + 1 ] );
else MS [ i ] = max ( arr [ i ] + MS [ i + k + 1 ], MS [ i + 1 ] );
}
return MS [ 0 ];
}
int f_filled ( int arr [ ], int N, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,5,20,21,23,26,27,31,33,38,39,41,48,48,50,51,56,57,64,68,69,70,71,74,76,86,97};
int param0_1[] = {32,34,-40,90,-82,-70,30,26,-76,-46,-84,76,-76};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {96,15,30,25,83};
int param0_4[] = {-90,-82,-80,-76,-62,-58,-50,-48,-46,-38,-38,-38,-38,-38,-34,-32,-24,-22,-16,-16,-4,-2,10,10,20,26,26,32,38,38,44,44,46,48,58,62,64,66,76,78,78,82,92,96,96,98};
int param0_5[] = {1,1,1,1,1,0,0,0,0,1,1,1,0,1,0,0,1,0,0};
int param0_6[] = {1,2,9,17,24,31,31,33,56,57,61,71,73,74,76,77,79,83,86,95,99};
int param0_7[] = {-12,52,-44,80,-66,34,42,-46,8,12,-22,-56,74,-98,-44,2,-24,-14,-54,-56,-26,-18,-72};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {65,1,34,38,15,6,55,21,32,90,39,25,43,48,64,66,88,70,82,75,25,56,23,27,41,33,33,55,60,90,41,58,42,53,38,90,7,15};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {23,9,22,2,27,9,12,13,13,37};
int param2[] = {15,10,34,3,30,9,10,19,13,33};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int N, int k ) { int MS [MASK] N ]; MS [ N - 1 ] = arr [ N - 1 ]; for ( int i = N - 2; i >= 0; i -- ) { if ( i + k + 1 >= N ) MS [ i ] = max ( arr [ i ], MS [ i + 1 ] ); else MS [ i ] = max ( arr [ i ] + MS [ i + k + 1 ], MS [ i + 1 ] ); } return MS [ 0 ]; } int f_filled ( int arr [ ], int N, int k ) {}1 >= N ) MS [ i ] = max ( arr [ i ], MS [ i + 1 ] );
else MS [ i ] = max ( arr [ i ] + MS [ i + k + 1 ], MS [ i + 1 ] );
}
return MS [ 0 ];
}
int f_filled ( int arr [ ], int N, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,5,20,21,23,26,27,31,33,38,39,41,48,48,50,51,56,57,64,68,69,70,71,74,76,86,97};
int param0_1[] = {32,34,-40,90,-82,-70,30,26,-76,-46,-84,76,-76};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {96,15,30,25,83};
int param0_4[] = {-90,-82,-80,-76,-62,-58,-50,-48,-46,-38,-38,-38,-38,-38,-34,-32,-24,-22,-16,-16,-4,-2,10,10,20,26,26,32,38,38,44,44,46,48,58,62,64,66,76,78,78,82,92,96,96,98};
int param0_5[] = {1,1,1,1,1,0,0,0,0,1,1,1,0,1,0,0,1,0,0};
int param0_6[] = {1,2,9,17,24,31,31,33,56,57,61,71,73,74,76,77,79,83,86,95,99};
int param0_7[] = {-12,52,-44,80,-66,34,42,-46,8,12,-22,-56,74,-98,-44,2,-24,-14,-54,-56,-26,-18,-72};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {65,1,34,38,15,6,55,21,32,90,39,25,43,48,64,66,88,70,82,75,25,56,23,27,41,33,33,55,60,90,41,58,42,53,38,90,7,15};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {23,9,22,2,27,9,12,13,13,37};
int param2[] = {15,10,34,3,30,9,10,19,13,33};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | [ | [
"a) [",
"b) arr",
"c) +=",
"d) ])",
"e) long"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int sum [ n ];
if ( n >= 1 ) sum [ 0 ] = arr [ 0 ];
if ( n >= 2 ) sum [ 1 ] = arr [ 0 ] + arr [ 1 ];
if ( n > 2 ) sum [ 2 ] = max ( sum [ 1 ], max ( arr [ 1 ] + arr [ 2 ], arr [ 0 ] + arr [ 2 ] ) );
for ( int i = 3;
i < n;
i ++ ) sum [ i ] = max ( max ( sum [ i - 1 ], sum [ i - 2 ] + arr [ i ] ), arr [ i ] + arr [ i - 1 ] + sum [ i - 3 ] );
return sum [ n - 1 ];
}
int f_filled ( int arr [ ], int n ) {}
i < n;
i ++ ) sum [ i ] = max ( max ( sum [ i - 1 ], sum [ i - 2 ] + arr [ i ] ), arr [ i ] + arr [ i - 1 ] + sum [ i - 3 ] );
return sum [ n - 1 ];
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {5,6,8,9,10,10,16,17,17,20,21,22,23,28,29,32,36,37,40,41,42,43,47,47,48,48,49,49,52,52,53,59,61,64,65,79,79,81,87,91,92,98};
int param0_1[] = {98,76,-80,-30,82,52,-14,28,98,18,82,52,26,-62,-8};
int param0_2[] = {0,0,0,0,0,1,1,1,1};
int param0_3[] = {21,26,85,73,47,10,54,9,11,70,42,95,44,91};
int param0_4[] = {-94,-92,-90,-84,-76,-68,-60,-50,-34,-34,-20,-16,-6,18,50,54,66,70,96};
int param0_5[] = {1,0,1,1,1,0,1,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1};
int param0_6[] = {2,3,4,4,14,14,18,21,24,26,29,31,32,34,36,37,38,40,42,44,44,54,63,69,77,77,82,82,86,87,90,93,95};
int param0_7[] = {-46,64,-44,88,-74,54,40,-2,-24,94,40,-44,56,-54,-60,-86,-58,48,-90,12,-76,-30,94,-34,14,12,80,-40,60};
int param0_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1};
int param0_9[] = {4,32,63,23,44,57,59,69,88,61,66,61,65,33,79,58,71,2,80,41,83,12,20,9,7,40,36,97,10,98,66,78,71,37,53};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {35,7,7,12,9,16,31,22,7,26};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int sum [ n ]; if ( n >= 1 ) sum [ 0 ] = arr [ 0 ]; if ( n >= 2 ) sum [ 1 ] = arr [ 0 ] + arr [ 1 ]; if ( n > 2 ) sum [ 2 ] = max ( sum [ 1 ], max ( arr [ 1 ] + arr [ 2 ], arr [ 0 ] + arr [ 2 ] ) ); for ( int i = 3; i < n; i ++ ) sum [ i ] = max ( max ( sum [ i - 1 ], sum [ i - 2 ] + arr [ i ] ), arr [ i ] + arr [ i - 1 ] + sum [ i - 3 ] ); return sum [ n [MASK] 1 ]; } int f_filled ( int arr [ ], int n ) {} i < n;
i ++ ) sum [ i ] = max ( max ( sum [ i - 1 ], sum [ i - 2 ] + arr [ i ] ), arr [ i ] + arr [ i - 1 ] + sum [ i - 3 ] );
return sum [ n - 1 ];
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {5,6,8,9,10,10,16,17,17,20,21,22,23,28,29,32,36,37,40,41,42,43,47,47,48,48,49,49,52,52,53,59,61,64,65,79,79,81,87,91,92,98};
int param0_1[] = {98,76,-80,-30,82,52,-14,28,98,18,82,52,26,-62,-8};
int param0_2[] = {0,0,0,0,0,1,1,1,1};
int param0_3[] = {21,26,85,73,47,10,54,9,11,70,42,95,44,91};
int param0_4[] = {-94,-92,-90,-84,-76,-68,-60,-50,-34,-34,-20,-16,-6,18,50,54,66,70,96};
int param0_5[] = {1,0,1,1,1,0,1,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1};
int param0_6[] = {2,3,4,4,14,14,18,21,24,26,29,31,32,34,36,37,38,40,42,44,44,54,63,69,77,77,82,82,86,87,90,93,95};
int param0_7[] = {-46,64,-44,88,-74,54,40,-2,-24,94,40,-44,56,-54,-60,-86,-58,48,-90,12,-76,-30,94,-34,14,12,80,-40,60};
int param0_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1};
int param0_9[] = {4,32,63,23,44,57,59,69,88,61,66,61,65,33,79,58,71,2,80,41,83,12,20,9,7,40,36,97,10,98,66,78,71,37,53};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {35,7,7,12,9,16,31,22,7,26};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | - | [
"a) -",
"b) k",
"c) (",
"d) int",
"e) ="
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int A [ ], int N, int M ) {
int sum = 0;
int ans = 0;
for ( int i = 0;
i < N;
i ++ ) {
for ( int j = i + 1;
j < N;
j ++ ) {
for ( int k = j + 1;
k < N;
k ++ ) {
sum = A [ i ] + A [ j ] + A [ k ];
if ( sum % M == 0 ) ans ++;
}
}
}
return ans;
}
int f_filled ( int A [ ], int N, int M ) {}
k = j + 1;
k < N;
k ++ ) {
sum = A [ i ] + A [ j ] + A [ k ];
if ( sum % M == 0 ) ans ++;
}
}
}
return ans;
}
int f_filled ( int A [ ], int N, int M ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {14,35,56,70,88};
int param0_1[] = {-50,-92,16,-68,-36};
int param0_2[] = {0,0,0,1,1,1};
int param0_3[] = {76,43,22,41,49,99,25,40,3,45,60,16,83,62,26,93,64,73,72,53,6,32,35,67,17};
int param0_4[] = {-90,-86,-86,-66,-50,-48,-44,-42,-42,-38,-24,-22,-20,-18,-8,8,24,28,34,48,60,62,66,68,74,76,80,82,88};
int param0_5[] = {1,1,1,0,0,1,0,1,0,1,1,0,0,1,1,0,1,0,0,1,1,0,1,1,0,0,0,1,1,0,1,1,1,0,1,1,0};
int param0_6[] = {4,5,8,9,10,12,13,16,17,18,21,21,25,27,28,30,36,36,54,55,56,57,60,62,67,67,68,71,72,72,73,73,77,77,83,86,86,86,87,89,92,92,96,97,97,98};
int param0_7[] = {-64,52,-32,38,8,-62,-56,20,72,-12,32,44};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {77,68,45,6,27,19,29,95,21,2,39,48,72,67,49,45,1,16,56,78,25,22,27,40,31,34,26,35,12};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {3,3,4,14,24,24,24,6,12,25};
int param2[] = {4,4,5,21,20,30,23,6,15,25};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> [MASK] min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int A [ ], int N, int M ) { int sum = 0; int ans = 0; for ( int i = 0; i < N; i ++ ) { for ( int j = i + 1; j < N; j ++ ) { for ( int k = j + 1; k < N; k ++ ) { sum = A [ i ] + A [ j ] + A [ k ]; if ( sum % M == 0 ) ans ++; } } } return ans; } int f_filled ( int A [ ], int N, int M ) {}k = j + 1;
k < N;
k ++ ) {
sum = A [ i ] + A [ j ] + A [ k ];
if ( sum % M == 0 ) ans ++;
}
}
}
return ans;
}
int f_filled ( int A [ ], int N, int M ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {14,35,56,70,88};
int param0_1[] = {-50,-92,16,-68,-36};
int param0_2[] = {0,0,0,1,1,1};
int param0_3[] = {76,43,22,41,49,99,25,40,3,45,60,16,83,62,26,93,64,73,72,53,6,32,35,67,17};
int param0_4[] = {-90,-86,-86,-66,-50,-48,-44,-42,-42,-38,-24,-22,-20,-18,-8,8,24,28,34,48,60,62,66,68,74,76,80,82,88};
int param0_5[] = {1,1,1,0,0,1,0,1,0,1,1,0,0,1,1,0,1,0,0,1,1,0,1,1,0,0,0,1,1,0,1,1,1,0,1,1,0};
int param0_6[] = {4,5,8,9,10,12,13,16,17,18,21,21,25,27,28,30,36,36,54,55,56,57,60,62,67,67,68,71,72,72,73,73,77,77,83,86,86,86,87,89,92,92,96,97,97,98};
int param0_7[] = {-64,52,-32,38,8,-62,-56,20,72,-12,32,44};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {77,68,45,6,27,19,29,95,21,2,39,48,72,67,49,45,1,16,56,78,25,22,27,40,31,34,26,35,12};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {3,3,4,14,24,24,24,6,12,25};
int param2[] = {4,4,5,21,20,30,23,6,15,25};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | int | [
"a) ;",
"b) i",
"c) CHECK_TWO_GIVEN_CIRCLES_TOUCH_INTERSECT{",
"d) :",
"e) int"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int C [ n + 1 ] [ n + 1 ];
for ( int i = 0;
i <= n;
i ++ ) {
for ( int j = 0;
j <= min ( i, n );
j ++ ) {
if ( j == 0 || j == i ) C [ i ] [ j ] = 1;
else C [ i ] [ j ] = C [ i - 1 ] [ j - 1 ] + C [ i - 1 ] [ j ];
}
}
int maxvalue = 0;
for ( int i = 0;
i <= n;
i ++ ) maxvalue = max ( maxvalue, C [ n ] [ i ] );
return maxvalue;
}
int f_filled ( int n ) {}
- 1 ] [ j - 1 ] + C [ i - 1 ] [ j ];
}
}
int maxvalue = 0;
for ( int i = 0;
i <= n;
i ++ ) maxvalue = max ( maxvalue, C [ n ] [ i ] );
return maxvalue;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {23,41,69,56,71,38,26,52,93,44};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { int C [ n + 1 [MASK] [ n + 1 ]; for ( int i = 0; i <= n; i ++ ) { for ( int j = 0; j <= min ( i, n ); j ++ ) { if ( j == 0 || j == i ) C [ i ] [ j ] = 1; else C [ i ] [ j ] = C [ i - 1 ] [ j - 1 ] + C [ i - 1 ] [ j ]; } } int maxvalue = 0; for ( int i = 0; i <= n; i ++ ) maxvalue = max ( maxvalue, C [ n ] [ i ] ); return maxvalue; } int f_filled ( int n ) {}- 1 ] [ j - 1 ] + C [ i - 1 ] [ j ];
}
}
int maxvalue = 0;
for ( int i = 0;
i <= n;
i ++ ) maxvalue = max ( maxvalue, C [ n ] [ i ] );
return maxvalue;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {23,41,69,56,71,38,26,52,93,44};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ] | [
"a) ]",
"b) of",
"c) f_filled",
"d) arr",
"e) )"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
char f_gold [] ( char str [] ) {
char result [] = "";
bool v = true;
for ( int i = 0;
i < strlen(str);
i ++ ) {
if ( str [ i ] == ' ' ) v = true;
else if ( str [ i ] != ' ' && v == true ) {
result . push_back ( str [ i ] );
v = false;
}
}
return result;
}
char f_filled [] ( char str [] ) {}
[ i ] == ' ' ) v = true;
else if ( str [ i ] != ' ' && v == true ) {
result . push_back ( str [ i ] );
v = false;
}
}
return result;
}
char f_filled [] ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"t a","77 78 2 600 7","011 10 10","kVCo kV Co O iR","2","0 11","Y sT wgheC","58 824 6","00 100 001 0111","Q"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int [MASK] (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} char f_gold [] ( char str [] ) { char result [] = ""; bool v = true; for ( int i = 0; i < strlen(str); i ++ ) { if ( str [ i ] == ' ' ) v = true; else if ( str [ i ] != ' ' && v == true ) { result . push_back ( str [ i ] ); v = false; } } return result; } char f_filled [] ( char str [] ) {} [ i ] == ' ' ) v = true;
else if ( str [ i ] != ' ' && v == true ) {
result . push_back ( str [ i ] );
v = false;
}
}
return result;
}
char f_filled [] ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"t a","77 78 2 600 7","011 10 10","kVCo kV Co O iR","2","0 11","Y sT wgheC","58 824 6","00 100 001 0111","Q"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | len | [
"a) len",
"b) .",
"c) i",
"d) }",
"e) ("
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
long f_gold ( int n ) {
long dp [ 2 ] [ n + 1 ];
dp [ 0 ] [ 1 ] = 1;
dp [ 1 ] [ 1 ] = 2;
for ( int i = 2;
i <= n;
i ++ ) {
dp [ 0 ] [ i ] = dp [ 0 ] [ i - 1 ] + dp [ 1 ] [ i - 1 ];
dp [ 1 ] [ i ] = dp [ 0 ] [ i - 1 ] * 2 + dp [ 1 ] [ i - 1 ];
}
return dp [ 0 ] [ n ] + dp [ 1 ] [ n ];
}
long f_filled ( int n ) {}
[ 0 ] [ i ] = dp [ 0 ] [ i - 1 ] + dp [ 1 ] [ i - 1 ];
dp [ 1 ] [ i ] = dp [ 0 ] [ i - 1 ] * 2 + dp [ 1 ] [ i - 1 ];
}
return dp [ 0 ] [ n ] + dp [ 1 ] [ n ];
}
long f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {68,91,99,79,61,48,89,20,83,1};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} long f_gold ( int n ) { long dp [ 2 ] [ n + 1 ]; dp [ 0 ] [ 1 ] = 1; dp [ 1 ] [ 1 ] = 2; for ( int i = 2; i <= n; i ++ ) { dp [ 0 ] [ i ] = dp [ 0 ] [ i - 1 ] + dp [ 1 ] [ i - 1 ]; dp [ 1 ] [ i ] = dp [ 0 ] [ i - 1 ] * 2 + dp [MASK] 1 ] [ i - 1 ]; } return dp [ 0 ] [ n ] + dp [ 1 ] [ n ]; } long f_filled ( int n ) {}[ 0 ] [ i ] = dp [ 0 ] [ i - 1 ] + dp [ 1 ] [ i - 1 ];
dp [ 1 ] [ i ] = dp [ 0 ] [ i - 1 ] * 2 + dp [ 1 ] [ i - 1 ];
}
return dp [ 0 ] [ n ] + dp [ 1 ] [ n ];
}
long f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {68,91,99,79,61,48,89,20,83,1};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | [ | [
"a) j",
"b) digit",
"c) [",
"d) int",
"e) profit"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int x, int y ) {
return ( ( x ^ y ) < 0 );
}
bool f_filled ( int x, int y ) {}
(arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int x, int y ) {
return ( ( x ^ y ) < 0 );
}
bool f_filled ( int x, int y ) {}
int main(void) {
int n_success = 0;
int param0[] = {59,-20,-100,54,-16,-23,93,24,-8,29};
int param1[] = {-99,-21,100,-49,16,-68,37,-61,69,10};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x [MASK] y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int x, int y ) { return ( ( x ^ y ) < 0 ); } bool f_filled ( int x, int y ) {} (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int x, int y ) {
return ( ( x ^ y ) < 0 );
}
bool f_filled ( int x, int y ) {}
int main(void) {
int n_success = 0;
int param0[] = {59,-20,-100,54,-16,-23,93,24,-8,29};
int param1[] = {-99,-21,100,-49,16,-68,37,-61,69,10};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | > | [
"a) ]",
"b) (",
"c) >",
"d) arr",
"e) <"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b, int k ) {
int p = pow ( a, b );
int count = 0;
while ( p > 0 && count < k ) {
int rem = p % 10;
count ++;
if ( count == k ) return rem;
p = p / 10;
}
return 0;
}
int f_filled ( int a, int b, int k ) {}
;
int count = 0;
while ( p > 0 && count < k ) {
int rem = p % 10;
count ++;
if ( count == k ) return rem;
p = p / 10;
}
return 0;
}
int f_filled ( int a, int b, int k ) {}
int main(void) {
int n_success = 0;
int param0[] = {11,41,5,1,24,5,66,7,77,60};
int param1[] = {2,3,4,2,1,2,5,10,30,50};
int param2[] = {1,0,3,4,5,3,8,3,10,1};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, [MASK] y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a, int b, int k ) { int p = pow ( a, b ); int count = 0; while ( p > 0 && count < k ) { int rem = p % 10; count ++; if ( count == k ) return rem; p = p / 10; } return 0; } int f_filled ( int a, int b, int k ) {};
int count = 0;
while ( p > 0 && count < k ) {
int rem = p % 10;
count ++;
if ( count == k ) return rem;
p = p / 10;
}
return 0;
}
int f_filled ( int a, int b, int k ) {}
int main(void) {
int n_success = 0;
int param0[] = {11,41,5,1,24,5,66,7,77,60};
int param1[] = {2,3,4,2,1,2,5,10,30,50};
int param2[] = {1,0,3,4,5,3,8,3,10,1};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | int | [
"a) *",
"b) java.lang.*;",
"c) int",
"d) ==",
"e) y)?"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int count = 0;
sort ( arr, arr + n );
for ( int i = 0;
i < n - 1;
i ++ ) if ( arr [ i ] != arr [ i + 1 ] && arr [ i ] != arr [ i + 1 ] - 1 ) count += arr [ i + 1 ] - arr [ i ] - 1;
return count;
}
int f_filled ( int arr [ ], int n ) {}
t i = 0;
i < n - 1;
i ++ ) if ( arr [ i ] != arr [ i + 1 ] && arr [ i ] != arr [ i + 1 ] - 1 ) count += arr [ i + 1 ] - arr [ i ] - 1;
return count;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,4,5,7,7,9,13,15,18,19,25,27,27,29,32,36,48,51,53,53,55,65,66,67,72,74,74,76,77,79,80,81,82,83,83,86,87,97,98,98,99};
int param0_1[] = {34,6,-16,-26,-80,-90,-74,16,-84,64,-8,14,-52,-26,-90,-84,94,92,-88,-84,72};
int param0_2[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {25,29,12,79,23,92,54,43,26,10,43,39,32,12,62,13,13};
int param0_4[] = {-94,-86,-72,-64,-64,-58,-56,-56,-56,-56,-54,-54,-52,-42,-42,-40,-36,-32,-28,-22,-20,-18,-12,-8,-6,-4,0,2,4,10,16,30,32,48,48,60,70,74,76,84};
int param0_5[] = {1,1,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,1,1,0,1,0,1,1,0,0,1,0,1,1,1,0};
int param0_6[] = {4,5,8,12,16,16,17,20,20,23,26,26,27,28,32,34,40,40,41,41,44,45,47,49,51,52,54,57,60,62,63,64,66,68,69,70,71,76,77,80,80,80,90,91,92,94,96,98,99};
int param0_7[] = {66,-46,-92,-40,76,74,10,20,56,-46,88,-18,48,96,-48,-86,38,-98,50,4,-52,-38,14,-48,96,16,-74,-26,80,14,-92,-60,-78,-68,96,-72,-44,-92,2,60,4,48,84,-92};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {49,84,66};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {30,17,24,14,35,29,42,37,17,2};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int [MASK] = 0; sort ( arr, arr + n ); for ( int i = 0; i < n - 1; i ++ ) if ( arr [ i ] != arr [ i + 1 ] && arr [ i ] != arr [ i + 1 ] - 1 ) count += arr [ i + 1 ] - arr [ i ] - 1; return count; } int f_filled ( int arr [ ], int n ) {}t i = 0;
i < n - 1;
i ++ ) if ( arr [ i ] != arr [ i + 1 ] && arr [ i ] != arr [ i + 1 ] - 1 ) count += arr [ i + 1 ] - arr [ i ] - 1;
return count;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,4,5,7,7,9,13,15,18,19,25,27,27,29,32,36,48,51,53,53,55,65,66,67,72,74,74,76,77,79,80,81,82,83,83,86,87,97,98,98,99};
int param0_1[] = {34,6,-16,-26,-80,-90,-74,16,-84,64,-8,14,-52,-26,-90,-84,94,92,-88,-84,72};
int param0_2[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {25,29,12,79,23,92,54,43,26,10,43,39,32,12,62,13,13};
int param0_4[] = {-94,-86,-72,-64,-64,-58,-56,-56,-56,-56,-54,-54,-52,-42,-42,-40,-36,-32,-28,-22,-20,-18,-12,-8,-6,-4,0,2,4,10,16,30,32,48,48,60,70,74,76,84};
int param0_5[] = {1,1,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,1,1,0,1,0,1,1,0,0,1,0,1,1,1,0};
int param0_6[] = {4,5,8,12,16,16,17,20,20,23,26,26,27,28,32,34,40,40,41,41,44,45,47,49,51,52,54,57,60,62,63,64,66,68,69,70,71,76,77,80,80,80,90,91,92,94,96,98,99};
int param0_7[] = {66,-46,-92,-40,76,74,10,20,56,-46,88,-18,48,96,-48,-86,38,-98,50,4,-52,-38,14,-48,96,16,-74,-26,80,14,-92,-60,-78,-68,96,-72,-44,-92,2,60,4,48,84,-92};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {49,84,66};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {30,17,24,14,35,29,42,37,17,2};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | count | [
"a) max",
"b) :",
"c) char",
"d) }",
"e) count"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int maxA = INT_MIN, maxB = INT_MIN, maxC = INT_MIN;
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] > maxA ) {
maxC = maxB;
maxB = maxA;
maxA = arr [ i ];
}
else if ( arr [ i ] > maxB ) {
maxC = maxB;
maxB = arr [ i ];
}
else if ( arr [ i ] > maxC ) maxC = arr [ i ];
}
return ( maxA + maxB + maxC );
}
int f_filled ( int arr [ ], int n ) {}
[ i ] > maxB ) {
maxC = maxB;
maxB = arr [ i ];
}
else if ( arr [ i ] > maxC ) maxC = arr [ i ];
}
return ( maxA + maxB + maxC );
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,7,12,21,22,25,27,28,28,31,32,32,41,45,47,51,53,60,61,61,63,71,74,82,83,85,88,92,96,96};
int param0_1[] = {-52,26,74,-62,-76};
int param0_2[] = {0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {63,71,15,28,31,84,8,17,24,42,66,95,30};
int param0_4[] = {-94,-92,-92,-90,-88,-88,-86,-82,-80,-78,-66,-54,-52,-52,-46,-46,-42,-36,-32,-24,-24,-14,-14,-14,-12,-10,0,6,8,20,24,24,28,38,38,52,54,56,64,74,74,76,82,94,94};
int param0_5[] = {0,0,0,1,1,0,1,0,1,1,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0,0,0,0,1,1,0,0,0,0,1,0,1,1,0,1,0,0,0,1,0};
int param0_6[] = {15,19,80};
int param0_7[] = {4,80,18,74,36,-30,-72,-28,-32,-16,-8,38,78,-48,98,-64,86,-60,-44,84,-98,40,14,30,44,90,-30,-42,24,-28,24,40,-96,98,90,-68,-54,-52,62,34,-98,68,-56,-94,-78,-12,28};
int param0_8[] = {0,1,1,1,1,1};
int param0_9[] = {2,18,96,7,99,83,3,88,23,77,6,28,55,49,69,55,48,76,43,11,43,44,17,74,27,64,76,77,53,26,73,12,19,62,18,34,13,31,97,96,85,27,30,97,89,25};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {28,2,11,6,31,30,2,41,3,41};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int maxA = INT_MIN, maxB = INT_MIN, maxC = INT_MIN; for ( int i = 0; i < n; i ++ ) { if ( arr [ i ] > maxA ) { maxC = maxB; maxB = maxA; maxA = arr [ i ]; } else if ( arr [ i ] > [MASK] ) { maxC = maxB; maxB = arr [ i ]; } else if ( arr [ i ] > maxC ) maxC = arr [ i ]; } return ( maxA + maxB + maxC ); } int f_filled ( int arr [ ], int n ) {} [ i ] > maxB ) {
maxC = maxB;
maxB = arr [ i ];
}
else if ( arr [ i ] > maxC ) maxC = arr [ i ];
}
return ( maxA + maxB + maxC );
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,7,12,21,22,25,27,28,28,31,32,32,41,45,47,51,53,60,61,61,63,71,74,82,83,85,88,92,96,96};
int param0_1[] = {-52,26,74,-62,-76};
int param0_2[] = {0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {63,71,15,28,31,84,8,17,24,42,66,95,30};
int param0_4[] = {-94,-92,-92,-90,-88,-88,-86,-82,-80,-78,-66,-54,-52,-52,-46,-46,-42,-36,-32,-24,-24,-14,-14,-14,-12,-10,0,6,8,20,24,24,28,38,38,52,54,56,64,74,74,76,82,94,94};
int param0_5[] = {0,0,0,1,1,0,1,0,1,1,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0,0,0,0,1,1,0,0,0,0,1,0,1,1,0,1,0,0,0,1,0};
int param0_6[] = {15,19,80};
int param0_7[] = {4,80,18,74,36,-30,-72,-28,-32,-16,-8,38,78,-48,98,-64,86,-60,-44,84,-98,40,14,30,44,90,-30,-42,24,-28,24,40,-96,98,90,-68,-54,-52,62,34,-98,68,-56,-94,-78,-12,28};
int param0_8[] = {0,1,1,1,1,1};
int param0_9[] = {2,18,96,7,99,83,3,88,23,77,6,28,55,49,69,55,48,76,43,11,43,44,17,74,27,64,76,77,53,26,73,12,19,62,18,34,13,31,97,96,85,27,30,97,89,25};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {28,2,11,6,31,30,2,41,3,41};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | maxB | [
"a) [",
"b) n",
"c) n",
"d) )",
"e) maxB"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int i;
for ( i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == i ) return i;
}
return - 1;
}
int f_filled ( int arr [ ], int n ) {}
of(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int i;
for ( i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == i ) return i;
}
return - 1;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {8,16,21,26,27,29,34,35,35,37,38,40,48,52,58,59,60,61,63,63,65,66,69,75,79,83,86,88,91,91,96};
int param0_1[] = {22,-70,34,-44,84,54,14,-88};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {59,67,70,34,18,22,52,95,11,66,60,24,7,71,52,88,32,52,85,81,32,44,25,51,47,97,81,33,88,38,36,54,80,25,70,27,75,29,94};
int param0_4[] = {-96,-96,-94,-88,-88,-82,-72,-72,-70,-70,-66,-64,-64,-62,-58,-54,-46,-44,-30,-26,-22,-8,-6,-2,0,26,30,30,34,42,42,48,64,76,90,96};
int param0_5[] = {0,1,0,0,1,1,1,0,0,1,1,0,1,0,0,0,0,0,1,0,1,1,0,0,1,0,1,1};
int param0_6[] = {2,2,4,7,10,15,16,16,23,24,27,39,42,58,60,64,72,74,78,78,78,80,80,84,85,86,88,88,90,92,93,94,95,96};
int param0_7[] = {-68,-48,36,22,-80,-48,-74,-14,44,-46,-76,18,-16,-36,-68,0,-30,-56,42,92,82,64,-18,-6,-78,-86,26,86,36,-66,-50,18,-26,48,8};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {3,76,99,1,1,29,9,12,57,12,74,22,83,77,39,84,50,60,36,90,88,62,79,58,58,40,44,99,84,63,23,21,16,98,68,8,46};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {23,7,31,37,34,15,22,20,23,35};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int i; for ( i = 0; i < n; i ++ ) { if [MASK] arr [ i ] == i ) return i; } return - 1; } int f_filled ( int arr [ ], int n ) {}of(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int i;
for ( i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == i ) return i;
}
return - 1;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {8,16,21,26,27,29,34,35,35,37,38,40,48,52,58,59,60,61,63,63,65,66,69,75,79,83,86,88,91,91,96};
int param0_1[] = {22,-70,34,-44,84,54,14,-88};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {59,67,70,34,18,22,52,95,11,66,60,24,7,71,52,88,32,52,85,81,32,44,25,51,47,97,81,33,88,38,36,54,80,25,70,27,75,29,94};
int param0_4[] = {-96,-96,-94,-88,-88,-82,-72,-72,-70,-70,-66,-64,-64,-62,-58,-54,-46,-44,-30,-26,-22,-8,-6,-2,0,26,30,30,34,42,42,48,64,76,90,96};
int param0_5[] = {0,1,0,0,1,1,1,0,0,1,1,0,1,0,0,0,0,0,1,0,1,1,0,0,1,0,1,1};
int param0_6[] = {2,2,4,7,10,15,16,16,23,24,27,39,42,58,60,64,72,74,78,78,78,80,80,84,85,86,88,88,90,92,93,94,95,96};
int param0_7[] = {-68,-48,36,22,-80,-48,-74,-14,44,-46,-76,18,-16,-36,-68,0,-30,-56,42,92,82,64,-18,-6,-78,-86,26,86,36,-66,-50,18,-26,48,8};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {3,76,99,1,1,29,9,12,57,12,74,22,83,77,39,84,50,60,36,90,88,62,79,58,58,40,44,99,84,63,23,21,16,98,68,8,46};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {23,7,31,37,34,15,22,20,23,35};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ( | [
"a) ;",
"b) *",
"c) =",
"d) >",
"e) ("
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char str [ ], int n ) {
char last = ' ';
int res = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( last != str [ i ] ) res ++;
last = str [ i ];
}
return res / 2;
}
int f_filled ( char str [ ], int n ) {}
char last = ' ';
int res = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( last != str [ i ] ) res ++;
last = str [ i ];
}
return res / 2;
}
int f_filled ( char str [ ], int n ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"VrTpXWR","2","00011111","adAIqCcOkao","6696836653","0010111","jGYH","4374","0","cNM"};
int param1[] = {46,58,84,85,52,78,60,52,56,35};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(¶m0[i].front(),param1[i]) == f_gold(¶m0[i].front(),param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const [MASK] * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char str [ ], int n ) { char last = ' '; int res = 0; for ( int i = 0; i < n; i ++ ) { if ( last != str [ i ] ) res ++; last = str [ i ]; } return res / 2; } int f_filled ( char str [ ], int n ) {} char last = ' ';
int res = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( last != str [ i ] ) res ++;
last = str [ i ];
}
return res / 2;
}
int f_filled ( char str [ ], int n ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"VrTpXWR","2","00011111","adAIqCcOkao","6696836653","0010111","jGYH","4374","0","cNM"};
int param1[] = {46,58,84,85,52,78,60,52,56,35};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(¶m0[i].front(),param1[i]) == f_gold(¶m0[i].front(),param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | void | [
"a) sum",
"b) ord",
"c) void",
"d) 2",
"e) const"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( unsigned int x, unsigned int p1, unsigned int p2, unsigned int n ) {
unsigned int set1 = ( x >> p1 ) & ( ( 1U << n ) - 1 );
unsigned int set2 = ( x >> p2 ) & ( ( 1U << n ) - 1 );
unsigned int Xor = ( set1 ^ set2 );
Xor = ( Xor << p1 ) | ( Xor << p2 );
unsigned int result = x ^ Xor;
return result;
}
int f_filled ( unsigned int x, unsigned int p1, unsigned int p2, unsigned int n ) {}
= ( set1 ^ set2 );
Xor = ( Xor << p1 ) | ( Xor << p2 );
unsigned int result = x ^ Xor;
return result;
}
int f_filled ( unsigned int x, unsigned int p1, unsigned int p2, unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {95,16,55,75,90,58,69,5,36,62};
int param1[] = {88,26,56,35,12,65,64,1,33,69};
int param2[] = {97,59,40,79,59,25,17,59,97,66};
int param3[] = {92,42,41,30,34,19,94,38,44,9};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) [MASK] (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( unsigned int x, unsigned int p1, unsigned int p2, unsigned int n ) { unsigned int set1 = ( x >> p1 ) & ( ( 1U << n ) - 1 ); unsigned int set2 = ( x >> p2 ) & ( ( 1U << n ) - 1 ); unsigned int Xor = ( set1 ^ set2 ); Xor = ( Xor << p1 ) | ( Xor << p2 ); unsigned int result = x ^ Xor; return result; } int f_filled ( unsigned int x, unsigned int p1, unsigned int p2, unsigned int n ) {} = ( set1 ^ set2 );
Xor = ( Xor << p1 ) | ( Xor << p2 );
unsigned int result = x ^ Xor;
return result;
}
int f_filled ( unsigned int x, unsigned int p1, unsigned int p2, unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {95,16,55,75,90,58,69,5,36,62};
int param1[] = {88,26,56,35,12,65,64,1,33,69};
int param2[] = {97,59,40,79,59,25,17,59,97,66};
int param3[] = {92,42,41,30,34,19,94,38,44,9};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | (sizeof | [
"a) arr",
"b) (sizeof",
"c) #include",
"d) )",
"e) 3;"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
char f_gold [] ( char str [] ) {
int n = strlen(str);
char arr [] [ n ];
char concat [] = str + str;
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = concat . substr ( i, n );
sort ( arr, arr + n );
return arr [ 0 ];
}
char f_filled [] ( char str [] ) {}
[ n ];
char concat [] = str + str;
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = concat . substr ( i, n );
sort ( arr, arr + n );
return arr [ 0 ];
}
char f_filled [] ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"onWEchl","2","100","GHbCZA","50568798206105","001011110001","lljpYhznnyu","54499921759984","11101","qvypgCYEjsyjwZ"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * [MASK] const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} char f_gold [] ( char str [] ) { int n = strlen(str); char arr [] [ n ]; char concat [] = str + str; for ( int i = 0; i < n; i ++ ) arr [ i ] = concat . substr ( i, n ); sort ( arr, arr + n ); return arr [ 0 ]; } char f_filled [] ( char str [] ) {} [ n ];
char concat [] = str + str;
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = concat . substr ( i, n );
sort ( arr, arr + n );
return arr [ 0 ];
}
char f_filled [] ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"onWEchl","2","100","GHbCZA","50568798206105","001011110001","lljpYhznnyu","54499921759984","11101","qvypgCYEjsyjwZ"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | a, | [
"a) [",
"b) [",
"c) }",
"d) i",
"e) a,"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int a [ ], int b [ ], int n, int k ) {
sort ( a, a + n );
sort ( b, b + n, greater < int > ( ) );
for ( int i = 0;
i < n;
i ++ ) if ( a [ i ] + b [ i ] < k ) return false;
return true;
}
bool f_filled ( int a [ ], int b [ ], int n, int k ) {}
sort ( b, b + n, greater < int > ( ) );
for ( int i = 0;
i < n;
i ++ ) if ( a [ i ] + b [ i ] < k ) return false;
return true;
}
bool f_filled ( int a [ ], int b [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,12,16,25,27,40,43,52,52,70,87,88,90,97,99};
int param0_1[] = {-96,-90,-80,10,-84,-96,-28,-42,30,-92,-44,-14,18,-68,-94,6,-76,72,-90,42,70,-78,56,-26,8,74,12,-74,20,-86,-74,-90,-98,92,30,94,14,92,88,-98,42,-48};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {13,35,6,69,42,55,11,97,15,65,70,77,51,16,3,26,47,72,15,71,2,31,18,59,75,48};
int param0_4[] = {-72,-70,-66,-64,-52,-52,-52,-48,-46,-42,-40,-34,-20,-4,-4,-2,2,4,16,16,18,18,32,36,52,54,56,56,58,68,72,74,84,84,90,90,92,94};
int param0_5[] = {1,0,0,1,0,1,1,0,1,0,1,1,1,0,0,1,0,1,0};
int param0_6[] = {8,17,18,21,23,32,34,37,44,48,53,58,64,66,66,72,72,79,80,80,80,82,87,92,93,94,96,96,98};
int param0_7[] = {-20,-22,-16,-80,-88,22,-78,-82,-50,32,28,-8,-48,80,62,-14,14,10,-78,78,52,94,-66,14,50,18,-38,-98,24,18,-28,24,10,-88,-14};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {75,31,58,10,92,65,45,72,53,91,39,33,10,13,67,85};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1_0[] = {4,7,11,20,34,35,36,44,46,71,72,78,85,85,91};
int param1_1[] = {-48,84,16,-72,96,-78,-76,-84,-76,-32,-50,62,-22,24,-32,94,8,-14,-20,44,-80,68,-44,60,94,-42,-44,-74,-98,-86,16,62,-80,18,-18,70,30,40,-56,76,-32,50};
int param1_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param1_3[] = {88,15,44,36,38,98,89,81,73,51,37,4,79,60,11,62,48,45,12,21,65,14,78,20,12,46};
int param1_4[] = {-94,-76,-74,-56,-54,-50,-46,-38,-26,-24,-24,-22,-16,-10,-6,-4,-4,0,0,6,12,12,18,20,38,50,52,52,54,64,64,72,72,72,76,90,96,96};
int param1_5[] = {1,1,0,0,0,1,0,1,0,1,1,1,1,1,0,1,0,0,1};
int param1_6[] = {11,15,17,19,23,23,26,27,36,43,46,47,55,59,63,66,77,79,79,82,85,86,86,91,91,94,94,97,99};
int param1_7[] = {6,-54,90,98,-30,88,36,88,38,12,46,-66,-80,32,42,-96,62,-44,-80,-14,20,2,70,-46,96,-40,52,56,96,-82,24,98,-16,90,66};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {41,91,78,28,40,71,74,69,71,12,7,21,92,19,39,34};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2[] = {10,40,11,25,26,13,20,31,31,14};
int param3[] = {7,38,15,16,30,13,14,24,30,8};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * [MASK] {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int a [ ], int b [ ], int n, int k ) { sort ( a, a + n ); sort ( b, b + n, greater < int > ( ) ); for ( int i = 0; i < n; i ++ ) if ( a [ i ] + b [ i ] < k ) return false; return true; } bool f_filled ( int a [ ], int b [ ], int n, int k ) {}
sort ( b, b + n, greater < int > ( ) );
for ( int i = 0;
i < n;
i ++ ) if ( a [ i ] + b [ i ] < k ) return false;
return true;
}
bool f_filled ( int a [ ], int b [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,12,16,25,27,40,43,52,52,70,87,88,90,97,99};
int param0_1[] = {-96,-90,-80,10,-84,-96,-28,-42,30,-92,-44,-14,18,-68,-94,6,-76,72,-90,42,70,-78,56,-26,8,74,12,-74,20,-86,-74,-90,-98,92,30,94,14,92,88,-98,42,-48};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {13,35,6,69,42,55,11,97,15,65,70,77,51,16,3,26,47,72,15,71,2,31,18,59,75,48};
int param0_4[] = {-72,-70,-66,-64,-52,-52,-52,-48,-46,-42,-40,-34,-20,-4,-4,-2,2,4,16,16,18,18,32,36,52,54,56,56,58,68,72,74,84,84,90,90,92,94};
int param0_5[] = {1,0,0,1,0,1,1,0,1,0,1,1,1,0,0,1,0,1,0};
int param0_6[] = {8,17,18,21,23,32,34,37,44,48,53,58,64,66,66,72,72,79,80,80,80,82,87,92,93,94,96,96,98};
int param0_7[] = {-20,-22,-16,-80,-88,22,-78,-82,-50,32,28,-8,-48,80,62,-14,14,10,-78,78,52,94,-66,14,50,18,-38,-98,24,18,-28,24,10,-88,-14};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {75,31,58,10,92,65,45,72,53,91,39,33,10,13,67,85};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1_0[] = {4,7,11,20,34,35,36,44,46,71,72,78,85,85,91};
int param1_1[] = {-48,84,16,-72,96,-78,-76,-84,-76,-32,-50,62,-22,24,-32,94,8,-14,-20,44,-80,68,-44,60,94,-42,-44,-74,-98,-86,16,62,-80,18,-18,70,30,40,-56,76,-32,50};
int param1_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param1_3[] = {88,15,44,36,38,98,89,81,73,51,37,4,79,60,11,62,48,45,12,21,65,14,78,20,12,46};
int param1_4[] = {-94,-76,-74,-56,-54,-50,-46,-38,-26,-24,-24,-22,-16,-10,-6,-4,-4,0,0,6,12,12,18,20,38,50,52,52,54,64,64,72,72,72,76,90,96,96};
int param1_5[] = {1,1,0,0,0,1,0,1,0,1,1,1,1,1,0,1,0,0,1};
int param1_6[] = {11,15,17,19,23,23,26,27,36,43,46,47,55,59,63,66,77,79,79,82,85,86,86,91,91,94,94,97,99};
int param1_7[] = {6,-54,90,98,-30,88,36,88,38,12,46,-66,-80,32,42,-96,62,-44,-80,-14,20,2,70,-46,96,-40,52,56,96,-82,24,98,-16,90,66};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {41,91,78,28,40,71,74,69,71,12,7,21,92,19,39,34};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2[] = {10,40,11,25,26,13,20,31,31,14};
int param3[] = {7,38,15,16,30,13,14,24,30,8};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | b) | [
"a) int",
"b) 1,",
"c) b)",
"d) )",
"e) ="
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int low, int high ) {
if ( high < low ) return arr [ 0 ];
if ( high == low ) return arr [ low ];
int mid = low + ( high - low ) / 2;
if ( mid < high && arr [ mid + 1 ] < arr [ mid ] ) return arr [ mid + 1 ];
if ( mid > low && arr [ mid ] < arr [ mid - 1 ] ) return arr [ mid ];
if ( arr [ high ] > arr [ mid ] ) return f_gold ( arr, low, mid - 1 );
return f_gold ( arr, mid + 1, high );
}
int f_filled ( int arr [ ], int low, int high ) {}
d - 1 ] ) return arr [ mid ];
if ( arr [ high ] > arr [ mid ] ) return f_gold ( arr, low, mid - 1 );
return f_gold ( arr, mid + 1, high );
}
int f_filled ( int arr [ ], int low, int high ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {16,22,50,64,68,79,84,88,89};
int param0_1[] = {88,-38,46,24,-52,-12,-90,28,18,14,-72,58,-98,28,-84,44,-42,-32,-22,-22,-82,-30,90,18,62,62,92,6,60,28,-90,92,82,62,98,-68,48,-74,-8,50,62,24,30,-86,98,-96,-98};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {26,66,94,28,38,31,92,66,81,8,36,64,80,32,48,71,72,54,61,60,89};
int param0_4[] = {-46,-26,-22,-14,46,62};
int param0_5[] = {0,1,1,1};
int param0_6[] = {14,81,87};
int param0_7[] = {4};
int param0_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {3,41,40,53,82,9,90,43,90,59,37,21,92,98,36,99,35,67,24,29,40,31,46,12,29,8,93,67,44,83,71,29,22,32,33,11,44,97,84,44,8,10,31,50,22,8};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {4,42,28,19,4,2,1,0,15,42};
int param2[] = {6,31,21,17,4,2,1,0,17,31};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int low, int high ) { if ( high < low ) return arr [ 0 ]; if ( high [MASK] low ) return arr [ low ]; int mid = low + ( high - low ) / 2; if ( mid < high && arr [ mid + 1 ] < arr [ mid ] ) return arr [ mid + 1 ]; if ( mid > low && arr [ mid ] < arr [ mid - 1 ] ) return arr [ mid ]; if ( arr [ high ] > arr [ mid ] ) return f_gold ( arr, low, mid - 1 ); return f_gold ( arr, mid + 1, high ); } int f_filled ( int arr [ ], int low, int high ) {}d - 1 ] ) return arr [ mid ];
if ( arr [ high ] > arr [ mid ] ) return f_gold ( arr, low, mid - 1 );
return f_gold ( arr, mid + 1, high );
}
int f_filled ( int arr [ ], int low, int high ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {16,22,50,64,68,79,84,88,89};
int param0_1[] = {88,-38,46,24,-52,-12,-90,28,18,14,-72,58,-98,28,-84,44,-42,-32,-22,-22,-82,-30,90,18,62,62,92,6,60,28,-90,92,82,62,98,-68,48,-74,-8,50,62,24,30,-86,98,-96,-98};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {26,66,94,28,38,31,92,66,81,8,36,64,80,32,48,71,72,54,61,60,89};
int param0_4[] = {-46,-26,-22,-14,46,62};
int param0_5[] = {0,1,1,1};
int param0_6[] = {14,81,87};
int param0_7[] = {4};
int param0_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {3,41,40,53,82,9,90,43,90,59,37,21,92,98,36,99,35,67,24,29,40,31,46,12,29,8,93,67,44,83,71,29,22,32,33,11,44,97,84,44,8,10,31,50,22,8};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {4,42,28,19,4,2,1,0,15,42};
int param2[] = {6,31,21,17,4,2,1,0,17,31};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | == | [
"a) i",
"b) ==",
"c) )",
"d) int",
"e) (l"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int x ) {
return ( - ( ~ x ) );
}
int f_filled ( int x ) {}
eturn ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int x ) {
return ( - ( ~ x ) );
}
int f_filled ( int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {20,68,52,61,3,88,41,78,94,18};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include [MASK] #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int x ) { return ( - ( ~ x ) ); } int f_filled ( int x ) {}eturn ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int x ) {
return ( - ( ~ x ) );
}
int f_filled ( int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {20,68,52,61,3,88,41,78,94,18};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | <math.h> | [
"a) dp",
"b) arr,",
"c) <math.h>",
"d) s",
"e) i"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int n ) {
return ( n - 1 ) * ( * min_element ( a, a + n ) );
}
int f_filled ( int a [ ], int n ) {}
id sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int n ) {
return ( n - 1 ) * ( * min_element ( a, a + n ) );
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,3,4,7,8,10,10,16,20,22,22,23,23,23,27,29,32,35,39,41,46,51,53,54,59,59,60,61,69,70,70,79,79,81,84,90,91,98};
int param0_1[] = {-6,10};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {20,61,92,45,75,26,83,5,85,27,39,88,36,39,83,41,56,77,39,69,72,98,39,15,29,69,64,92,96,49,59,62,53,82,40,37,29,41};
int param0_4[] = {-88,-60,-60,-58,-56,-56,-46,-44,-40,-38,-32,-28,-22,-18,-12,-4,-2,10,24,24,28,38,42,46,54,64,72,74,78,96,96};
int param0_5[] = {0,1,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,0,1,0,0,1,1,1,1,1,1,0,1,0,0,1,1,1,0,0,0,1,1,0,0,0,1,0,1,1};
int param0_6[] = {1,4,6,9,10,12,17,17,18,21,22,26,26,31,32,33,34,39,42,43,45,46,48,50,53,53,54,55,60,61,62,63,63,64,70,70,70,71,71,78,86,88,91,92,95,95,96,97,99};
int param0_7[] = {-42,44,-80,-60,48,66,54,-76,26,-74,-10,46,-50,42,-26,-24,-14,36,-2,-26,16,-10,20,-88,-78};
int param0_8[] = {0,0,0,0,1,1,1,1,1,1};
int param0_9[] = {65,32,66,82,86,98,15,33,57,3,73,45,90,82,33,99,44,76,50,89,5,7,64};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {25,1,15,23,26,39,28,19,5,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; [MASK] int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a [ ], int n ) { return ( n - 1 ) * ( * min_element ( a, a + n ) ); } int f_filled ( int a [ ], int n ) {}id sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int n ) {
return ( n - 1 ) * ( * min_element ( a, a + n ) );
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,3,4,7,8,10,10,16,20,22,22,23,23,23,27,29,32,35,39,41,46,51,53,54,59,59,60,61,69,70,70,79,79,81,84,90,91,98};
int param0_1[] = {-6,10};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {20,61,92,45,75,26,83,5,85,27,39,88,36,39,83,41,56,77,39,69,72,98,39,15,29,69,64,92,96,49,59,62,53,82,40,37,29,41};
int param0_4[] = {-88,-60,-60,-58,-56,-56,-46,-44,-40,-38,-32,-28,-22,-18,-12,-4,-2,10,24,24,28,38,42,46,54,64,72,74,78,96,96};
int param0_5[] = {0,1,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,0,1,0,0,1,1,1,1,1,1,0,1,0,0,1,1,1,0,0,0,1,1,0,0,0,1,0,1,1};
int param0_6[] = {1,4,6,9,10,12,17,17,18,21,22,26,26,31,32,33,34,39,42,43,45,46,48,50,53,53,54,55,60,61,62,63,63,64,70,70,70,71,71,78,86,88,91,92,95,95,96,97,99};
int param0_7[] = {-42,44,-80,-60,48,66,54,-76,26,-74,-10,46,-50,42,-26,-24,-14,36,-2,-26,16,-10,20,-88,-78};
int param0_8[] = {0,0,0,0,1,1,1,1,1,1};
int param0_9[] = {65,32,66,82,86,98,15,33,57,3,73,45,90,82,33,99,44,76,50,89,5,7,64};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {25,1,15,23,26,39,28,19,5,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | } | [
"a) :",
"b) ||",
"c) n",
"d) }",
"e) int"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char s [] ) {
int aCount = 0;
int bCount = 0;
int cCount = 0;
for ( unsigned int i = 0;
i < len(s);
i ++ ) {
if ( s [ i ] == 'a' ) aCount = ( 1 + 2 * aCount );
else if ( s [ i ] == 'b' ) bCount = ( aCount + 2 * bCount );
else if ( s [ i ] == 'c' ) cCount = ( bCount + 2 * cCount );
}
return cCount;
}
int f_filled ( char s [] ) {}
* aCount );
else if ( s [ i ] == 'b' ) bCount = ( aCount + 2 * bCount );
else if ( s [ i ] == 'c' ) cCount = ( bCount + 2 * cCount );
}
return cCount;
}
int f_filled ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"","abbc","abcabc","agsdbkfdc","ababab","aaaaaaa","aabaaabcc","19","1001100","DtAnuQbU"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char s [] ) [MASK] int aCount = 0; int bCount = 0; int cCount = 0; for ( unsigned int i = 0; i < len(s); i ++ ) { if ( s [ i ] == 'a' ) aCount = ( 1 + 2 * aCount ); else if ( s [ i ] == 'b' ) bCount = ( aCount + 2 * bCount ); else if ( s [ i ] == 'c' ) cCount = ( bCount + 2 * cCount ); } return cCount; } int f_filled ( char s [] ) {} * aCount );
else if ( s [ i ] == 'b' ) bCount = ( aCount + 2 * bCount );
else if ( s [ i ] == 'c' ) cCount = ( bCount + 2 * cCount );
}
return cCount;
}
int f_filled ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"","abbc","abcabc","agsdbkfdc","ababab","aaaaaaa","aabaaabcc","19","1001100","DtAnuQbU"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | { | [
"a) )",
"b) ]",
"c) {",
"d) f_gold",
"e) }"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int size ) {
unordered_map < int, int > hash;
for ( int i = 0;
i < size;
i ++ ) {
hash [ arr [ i ] ] ++;
}
for ( auto i : hash ) {
if ( i . second % 2 != 0 ) {
return i . first;
}
}
return - 1;
}
int f_filled ( int arr [ ], int size ) {}
e;
i ++ ) {
hash [ arr [ i ] ] ++;
}
for ( auto i : hash ) {
if ( i . second % 2 != 0 ) {
return i . first;
}
}
return - 1;
}
int f_filled ( int arr [ ], int size ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {49,90};
int param0_1[] = {-96,94,92,-24,48,54,-30,-86,28,-18,12,-64,-36,68,68,-78,-6,30,-84,20,52,-36,40,-62,90,-48,86,98,12,44,98,-66,52,34,36,76,-50,-20,-20,-20};
int param0_2[] = {0,1};
int param0_3[] = {79,55,18,99,38,93,19,49,21,74,16,76,82,52,86,17,42,9,6,63,1,40,75,59,41,81};
int param0_4[] = {-90,-84,-82,-68,-66,-66,-60,-60,-48,-44,-36,-34,-30,-16,-14,-12,-10,-6,2,10,10,14,22,26,30,34,46,50,52,62,64,64,66,72,74,78,78,82,84,88,92};
int param0_5[] = {1,1,0,0,1,0,1,1,0,0,1,1,1,1,0,0,1,1,1,0,1,0,0,1,0,1};
int param0_6[] = {2,4,5,7,7,18,18,23,23,25,25,31,41,43,45,46,52,52,55,64,69,69,80,81,84,90,91,93,94,94,94,94,96,98,99};
int param0_7[] = {86,66,-8,2,-18,-22,38,4,-38,-54,78,64,78,20,-32,84,-70,66,-46,12,-12,8,44,14,20};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {11,4,98,38,20,41,1,8};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {1,39,1,23,23,18,20,20,21,7};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int size ) { unordered_map < int, int > hash; for ( int i = 0; i < size; i [MASK] ) { hash [ arr [ i ] ] ++; } for ( auto i : hash ) { if ( i . second % 2 != 0 ) { return i . first; } } return - 1; } int f_filled ( int arr [ ], int size ) {}e;
i ++ ) {
hash [ arr [ i ] ] ++;
}
for ( auto i : hash ) {
if ( i . second % 2 != 0 ) {
return i . first;
}
}
return - 1;
}
int f_filled ( int arr [ ], int size ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {49,90};
int param0_1[] = {-96,94,92,-24,48,54,-30,-86,28,-18,12,-64,-36,68,68,-78,-6,30,-84,20,52,-36,40,-62,90,-48,86,98,12,44,98,-66,52,34,36,76,-50,-20,-20,-20};
int param0_2[] = {0,1};
int param0_3[] = {79,55,18,99,38,93,19,49,21,74,16,76,82,52,86,17,42,9,6,63,1,40,75,59,41,81};
int param0_4[] = {-90,-84,-82,-68,-66,-66,-60,-60,-48,-44,-36,-34,-30,-16,-14,-12,-10,-6,2,10,10,14,22,26,30,34,46,50,52,62,64,64,66,72,74,78,78,82,84,88,92};
int param0_5[] = {1,1,0,0,1,0,1,1,0,0,1,1,1,1,0,0,1,1,1,0,1,0,0,1,0,1};
int param0_6[] = {2,4,5,7,7,18,18,23,23,25,25,31,41,43,45,46,52,52,55,64,69,69,80,81,84,90,91,93,94,94,94,94,96,98,99};
int param0_7[] = {86,66,-8,2,-18,-22,38,4,-38,-54,78,64,78,20,-32,84,-70,66,-46,12,-12,8,44,14,20};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {11,4,98,38,20,41,1,8};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {1,39,1,23,23,18,20,20,21,7};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ++ | [
"a) n",
"b) ++",
"c) int",
"d) int",
"e) ]"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char s [ ] ) {
int n = strlen ( s );
int count = 0;
for ( int i = 0;
i < n;
++ i ) if ( s [ i ] == '4' || s [ i ] == '8' || s [ i ] == '0' ) count ++;
for ( int i = 0;
i < n - 1;
++ i ) {
int h = ( s [ i ] - '0' ) * 10 + ( s [ i + 1 ] - '0' );
if ( h % 4 == 0 ) count = count + i + 1;
}
return count;
}
int f_filled ( char s [ ] ) {}
( int i = 0;
i < n - 1;
++ i ) {
int h = ( s [ i ] - '0' ) * 10 + ( s [ i + 1 ] - '0' );
if ( h % 4 == 0 ) count = count + i + 1;
}
return count;
}
int f_filled ( char s [ ] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"Qaq","9400761825850","0011001111","lasWqrLRq","5662","110"," tOYKf","6536991235305","11111","uZftT iDHcYiCt"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(¶m0[i].front()) == f_gold(¶m0[i].front()))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char s [ ] ) { int n = strlen ( s ); int count = 0; for ( int i = 0; i < n; ++ i ) if ( s [ i ] == '4' || s [ i ] == '8' || s [ i ] == '0' ) count ++; for ( int i = 0; i < n - 1; ++ i ) { int h = ( s [ i ] - '0' ) * 10 + ( s [ i + 1 ] [MASK] '0' ); if ( h % 4 == 0 ) count = count + i + 1; } return count; } int f_filled ( char s [ ] ) {} ( int i = 0;
i < n - 1;
++ i ) {
int h = ( s [ i ] - '0' ) * 10 + ( s [ i + 1 ] - '0' );
if ( h % 4 == 0 ) count = count + i + 1;
}
return count;
}
int f_filled ( char s [ ] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"Qaq","9400761825850","0011001111","lasWqrLRq","5662","110"," tOYKf","6536991235305","11111","uZftT iDHcYiCt"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(¶m0[i].front()) == f_gold(¶m0[i].front()))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | - | [
"a) ]",
"b) /",
"c) y;",
"d) minute_angle",
"e) -"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( char str [] ) {
int n = strlen(str);
if ( ( str [ n - 1 ] - '0' ) % 2 != 0 ) return false;
int digitSum = 0;
for ( int i = 0;
i < n;
i ++ ) digitSum += ( str [ i ] - '0' );
return ( digitSum % 3 == 0 );
}
bool f_filled ( char str [] ) {}
- 1 ] - '0' ) % 2 != 0 ) return false;
int digitSum = 0;
for ( int i = 0;
i < n;
i ++ ) digitSum += ( str [ i ] - '0' );
return ( digitSum % 3 == 0 );
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"2112","1124","1110","O","65530186","132","UqOE","587","1010","QETUfLQ"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / [MASK] (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( char str [] ) { int n = strlen(str); if ( ( str [ n - 1 ] - '0' ) % 2 != 0 ) return false; int digitSum = 0; for ( int i = 0; i < n; i ++ ) digitSum += ( str [ i ] - '0' ); return ( digitSum % 3 == 0 ); } bool f_filled ( char str [] ) {}- 1 ] - '0' ) % 2 != 0 ) return false;
int digitSum = 0;
for ( int i = 0;
i < n;
i ++ ) digitSum += ( str [ i ] - '0' );
return ( digitSum % 3 == 0 );
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"2112","1124","1110","O","65530186","132","UqOE","587","1010","QETUfLQ"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | sizeof | [
"a) sizeof",
"b) >=",
"c) -",
"d) [",
"e) !="
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
void f_gold ( int arr [ ], int n ) {
for ( int i = 0;
i < n;
i ++ ) {
arr [ i ] = i + 1;
}
}
void f_filled ( int arr [ ], int n ) {}
], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
void f_gold ( int arr [ ], int n ) {
for ( int i = 0;
i < n;
i ++ ) {
arr [ i ] = i + 1;
}
}
void f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,3,6,7,9,11,15,15,17,19,21,23,26,27,37,48,48,51,53,53,59,64,69,69,70,71,72,84,93,96};
int param0_1[] = {66,-28,6,25,-65,19,-86,-86,-90,40,-62};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {85,84,8,36,93,76,14,54,85,86};
int param0_4[] = {-90,-82,-80,-73,-67,-62,-62,-61,-58,-56,-56,-52,-50,-49,-49,-43,-43,-30,-26,-26,-15,-14,-13,-4,10,19,20,22,26,29,34,35,37,45,49,52,54,66,67,80,84,87,89,90};
int param0_5[] = {1,1,0,0,0,1,0,1,1,1,0,0,0,1,0,1,0,0,1,1,0,0,0,1,1,0,0,1,0,1,1,1};
int param0_6[] = {10,11,13,19,19,30,33,36,40,42,44,47,49,52,53,58,66,68,72,82,87,89,90,94};
int param0_7[] = {-46,-35,40,-76,-66,-47,36,-82,-43,12,-95,54,58,82,-87,-17,-71,-97,-10,4,23,86,-24};
int param0_8[] = {0,0,0,0,0,1,1,1,1,1,1};
int param0_9[] = {88,76,16,23,40,60,73,32,15,13,5,75,74,52,77,41,53,50,15,7,40,28,32,99,15,85};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {19,8,26,9,31,29,21,12,6,18};
int filled_function_param0_0[] = {3,3,6,7,9,11,15,15,17,19,21,23,26,27,37,48,48,51,53,53,59,64,69,69,70,71,72,84,93,96};
int filled_function_param0_1[] = {66,-28,6,25,-65,19,-86,-86,-90,40,-62};
int filled_function_param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int filled_function_param0_3[] = {85,84,8,36,93,76,14,54,85,86};
int filled_function_param0_4[] = {-90,-82,-80,-73,-67,-62,-62,-61,-58,-56,-56,-52,-50,-49,-49,-43,-43,-30,-26,-26,-15,-14,-13,-4,10,19,20,22,26,29,34,35,37,45,49,52,54,66,67,80,84,87,89,90};
int filled_function_param0_5[] = {1,1,0,0,0,1,0,1,1,1,0,0,0,1,0,1,0,0,1,1,0,0,0,1,1,0,0,1,0,1,1,1};
int filled_function_param0_6[] = {10,11,13,19,19,30,33,36,40,42,44,47,49,52,53,58,66,68,72,82,87,89,90,94};
int filled_function_param0_7[] = {-46,-35,40,-76,-66,-47,36,-82,-43,12,-95,54,58,82,-87,-17,-71,-97,-10,4,23,86,-24};
int filled_function_param0_8[] = {0,0,0,0,0,1,1,1,1,1,1};
int filled_function_param0_9[] = {88,76,16,23,40,60,73,32,15,13,5,75,74,52,77,41,53,50,15,7,40,28,32,99,15,85};
int *filled_function_param0[10] = {filled_function_param0_0,filled_function_param0_1,filled_function_param0_2,filled_function_param0_3,filled_function_param0_4,filled_function_param0_5,filled_function_param0_6,filled_function_param0_7,filled_function_param0_8,filled_function_param0_9};
int filled_function_param1[] = {19,8,26,9,31,29,21,12,6,18};
for(int i = 0; i < len(param0); ++i)
{
f_filled(filled_function_param0[i],filled_function_param1[i]);
f_gold(param0[i],param1[i]);
if(equal(begin(param0[i]), end(param0[i]), begin(filled_function_param0[i])) && param1[i] == filled_function_param1[i])
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: [MASK] } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} void f_gold ( int arr [ ], int n ) { for ( int i = 0; i < n; i ++ ) { arr [ i ] = i + 1; } } void f_filled ( int arr [ ], int n ) {}], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
void f_gold ( int arr [ ], int n ) {
for ( int i = 0;
i < n;
i ++ ) {
arr [ i ] = i + 1;
}
}
void f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,3,6,7,9,11,15,15,17,19,21,23,26,27,37,48,48,51,53,53,59,64,69,69,70,71,72,84,93,96};
int param0_1[] = {66,-28,6,25,-65,19,-86,-86,-90,40,-62};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {85,84,8,36,93,76,14,54,85,86};
int param0_4[] = {-90,-82,-80,-73,-67,-62,-62,-61,-58,-56,-56,-52,-50,-49,-49,-43,-43,-30,-26,-26,-15,-14,-13,-4,10,19,20,22,26,29,34,35,37,45,49,52,54,66,67,80,84,87,89,90};
int param0_5[] = {1,1,0,0,0,1,0,1,1,1,0,0,0,1,0,1,0,0,1,1,0,0,0,1,1,0,0,1,0,1,1,1};
int param0_6[] = {10,11,13,19,19,30,33,36,40,42,44,47,49,52,53,58,66,68,72,82,87,89,90,94};
int param0_7[] = {-46,-35,40,-76,-66,-47,36,-82,-43,12,-95,54,58,82,-87,-17,-71,-97,-10,4,23,86,-24};
int param0_8[] = {0,0,0,0,0,1,1,1,1,1,1};
int param0_9[] = {88,76,16,23,40,60,73,32,15,13,5,75,74,52,77,41,53,50,15,7,40,28,32,99,15,85};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {19,8,26,9,31,29,21,12,6,18};
int filled_function_param0_0[] = {3,3,6,7,9,11,15,15,17,19,21,23,26,27,37,48,48,51,53,53,59,64,69,69,70,71,72,84,93,96};
int filled_function_param0_1[] = {66,-28,6,25,-65,19,-86,-86,-90,40,-62};
int filled_function_param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int filled_function_param0_3[] = {85,84,8,36,93,76,14,54,85,86};
int filled_function_param0_4[] = {-90,-82,-80,-73,-67,-62,-62,-61,-58,-56,-56,-52,-50,-49,-49,-43,-43,-30,-26,-26,-15,-14,-13,-4,10,19,20,22,26,29,34,35,37,45,49,52,54,66,67,80,84,87,89,90};
int filled_function_param0_5[] = {1,1,0,0,0,1,0,1,1,1,0,0,0,1,0,1,0,0,1,1,0,0,0,1,1,0,0,1,0,1,1,1};
int filled_function_param0_6[] = {10,11,13,19,19,30,33,36,40,42,44,47,49,52,53,58,66,68,72,82,87,89,90,94};
int filled_function_param0_7[] = {-46,-35,40,-76,-66,-47,36,-82,-43,12,-95,54,58,82,-87,-17,-71,-97,-10,4,23,86,-24};
int filled_function_param0_8[] = {0,0,0,0,0,1,1,1,1,1,1};
int filled_function_param0_9[] = {88,76,16,23,40,60,73,32,15,13,5,75,74,52,77,41,53,50,15,7,40,28,32,99,15,85};
int *filled_function_param0[10] = {filled_function_param0_0,filled_function_param0_1,filled_function_param0_2,filled_function_param0_3,filled_function_param0_4,filled_function_param0_5,filled_function_param0_6,filled_function_param0_7,filled_function_param0_8,filled_function_param0_9};
int filled_function_param1[] = {19,8,26,9,31,29,21,12,6,18};
for(int i = 0; i < len(param0); ++i)
{
f_filled(filled_function_param0[i],filled_function_param1[i]);
f_gold(param0[i],param1[i]);
if(equal(begin(param0[i]), end(param0[i]), begin(filled_function_param0[i])) && param1[i] == filled_function_param1[i])
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | y; | [
"a) j",
"b) {",
"c) y;",
"d) n",
"e) ("
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int a, int b, int c, int d ) {
int sum = a * a + b * b + c * c;
if ( d * d == sum ) return true;
else return false;
}
bool f_filled ( int a, int b, int c, int d ) {}
pfunc);}
bool f_gold ( int a, int b, int c, int d ) {
int sum = a * a + b * b + c * c;
if ( d * d == sum ) return true;
else return false;
}
bool f_filled ( int a, int b, int c, int d ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,3,0,-1,82,14,6,13,96,70};
int param1[] = {2,2,0,-1,79,57,96,7,65,33};
int param2[] = {2,5,0,-1,6,35,45,3,72,6};
int param3[] = {3,38,0,1,59,29,75,63,93,2};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void [MASK] a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int a, int b, int c, int d ) { int sum = a * a + b * b + c * c; if ( d * d == sum ) return true; else return false; } bool f_filled ( int a, int b, int c, int d ) {}pfunc);}
bool f_gold ( int a, int b, int c, int d ) {
int sum = a * a + b * b + c * c;
if ( d * d == sum ) return true;
else return false;
}
bool f_filled ( int a, int b, int c, int d ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,3,0,-1,82,14,6,13,96,70};
int param1[] = {2,2,0,-1,79,57,96,7,65,33};
int param2[] = {2,5,0,-1,6,35,45,3,72,6};
int param3[] = {3,38,0,1,59,29,75,63,93,2};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | * | [
"a) n",
"b) *",
"c) true",
"d) max",
"e) 1"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int sum = 0;
sort ( arr, arr + n );
for ( int i = 0;
i < n / 2;
i ++ ) {
sum -= ( 2 * arr [ i ] );
sum += ( 2 * arr [ n - i - 1 ] );
}
return sum;
}
int f_filled ( int arr [ ], int n ) {}
sort ( arr, arr + n );
for ( int i = 0;
i < n / 2;
i ++ ) {
sum -= ( 2 * arr [ i ] );
sum += ( 2 * arr [ n - i - 1 ] );
}
return sum;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {8,9,12,13,17,21,24,29,37,37,39,40,41,45,49,50,53,54,56,59,60,60,70,71,72,74,77,77,78,85,89,89,90,90,95,98,98};
int param0_1[] = {0,48,-32,28,-84,14,30,-80,92,76,-52,-20,52,78,20,32,96,66,48,26,88,6,94,32,-40,44,-84,54,-84,-80,-80,-64,-92,-84,-16,-18};
int param0_2[] = {0,0,0,1,1,1};
int param0_3[] = {47,7,84,96,59,53,80};
int param0_4[] = {-88,-80,-68,-62,-60,-60,-48,-46,-44,-38,-16,-16,0,0,2,8,20,36,40,40,44,54,60,68,70,82,82,84,92,94,96};
int param0_5[] = {1,1,1,0,0,1,1,1,1,1,1,0,0,1,1,1,0,0,0,1,1,0,1,0,0,0,0,1,0,1,1,1,1,1,0,0,0,1,0,0,1,0,0,0,1,0,1,1};
int param0_6[] = {2,5,10,11,13,14,15,17,17,23,23,24,27,27,28,29,30,40,42,43,46,47,51,52,57,64,65,73,74,75,76,77,81,81,82,87,89,93,95,95,99};
int param0_7[] = {-72,-84,84,2,-76,48,12,-72,-92,-72,38,26,-38,26,50,2,20,26,-48,30,24,-12,-84,-54,20,-16,-94,26,-22,86};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {57,74,53,52,80,31,27,53,8,57,46,73,46,56,73,84,37,7,97};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {34,24,3,5,29,32,35,21,37,13};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int [MASK] { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int sum = 0; sort ( arr, arr + n ); for ( int i = 0; i < n / 2; i ++ ) { sum -= ( 2 * arr [ i ] ); sum += ( 2 * arr [ n - i - 1 ] ); } return sum; } int f_filled ( int arr [ ], int n ) {}
sort ( arr, arr + n );
for ( int i = 0;
i < n / 2;
i ++ ) {
sum -= ( 2 * arr [ i ] );
sum += ( 2 * arr [ n - i - 1 ] );
}
return sum;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {8,9,12,13,17,21,24,29,37,37,39,40,41,45,49,50,53,54,56,59,60,60,70,71,72,74,77,77,78,85,89,89,90,90,95,98,98};
int param0_1[] = {0,48,-32,28,-84,14,30,-80,92,76,-52,-20,52,78,20,32,96,66,48,26,88,6,94,32,-40,44,-84,54,-84,-80,-80,-64,-92,-84,-16,-18};
int param0_2[] = {0,0,0,1,1,1};
int param0_3[] = {47,7,84,96,59,53,80};
int param0_4[] = {-88,-80,-68,-62,-60,-60,-48,-46,-44,-38,-16,-16,0,0,2,8,20,36,40,40,44,54,60,68,70,82,82,84,92,94,96};
int param0_5[] = {1,1,1,0,0,1,1,1,1,1,1,0,0,1,1,1,0,0,0,1,1,0,1,0,0,0,0,1,0,1,1,1,1,1,0,0,0,1,0,0,1,0,0,0,1,0,1,1};
int param0_6[] = {2,5,10,11,13,14,15,17,17,23,23,24,27,27,28,29,30,40,42,43,46,47,51,52,57,64,65,73,74,75,76,77,81,81,82,87,89,93,95,95,99};
int param0_7[] = {-72,-84,84,2,-76,48,12,-72,-92,-72,38,26,-38,26,50,2,20,26,-48,30,24,-12,-84,-54,20,-16,-94,26,-22,86};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {57,74,53,52,80,31,27,53,8,57,46,73,46,56,73,84,37,7,97};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {34,24,3,5,29,32,35,21,37,13};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | y) | [
"a) #include",
"b) math.sqrt",
"c) 0",
"d) y)",
"e) <stdio.h>"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr1 [ ], int n, int arr2 [ ], int m ) {
int table [ m ];
for ( int j = 0;
j < m;
j ++ ) table [ j ] = 0;
for ( int i = 0;
i < n;
i ++ ) {
int current = 0;
for ( int j = 0;
j < m;
j ++ ) {
if ( arr1 [ i ] == arr2 [ j ] ) if ( current + 1 > table [ j ] ) table [ j ] = current + 1;
if ( arr1 [ i ] > arr2 [ j ] ) if ( table [ j ] > current ) current = table [ j ];
}
}
int result = 0;
for ( int i = 0;
i < m;
i ++ ) if ( table [ i ] > result ) result = table [ i ];
return result;
}
int f_filled ( int arr1 [ ], int n, int arr2 [ ], int m ) {}
}
}
int result = 0;
for ( int i = 0;
i < m;
i ++ ) if ( table [ i ] > result ) result = table [ i ];
return result;
}
int f_filled ( int arr1 [ ], int n, int arr2 [ ], int m ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,7,9,35,43,51,51,66,88};
int param0_1[] = {-52,52,-92,-46,-94,30,-36,18,-98,22,-36,96,-88,-50,50};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {5,74,29};
int param0_4[] = {-84,-74,-70,-62,-56,-56,-52,-2,6,24,28,44,44,52};
int param0_5[] = {0,0,0,1,0,1,0,0,1,1,1,1,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0,0,1,0};
int param0_6[] = {3,4,4,7,15,15,16,22,32,32,37,39,39,41,43,46,47,47,49,75,79,80,86,88,93};
int param0_7[] = {70,-64,0,52,32,-98,38,-8,34,70,98,58,-48,-60,-28,-22,-72,82,-98,-36};
int param0_8[] = {0,0,1,1,1,1,1,1};
int param0_9[] = {46,87,98};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {5,7,36,1,8,17,19,16,7,2};
int param2_0[] = {10,21,38,50,65,67,87,93,99};
int param2_1[] = {-58,40,56,-62,-92,-94,40,18,-2,-76,-78,-14,44,84,4};
int param2_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param2_3[] = {57,33,48};
int param2_4[] = {-98,-96,-88,-66,-32,-26,-24,-20,-4,20,48,74,90,96};
int param2_5[] = {1,0,1,1,0,0,0,0,1,1,1,0,1,0,0,0,0,1,0,0,0,0,1,1,1,1,1,1,1,0};
int param2_6[] = {9,12,15,20,22,27,28,28,30,31,35,39,47,58,58,60,73,74,76,78,80,86,95,96,98};
int param2_7[] = {-18,88,-40,-52,30,-10,-18,-56,84,-22,-64,80,-14,-64,40,92,48,-8,24,82};
int param2_8[] = {0,1,1,1,1,1,1,1};
int param2_9[] = {67,31,54};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {8,10,22,1,12,15,14,12,7,2};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr1 [ ], int n, int arr2 [ ], int m ) { int table [ m ]; for ( int j = 0; j < m; j ++ ) table [ j ] = 0; for ( int i = 0; i < n; i ++ ) { int current = 0; for ( int j = 0; j < m; j ++ ) { if ( arr1 [ i ] == arr2 [ j ] ) if ( current + 1 > table [ j ] ) table [ j ] = current + 1; if ( arr1 [ i ] > arr2 [ j ] ) if ( table [ [MASK] ] > current ) current = table [ j ]; } } int result = 0; for ( int i = 0; i < m; i ++ ) if ( table [ i ] > result ) result = table [ i ]; return result; } int f_filled ( int arr1 [ ], int n, int arr2 [ ], int m ) {}
}
}
int result = 0;
for ( int i = 0;
i < m;
i ++ ) if ( table [ i ] > result ) result = table [ i ];
return result;
}
int f_filled ( int arr1 [ ], int n, int arr2 [ ], int m ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,7,9,35,43,51,51,66,88};
int param0_1[] = {-52,52,-92,-46,-94,30,-36,18,-98,22,-36,96,-88,-50,50};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {5,74,29};
int param0_4[] = {-84,-74,-70,-62,-56,-56,-52,-2,6,24,28,44,44,52};
int param0_5[] = {0,0,0,1,0,1,0,0,1,1,1,1,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0,0,1,0};
int param0_6[] = {3,4,4,7,15,15,16,22,32,32,37,39,39,41,43,46,47,47,49,75,79,80,86,88,93};
int param0_7[] = {70,-64,0,52,32,-98,38,-8,34,70,98,58,-48,-60,-28,-22,-72,82,-98,-36};
int param0_8[] = {0,0,1,1,1,1,1,1};
int param0_9[] = {46,87,98};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {5,7,36,1,8,17,19,16,7,2};
int param2_0[] = {10,21,38,50,65,67,87,93,99};
int param2_1[] = {-58,40,56,-62,-92,-94,40,18,-2,-76,-78,-14,44,84,4};
int param2_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param2_3[] = {57,33,48};
int param2_4[] = {-98,-96,-88,-66,-32,-26,-24,-20,-4,20,48,74,90,96};
int param2_5[] = {1,0,1,1,0,0,0,0,1,1,1,0,1,0,0,0,0,1,0,0,0,0,1,1,1,1,1,1,1,0};
int param2_6[] = {9,12,15,20,22,27,28,28,30,31,35,39,47,58,58,60,73,74,76,78,80,86,95,96,98};
int param2_7[] = {-18,88,-40,-52,30,-10,-18,-56,84,-22,-64,80,-14,-64,40,92,48,-8,24,82};
int param2_8[] = {0,1,1,1,1,1,1,1};
int param2_9[] = {67,31,54};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {8,10,22,1,12,15,14,12,7,2};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | j | [
"a) /",
"b) j",
"c) i",
"d) return",
"e) ."
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b, int m ) {
int n = ( int ) sqrt ( m ) + 1;
int an = 1;
for ( int i = 0;
i < n;
++ i ) an = ( an * a ) % m;
unordered_map < int, int > value;
for ( int i = 1, cur = an;
i <= n;
++ i ) {
if ( ! value [ cur ] ) value [ cur ] = i;
cur = ( cur * an ) % m;
}
for ( int i = 0, cur = b;
i <= n;
++ i ) {
if ( value [ cur ] ) {
int ans = value [ cur ] * n - i;
if ( ans < m ) return ans;
}
cur = ( cur * a ) % m;
}
return - 1;
}
int f_filled ( int a, int b, int m ) {}
) {
if ( value [ cur ] ) {
int ans = value [ cur ] * n - i;
if ( ans < m ) return ans;
}
cur = ( cur * a ) % m;
}
return - 1;
}
int f_filled ( int a, int b, int m ) {}
int main(void) {
int n_success = 0;
int param0[] = {38,10,55,3,80,65,47,50,44,47};
int param1[] = {81,97,63,18,48,87,79,74,86,8};
int param2[] = {29,69,15,41,77,97,19,90,56,77};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a, int b, int m ) { int n = ( int ) sqrt ( m ) + 1; int an = 1; for ( int i = 0; i < n; ++ i ) an = ( an * a ) % m; unordered_map < int, int > value; for ( int i = 1, cur = an; i <= n; ++ i ) { if ( ! value [ cur ] ) value [ cur ] = i; cur = ( cur * an ) % m; } for ( int i = 0, cur = b; i <= n; ++ i ) { if ( value [ cur ] ) { int ans = value [ cur ] * n - i; if ( ans < m ) return ans; } cur = ( cur * a ) [MASK] m; } return - 1; } int f_filled ( int a, int b, int m ) {}) {
if ( value [ cur ] ) {
int ans = value [ cur ] * n - i;
if ( ans < m ) return ans;
}
cur = ( cur * a ) % m;
}
return - 1;
}
int f_filled ( int a, int b, int m ) {}
int main(void) {
int n_success = 0;
int param0[] = {38,10,55,3,80,65,47,50,44,47};
int param1[] = {81,97,63,18,48,87,79,74,86,8};
int param2[] = {29,69,15,41,77,97,19,90,56,77};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | % | [
"a) ],",
"b) [",
"c) N,",
"d) %",
"e) *"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int p [ ], int n ) {
int m [ n ] [ n ];
int i, j, k, L, q;
for ( i = 1;
i < n;
i ++ ) m [ i ] [ i ] = 0;
for ( L = 2;
L < n;
L ++ ) {
for ( i = 1;
i < n - L + 1;
i ++ ) {
j = i + L - 1;
m [ i ] [ j ] = INT_MAX;
for ( k = i;
k <= j - 1;
k ++ ) {
q = m [ i ] [ k ] + m [ k + 1 ] [ j ] + p [ i - 1 ] * p [ k ] * p [ j ];
if ( q < m [ i ] [ j ] ) m [ i ] [ j ] = q;
}
}
}
return m [ 1 ] [ n - 1 ];
}
int f_filled ( int p [ ], int n ) {}
k ] + m [ k + 1 ] [ j ] + p [ i - 1 ] * p [ k ] * p [ j ];
if ( q < m [ i ] [ j ] ) m [ i ] [ j ] = q;
}
}
}
return m [ 1 ] [ n - 1 ];
}
int f_filled ( int p [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,4,11,17,26,33,37,51,62,70,71,73,74,74,81,82,83,90,95,98,98};
int param0_1[] = {-50,74,-8,2,-24,28,-86,34,-36,92,-70,-98};
int param0_2[] = {0,0,0,1,1,1,1};
int param0_3[] = {4,73,3,88,79,40,25,58,39,53,32,20,95,60,60,98,23,95,42,26,95,14,43,97,30,83,29,37,74,72,37,31,32,83,57,40,56,95,8,79,67,62};
int param0_4[] = {-92,-88,-88,-88,-86,-84,-80,-78,-76,-74,-72,-68,-68,-66,-62,-42,-34,-30,-28,-24,-20,-14,-12,-10,-8,-8,-8,6,10,26,26,36,38,42,46,48,48,54,54,58,60,66,70,76,78,80,82,98};
int param0_5[] = {1,1,0,1,0,0,1};
int param0_6[] = {8,25,38,39,41,57,71,89};
int param0_7[] = {76,-28,20,62,-44,8,-46,52,26,76,22,38,-36,10,2,-86,42,-62,-68,-56,10};
int param0_8[] = {0,0,0,0,1,1,1};
int param0_9[] = {98,96,76,76,8,4,53,34,54,10,98,46,58,7,36,72,32,59,52,99,40,52,50,43,26,93,76,90,12,82,31,50,55,34,61,78};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {20,10,3,41,47,4,6,18,5,26};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < [MASK] x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int p [ ], int n ) { int m [ n ] [ n ]; int i, j, k, L, q; for ( i = 1; i < n; i ++ ) m [ i ] [ i ] = 0; for ( L = 2; L < n; L ++ ) { for ( i = 1; i < n - L + 1; i ++ ) { j = i + L - 1; m [ i ] [ j ] = INT_MAX; for ( k = i; k <= j - 1; k ++ ) { q = m [ i ] [ k ] + m [ k + 1 ] [ j ] + p [ i - 1 ] * p [ k ] * p [ j ]; if ( q < m [ i ] [ j ] ) m [ i ] [ j ] = q; } } } return m [ 1 ] [ n - 1 ]; } int f_filled ( int p [ ], int n ) {}k ] + m [ k + 1 ] [ j ] + p [ i - 1 ] * p [ k ] * p [ j ];
if ( q < m [ i ] [ j ] ) m [ i ] [ j ] = q;
}
}
}
return m [ 1 ] [ n - 1 ];
}
int f_filled ( int p [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,4,11,17,26,33,37,51,62,70,71,73,74,74,81,82,83,90,95,98,98};
int param0_1[] = {-50,74,-8,2,-24,28,-86,34,-36,92,-70,-98};
int param0_2[] = {0,0,0,1,1,1,1};
int param0_3[] = {4,73,3,88,79,40,25,58,39,53,32,20,95,60,60,98,23,95,42,26,95,14,43,97,30,83,29,37,74,72,37,31,32,83,57,40,56,95,8,79,67,62};
int param0_4[] = {-92,-88,-88,-88,-86,-84,-80,-78,-76,-74,-72,-68,-68,-66,-62,-42,-34,-30,-28,-24,-20,-14,-12,-10,-8,-8,-8,6,10,26,26,36,38,42,46,48,48,54,54,58,60,66,70,76,78,80,82,98};
int param0_5[] = {1,1,0,1,0,0,1};
int param0_6[] = {8,25,38,39,41,57,71,89};
int param0_7[] = {76,-28,20,62,-44,8,-46,52,26,76,22,38,-36,10,2,-86,42,-62,-68,-56,10};
int param0_8[] = {0,0,0,0,1,1,1};
int param0_9[] = {98,96,76,76,8,4,53,34,54,10,98,46,58,7,36,72,32,59,52,99,40,52,50,43,26,93,76,90,12,82,31,50,55,34,61,78};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {20,10,3,41,47,4,6,18,5,26};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | y)? | [
"a) bin",
"b) [",
"c) y)?",
"d) i",
"e) ["
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
char f_gold [] ( char s [], char c1, char c2 ) {
int l = strlen(s);
for ( int i = 0;
i < l;
i ++ ) {
if ( s [ i ] == c1 ) s [ i ] = c2;
else if ( s [ i ] == c2 ) s [ i ] = c1;
}
return s;
}
char f_filled [] ( char s [], char c1, char c2 ) {}
s);
for ( int i = 0;
i < l;
i ++ ) {
if ( s [ i ] == c1 ) s [ i ] = c2;
else if ( s [ i ] == c2 ) s [ i ] = c1;
}
return s;
}
char f_filled [] ( char s [], char c1, char c2 ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"IZTSMw j","7288334","010110000","b gJX","734","1","xCaUKdhA","4370992644981","01010","ZNIFGshaWA"};
char param1[] = {'W','6','1','t','4','1','X','5','0','Q'};
char param2[] = {'k','9','1','P','4','1','S','6','1','x'};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} char f_gold [] ( char s [], char c1, char c2 ) { int l = strlen(s); for ( int i = 0; i < l; i ++ ) { if ( s [ i ] == c1 ) s [ i [MASK] = c2; else if ( s [ i ] == c2 ) s [ i ] = c1; } return s; } char f_filled [] ( char s [], char c1, char c2 ) {}s);
for ( int i = 0;
i < l;
i ++ ) {
if ( s [ i ] == c1 ) s [ i ] = c2;
else if ( s [ i ] == c2 ) s [ i ] = c1;
}
return s;
}
char f_filled [] ( char s [], char c1, char c2 ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"IZTSMw j","7288334","010110000","b gJX","734","1","xCaUKdhA","4370992644981","01010","ZNIFGshaWA"};
char param1[] = {'W','6','1','t','4','1','X','5','0','Q'};
char param2[] = {'k','9','1','P','4','1','S','6','1','x'};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ] | [
"a) int",
"b) import",
"c) y)?",
"d) ]",
"e) {"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( double h, double m ) {
if ( h < 0 || m < 0 || h > 12 || m > 60 ) printf ( "Wrong input" );
if ( h == 12 ) h = 0;
if ( m == 60 ) m = 0;
int hour_angle = 0.5 * ( h * 60 + m );
int minute_angle = 6 * m;
int angle = abs ( hour_angle - minute_angle );
angle = min ( 360 - angle, angle );
return angle;
}
int f_filled ( double h, double m ) {}
= 0.5 * ( h * 60 + m );
int minute_angle = 6 * m;
int angle = abs ( hour_angle - minute_angle );
angle = min ( 360 - angle, angle );
return angle;
}
int f_filled ( double h, double m ) {}
int main(void) {
int n_success = 0;
double param0[] = {7322.337365895532,-0.5025472034247969,8735.336068205026,-5478.862697905712,8264.126919165505,-9671.311773842834,9995.328351000411,-5274.574323066984,1310.8711644223736,-2829.678131972794};
double param1[] = {6996.326968156217,-2910.070017192333,1910.3752934680874,-9470.18148108585,7058.937313484608,-3867.070379361206,2145.339179488316,-3583.7503371694124,5214.059687285893,-9371.556600288217};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [MASK] ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( double h, double m ) { if ( h < 0 || m < 0 || h > 12 || m > 60 ) printf ( "Wrong input" ); if ( h == 12 ) h = 0; if ( m == 60 ) m = 0; int hour_angle = 0.5 * ( h * 60 + m ); int minute_angle = 6 * m; int angle = abs ( hour_angle - minute_angle ); angle = min ( 360 - angle, angle ); return angle; } int f_filled ( double h, double m ) {}= 0.5 * ( h * 60 + m );
int minute_angle = 6 * m;
int angle = abs ( hour_angle - minute_angle );
angle = min ( 360 - angle, angle );
return angle;
}
int f_filled ( double h, double m ) {}
int main(void) {
int n_success = 0;
double param0[] = {7322.337365895532,-0.5025472034247969,8735.336068205026,-5478.862697905712,8264.126919165505,-9671.311773842834,9995.328351000411,-5274.574323066984,1310.8711644223736,-2829.678131972794};
double param1[] = {6996.326968156217,-2910.070017192333,1910.3752934680874,-9470.18148108585,7058.937313484608,-3867.070379361206,2145.339179488316,-3583.7503371694124,5214.059687285893,-9371.556600288217};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | [ | [
"a) m",
"b) 3",
"c) [",
"d) int",
"e) n"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int min = arr [ 0 ], min_index;
for ( int i = 0;
i < n;
i ++ ) {
if ( min > arr [ i ] ) {
min = arr [ i ];
min_index = i;
}
}
return min_index;
}
int f_filled ( int arr [ ], int n ) {}
, min_index;
for ( int i = 0;
i < n;
i ++ ) {
if ( min > arr [ i ] ) {
min = arr [ i ];
min_index = i;
}
}
return min_index;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,4,4,9,10,13,14,15,28,28,41,46,47,48,52,55,62,67,69,73,74,79,79,80,87,90,96,99};
int param0_1[] = {44,62,-40,62,98,30,16,76,-4,-2,78,-96,78,-72,94,-66,-38,-80,40,78,-26,28,-40,-32,-64,76,26,-2,12,82,16,-46,10,70,-62,-54,-6,58,32,98};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_3[] = {90,26,71,74,69,47,76,96,42,31,22,17,84,20,8,98,49,87,38,53,28,77,29};
int param0_4[] = {-64,-56,-10,-10,-6,-2,0,22,78,86,98};
int param0_5[] = {0,1,1,1,1,0,1};
int param0_6[] = {2,3,3,5,8,10,11,16,17,26,35,36,38,42,59,73,73,75,75,81,82,82,86,87,88,88,90,95,96,98,98,99};
int param0_7[] = {-96,70,-32,-46,-26,42,-56,36,-72,96,-54,-12,78,30,58,92,56,22,70,10,42,70,0,-76,58,-70,-66,-32,-30,-22,56,10,18,-90,-40,-92,-70,-30,48,10,32,20,-52};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {35,52,21,28,96,44,80,56,10,23,48,52,15,55,43,50,6,33,62,55,39,12,31,74,53,34,41,10,52,75,57,78,3};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {27,38,11,18,9,5,29,42,28,16};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b [MASK] int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int min = arr [ 0 ], min_index; for ( int i = 0; i < n; i ++ ) { if ( min > arr [ i ] ) { min = arr [ i ]; min_index = i; } } return min_index; } int f_filled ( int arr [ ], int n ) {}, min_index;
for ( int i = 0;
i < n;
i ++ ) {
if ( min > arr [ i ] ) {
min = arr [ i ];
min_index = i;
}
}
return min_index;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,4,4,9,10,13,14,15,28,28,41,46,47,48,52,55,62,67,69,73,74,79,79,80,87,90,96,99};
int param0_1[] = {44,62,-40,62,98,30,16,76,-4,-2,78,-96,78,-72,94,-66,-38,-80,40,78,-26,28,-40,-32,-64,76,26,-2,12,82,16,-46,10,70,-62,-54,-6,58,32,98};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_3[] = {90,26,71,74,69,47,76,96,42,31,22,17,84,20,8,98,49,87,38,53,28,77,29};
int param0_4[] = {-64,-56,-10,-10,-6,-2,0,22,78,86,98};
int param0_5[] = {0,1,1,1,1,0,1};
int param0_6[] = {2,3,3,5,8,10,11,16,17,26,35,36,38,42,59,73,73,75,75,81,82,82,86,87,88,88,90,95,96,98,98,99};
int param0_7[] = {-96,70,-32,-46,-26,42,-56,36,-72,96,-54,-12,78,30,58,92,56,22,70,10,42,70,0,-76,58,-70,-66,-32,-30,-22,56,10,18,-90,-40,-92,-70,-30,48,10,32,20,-52};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {35,52,21,28,96,44,80,56,10,23,48,52,15,55,43,50,6,33,62,55,39,12,31,74,53,34,41,10,52,75,57,78,3};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {27,38,11,18,9,5,29,42,28,16};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | );} | [
"a) <limits.h>",
"b) (sizeof",
"c) ];",
"d) namespace",
"e) );}"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int x, int y ) {
while ( y != 0 ) {
int carry = x & y;
x = x ^ y;
y = carry << 1;
}
return x;
}
int f_filled ( int x, int y ) {}
t (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int x, int y ) {
while ( y != 0 ) {
int carry = x & y;
x = x ^ y;
y = carry << 1;
}
return x;
}
int f_filled ( int x, int y ) {}
int main(void) {
int n_success = 0;
int param0[] = {56,17,73,75,27,61,65,22,61,97};
int param1[] = {60,44,96,3,54,1,63,19,9,23};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int x, int y ) { while ( y != 0 ) { int carry = x & y; x = x ^ [MASK] y = carry << 1; } return x; } int f_filled ( int x, int y ) {}t (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int x, int y ) {
while ( y != 0 ) {
int carry = x & y;
x = x ^ y;
y = carry << 1;
}
return x;
}
int f_filled ( int x, int y ) {}
int main(void) {
int n_success = 0;
int param0[] = {56,17,73,75,27,61,65,22,61,97};
int param1[] = {60,44,96,3,54,1,63,19,9,23};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | y; | [
"a) f_gold",
"b) arr",
"c) String",
"d) int",
"e) y;"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( char str [] ) {
int l = 0;
int h = strlen(str) - 1;
while ( h > l ) if ( str [ l ++ ] != str [ h -- ] ) return false;
return true;
}
bool f_filled ( char str [] ) {}
unc);}
bool f_gold ( char str [] ) {
int l = 0;
int h = strlen(str) - 1;
while ( h > l ) if ( str [ l ++ ] != str [ h -- ] ) return false;
return true;
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"aadaa","2674377254","11","0011000","26382426486138","111010111010","abccba","5191","1110101101","abcdecbe"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( char str [] ) { int l = 0; int h = strlen(str) - 1; while ( h > l ) if ( str [ l ++ ] != str [ h -- ] ) return [MASK] return true; } bool f_filled ( char str [] ) {}unc);}
bool f_gold ( char str [] ) {
int l = 0;
int h = strlen(str) - 1;
while ( h > l ) if ( str [ l ++ ] != str [ h -- ] ) return false;
return true;
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"aadaa","2674377254","11","0011000","26382426486138","111010111010","abccba","5191","1110101101","abcdecbe"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | false; | [
"a) n",
"b) Math",
"c) =",
"d) false;",
"e) ."
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( n * n ) + ( n * n * n );
}
int f_filled ( int n ) {}
(sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( n * n ) + ( n * n * n );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {90,95,22,29,62,40,52,21,33,11};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void [MASK] b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { return ( n * n ) + ( n * n * n ); } int f_filled ( int n ) {} (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( n * n ) + ( n * n * n );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {90,95,22,29,62,40,52,21,33,11};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | * | [
"a) pow",
"b) <string>",
"c) (",
"d) f_gold",
"e) *"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( char str1 [], char str2 [], int k ) {
if ( ( strlen(str1) + strlen(str2) ) < k ) return true;
int commonLength = 0;
for ( int i = 0;
i < min ( strlen(str1), strlen(str2) );
i ++ ) {
if ( str1 [ i ] == str2 [ i ] ) commonLength ++;
else break;
}
if ( ( k - strlen(str1) - strlen(str2) + 2 * commonLength ) % 2 == 0 ) return true;
return false;
}
bool f_filled ( char str1 [], char str2 [], int k ) {}
commonLength ++;
else break;
}
if ( ( k - strlen(str1) - strlen(str2) + 2 * commonLength ) % 2 == 0 ) return true;
return false;
}
bool f_filled ( char str1 [], char str2 [], int k ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"ZNHGro","382880806774","0","lxHTRFCTSQ","6399914758","01100011100000","WkGqlob","46974006151","1001001","IJQ"};
char param1[][100] = {"jAdbtDUYQu","65565","00100010100","sViXYE","780990121","0100","NpQVdXzEtUZy","74438","1000010","nFOHAeYEAp"};
int param2[] = {3,10,2,89,9,0,6,11,15,42};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} [MASK] f_gold ( char str1 [], char str2 [], int k ) { if ( ( strlen(str1) + strlen(str2) ) < k ) return true; int commonLength = 0; for ( int i = 0; i < min ( strlen(str1), strlen(str2) ); i ++ ) { if ( str1 [ i ] == str2 [ i ] ) commonLength ++; else break; } if ( ( k - strlen(str1) - strlen(str2) + 2 * commonLength ) % 2 == 0 ) return true; return false; } bool f_filled ( char str1 [], char str2 [], int k ) {}commonLength ++;
else break;
}
if ( ( k - strlen(str1) - strlen(str2) + 2 * commonLength ) % 2 == 0 ) return true;
return false;
}
bool f_filled ( char str1 [], char str2 [], int k ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"ZNHGro","382880806774","0","lxHTRFCTSQ","6399914758","01100011100000","WkGqlob","46974006151","1001001","IJQ"};
char param1[][100] = {"jAdbtDUYQu","65565","00100010100","sViXYE","780990121","0100","NpQVdXzEtUZy","74438","1000010","nFOHAeYEAp"};
int param2[] = {3,10,2,89,9,0,6,11,15,42};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | bool | [
"a) a",
"b) a",
"c) bool",
"d) return",
"e) (x"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char s [ ], int n ) {
int dp [ n ] [ n ];
memset ( dp, 0, sizeof ( dp ) );
for ( int i = 0;
i < n - 1;
i ++ ) if ( s [ i ] == '(' && s [ i + 1 ] == ')' ) dp [ i ] [ i + 1 ] = 2;
for ( int l = 2;
l < n;
l ++ ) {
for ( int i = 0, j = l;
j < n;
i ++, j ++ ) {
if ( s [ i ] == '(' && s [ j ] == ')' ) dp [ i ] [ j ] = 2 + dp [ i + 1 ] [ j - 1 ];
for ( int k = i;
k < j;
k ++ ) dp [ i ] [ j ] = max ( dp [ i ] [ j ], dp [ i ] [ k ] + dp [ k + 1 ] [ j ] );
}
}
return dp [ 0 ] [ n - 1 ];
}
int f_filled ( char s [ ], int n ) {}
( int k = i;
k < j;
k ++ ) dp [ i ] [ j ] = max ( dp [ i ] [ j ], dp [ i ] [ k ] + dp [ k + 1 ] [ j ] );
}
}
return dp [ 0 ] [ n - 1 ];
}
int f_filled ( char s [ ], int n ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"()()(()))()","(()(()))","(())()()","(())()))()","((()))(((","kjbcwkjebc","KZPNX","82050","010)()fkhj","ndPKtu"};
int param1[] = {11,8,8,10,9,10,5,5,10,6};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(¶m0[i].front(),param1[i]) == f_gold(¶m0[i].front(),param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char s [ ], int n ) { int dp [ n ] [ n ]; memset ( dp, 0, sizeof ( dp ) ); for ( int i = 0; i < n - [MASK] i ++ ) if ( s [ i ] == '(' && s [ i + 1 ] == ')' ) dp [ i ] [ i + 1 ] = 2; for ( int l = 2; l < n; l ++ ) { for ( int i = 0, j = l; j < n; i ++, j ++ ) { if ( s [ i ] == '(' && s [ j ] == ')' ) dp [ i ] [ j ] = 2 + dp [ i + 1 ] [ j - 1 ]; for ( int k = i; k < j; k ++ ) dp [ i ] [ j ] = max ( dp [ i ] [ j ], dp [ i ] [ k ] + dp [ k + 1 ] [ j ] ); } } return dp [ 0 ] [ n - 1 ]; } int f_filled ( char s [ ], int n ) {}( int k = i;
k < j;
k ++ ) dp [ i ] [ j ] = max ( dp [ i ] [ j ], dp [ i ] [ k ] + dp [ k + 1 ] [ j ] );
}
}
return dp [ 0 ] [ n - 1 ];
}
int f_filled ( char s [ ], int n ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"()()(()))()","(()(()))","(())()()","(())()))()","((()))(((","kjbcwkjebc","KZPNX","82050","010)()fkhj","ndPKtu"};
int param1[] = {11,8,8,10,9,10,5,5,10,6};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(¶m0[i].front(),param1[i]) == f_gold(¶m0[i].front(),param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | 1; | [
"a) {",
"b) 1;",
"c) (",
"d) float",
"e) <math.h>"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int x1, int y1, int x2, int y2 ) {
return ( x1 * ( y2 - y1 ) == y1 * ( x2 - x1 ) );
}
bool f_filled ( int x1, int y1, int x2, int y2 ) {}
{qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int x1, int y1, int x2, int y2 ) {
return ( x1 * ( y2 - y1 ) == y1 * ( x2 - x1 ) );
}
bool f_filled ( int x1, int y1, int x2, int y2 ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,10,0,1,82,78,13,18,42,29};
int param1[] = {28,0,1,1,86,86,46,29,35,17};
int param2[] = {2,20,0,10,19,11,33,95,25,45};
int param3[] = {56,0,17,10,4,6,33,12,36,35};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) [MASK] return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int x1, int y1, int x2, int y2 ) { return ( x1 * ( y2 - y1 ) == y1 * ( x2 - x1 ) ); } bool f_filled ( int x1, int y1, int x2, int y2 ) {} {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int x1, int y1, int x2, int y2 ) {
return ( x1 * ( y2 - y1 ) == y1 * ( x2 - x1 ) );
}
bool f_filled ( int x1, int y1, int x2, int y2 ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,10,0,1,82,78,13,18,42,29};
int param1[] = {28,0,1,1,86,86,46,29,35,17};
int param2[] = {2,20,0,10,19,11,33,95,25,45};
int param3[] = {56,0,17,10,4,6,33,12,36,35};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | { | [
"a) )",
"b) (",
"c) )",
"d) range",
"e) {"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( n * ( 2 * n - 1 ) * ( 2 * n + 1 ) ) / 3;
}
int f_filled ( int n ) {}
sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( n * ( 2 * n - 1 ) * ( 2 * n + 1 ) ) / 3;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {84,74,91,34,36,28,70,7,24,47};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include [MASK] #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { return ( n * ( 2 * n - 1 ) * ( 2 * n + 1 ) ) / 3; } int f_filled ( int n ) {} sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( n * ( 2 * n - 1 ) * ( 2 * n + 1 ) ) / 3;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {84,74,91,34,36,28,70,7,24,47};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | <math.h> | [
"a) <math.h>",
"b) (arr)[0]));}",
"c) x",
"d) =",
"e) 1"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n, int a, int b, int c ) {
int dp [ n + 1 ];
memset ( dp, - 1, sizeof ( dp ) );
dp [ 0 ] = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( dp [ i ] != - 1 ) {
if ( i + a <= n ) dp [ i + a ] = max ( dp [ i ] + 1, dp [ i + a ] );
if ( i + b <= n ) dp [ i + b ] = max ( dp [ i ] + 1, dp [ i + b ] );
if ( i + c <= n ) dp [ i + c ] = max ( dp [ i ] + 1, dp [ i + c ] );
}
}
return dp [ n ];
}
int f_filled ( int n, int a, int b, int c ) {}
b ] = max ( dp [ i ] + 1, dp [ i + b ] );
if ( i + c <= n ) dp [ i + c ] = max ( dp [ i ] + 1, dp [ i + c ] );
}
}
return dp [ n ];
}
int f_filled ( int n, int a, int b, int c ) {}
int main(void) {
int n_success = 0;
int param0[] = {23,62,32,82,94,44,4,53,9,23};
int param1[] = {16,76,46,48,99,21,57,23,55,15};
int param2[] = {23,81,1,72,62,46,2,80,26,73};
int param3[] = {18,97,78,58,38,60,77,5,85,42};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n, int a, int b, int c ) { int dp [ n + 1 ]; memset ( dp, - 1, sizeof ( dp ) ); dp [ 0 ] = 0; for ( int i = 0; i < n; i ++ ) { if ( dp [ i ] != - 1 ) { if ( i + a <= n ) dp [ i + a ] = max ( dp [ i ] + 1, dp [ i + a ] ); [MASK] ( i + b <= n ) dp [ i + b ] = max ( dp [ i ] + 1, dp [ i + b ] ); if ( i + c <= n ) dp [ i + c ] = max ( dp [ i ] + 1, dp [ i + c ] ); } } return dp [ n ]; } int f_filled ( int n, int a, int b, int c ) {} b ] = max ( dp [ i ] + 1, dp [ i + b ] );
if ( i + c <= n ) dp [ i + c ] = max ( dp [ i ] + 1, dp [ i + c ] );
}
}
return dp [ n ];
}
int f_filled ( int n, int a, int b, int c ) {}
int main(void) {
int n_success = 0;
int param0[] = {23,62,32,82,94,44,4,53,9,23};
int param1[] = {16,76,46,48,99,21,57,23,55,15};
int param2[] = {23,81,1,72,62,46,2,80,26,73};
int param3[] = {18,97,78,58,38,60,77,5,85,42};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | if | [
"a) j",
"b) if",
"c) return",
"d) str2",
"e) /"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int arr [ ], int n ) {
int temp [ n ];
for ( int i = 0;
i < n;
i ++ ) temp [ i ] = arr [ i ];
sort ( temp, temp + n );
int front;
for ( front = 0;
front < n;
front ++ ) if ( temp [ front ] != arr [ front ] ) break;
int back;
for ( back = n - 1;
back >= 0;
back -- ) if ( temp [ back ] != arr [ back ] ) break;
if ( front >= back ) return true;
do {
front ++;
if ( arr [ front - 1 ] < arr [ front ] ) return false;
}
while ( front != back );
return true;
}
bool f_filled ( int arr [ ], int n ) {}
ront >= back ) return true;
do {
front ++;
if ( arr [ front - 1 ] < arr [ front ] ) return false;
}
while ( front != back );
return true;
}
bool f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {5,9,9,16,17,22,32,40,45,53,57,58,66,69,76,80,91,93,94};
int param0_1[] = {52,-76,-18,86,56};
int param0_2[] = {0,0,1};
int param0_3[] = {66,44,98,44};
int param0_4[] = {-96,-62,-56,-46,-44,-38,-38,-26,-22,-22,-16,-12,-6,12,22,34,36,44,44,68,70,74,94};
int param0_5[] = {1,1,0,0,1,1,1,1,0,1,1,1,0,0,1,1,1,0,0,1,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,0,0,1,1};
int param0_6[] = {5,9,11,12,13,16,19,23,23,23,25,27,27,28,31,36,40,44,48,59,60,63,66,66,67,67,69,69,70,71,73,76,76,79,86,86,92,92,93,93};
int param0_7[] = {6,82,-88,-46,-60,70,-54,-96,-94,46,-52,48,-26,-50,-92,-92,6,-6,42,0,-66,-96,66,6,-68,-30,-54,76,60,30,72,-66,-12,-74};
int param0_8[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {62,54,36,35,36,91,45,87,74,49,15,15,73,77,63,70,74,65,11,18};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {10,3,1,2,14,27,34,28,13,16};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a [MASK] *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int arr [ ], int n ) { int temp [ n ]; for ( int i = 0; i < n; i ++ ) temp [ i ] = arr [ i ]; sort ( temp, temp + n ); int front; for ( front = 0; front < n; front ++ ) if ( temp [ front ] != arr [ front ] ) break; int back; for ( back = n - 1; back >= 0; back -- ) if ( temp [ back ] != arr [ back ] ) break; if ( front >= back ) return true; do { front ++; if ( arr [ front - 1 ] < arr [ front ] ) return false; } while ( front != back ); return true; } bool f_filled ( int arr [ ], int n ) {}ront >= back ) return true;
do {
front ++;
if ( arr [ front - 1 ] < arr [ front ] ) return false;
}
while ( front != back );
return true;
}
bool f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {5,9,9,16,17,22,32,40,45,53,57,58,66,69,76,80,91,93,94};
int param0_1[] = {52,-76,-18,86,56};
int param0_2[] = {0,0,1};
int param0_3[] = {66,44,98,44};
int param0_4[] = {-96,-62,-56,-46,-44,-38,-38,-26,-22,-22,-16,-12,-6,12,22,34,36,44,44,68,70,74,94};
int param0_5[] = {1,1,0,0,1,1,1,1,0,1,1,1,0,0,1,1,1,0,0,1,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,0,0,1,1};
int param0_6[] = {5,9,11,12,13,16,19,23,23,23,25,27,27,28,31,36,40,44,48,59,60,63,66,66,67,67,69,69,70,71,73,76,76,79,86,86,92,92,93,93};
int param0_7[] = {6,82,-88,-46,-60,70,-54,-96,-94,46,-52,48,-26,-50,-92,-92,6,-6,42,0,-66,-96,66,6,-68,-30,-54,76,60,30,72,-66,-12,-74};
int param0_8[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {62,54,36,35,36,91,45,87,74,49,15,15,73,77,63,70,74,65,11,18};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {10,3,1,2,14,27,34,28,13,16};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | - | [
"a) *",
"b) f_gold",
"c) ==",
"d) -",
"e) f_gold"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
unordered_set < int > S;
for ( int i = 0;
i < n;
i ++ ) S . insert ( arr [ i ] );
int ans = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( S . find ( arr [ i ] - 1 ) == S . end ( ) ) {
int j = arr [ i ];
while ( S . find ( j ) != S . end ( ) ) j ++;
ans = max ( ans, j - arr [ i ] );
}
}
return ans;
}
int f_filled ( int arr [ ], int n ) {}
. end ( ) ) {
int j = arr [ i ];
while ( S . find ( j ) != S . end ( ) ) j ++;
ans = max ( ans, j - arr [ i ] );
}
}
return ans;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,5,9,24,28,31,49,54,67,85,86,94,97,97};
int param0_1[] = {-34,16,-80,-10,80,2,50,-74,-76,36,-84,-24,74,-54,-22,46,80,58,-8,70,24,-88,52,62,30,42,48,16,78,-82,64,-36,84,-72};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {49,61,68,4,90,89,71,74,45,61,35,41,59};
int param0_4[] = {-42,-8,28,56,80,96};
int param0_5[] = {1,0,1,0,0,0,0,1,1,0,1,1,0,1,0,1,1,1,0,0,0,0,1,1,1,1,0,1,0,0,0,1,1,1,1};
int param0_6[] = {3,4,6,6,13,27,27,29,32,36,46,50,52,65,69,70,71,83,87,91};
int param0_7[] = {64,-76,28,6,56,18,32,-50,-20,18,-26,-90,32,50,-18,98,84,40,50,88,-70,-6,-24,-44,-96,-58,48,-78,-14};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {50,48,61,87,7,78,93,44,16,88,98,15,73,93,43,46,42,34,1,35,79,35,84,60,18,79,17,4,78,1,20,64};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {11,29,13,11,4,17,10,15,15,25};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { unordered_set < int > S; for ( int i = 0; i < [MASK] i ++ ) S . insert ( arr [ i ] ); int ans = 0; for ( int i = 0; i < n; i ++ ) { if ( S . find ( arr [ i ] - 1 ) == S . end ( ) ) { int j = arr [ i ]; while ( S . find ( j ) != S . end ( ) ) j ++; ans = max ( ans, j - arr [ i ] ); } } return ans; } int f_filled ( int arr [ ], int n ) {}. end ( ) ) {
int j = arr [ i ];
while ( S . find ( j ) != S . end ( ) ) j ++;
ans = max ( ans, j - arr [ i ] );
}
}
return ans;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,5,9,24,28,31,49,54,67,85,86,94,97,97};
int param0_1[] = {-34,16,-80,-10,80,2,50,-74,-76,36,-84,-24,74,-54,-22,46,80,58,-8,70,24,-88,52,62,30,42,48,16,78,-82,64,-36,84,-72};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {49,61,68,4,90,89,71,74,45,61,35,41,59};
int param0_4[] = {-42,-8,28,56,80,96};
int param0_5[] = {1,0,1,0,0,0,0,1,1,0,1,1,0,1,0,1,1,1,0,0,0,0,1,1,1,1,0,1,0,0,0,1,1,1,1};
int param0_6[] = {3,4,6,6,13,27,27,29,32,36,46,50,52,65,69,70,71,83,87,91};
int param0_7[] = {64,-76,28,6,56,18,32,-50,-20,18,-26,-90,32,50,-18,98,84,40,50,88,-70,-6,-24,-44,-96,-58,48,-78,-14};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {50,48,61,87,7,78,93,44,16,88,98,15,73,93,43,46,42,34,1,35,79,35,84,60,18,79,17,4,78,1,20,64};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {11,29,13,11,4,17,10,15,15,25};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | n; | [
"a) n;",
"b) A",
"c) (",
"d) 2",
"e) <math.h>"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int input, int unlock_code ) {
int rotation = 0;
int input_digit, code_digit;
while ( input || unlock_code ) {
input_digit = input % 10;
code_digit = unlock_code % 10;
rotation += min ( abs ( input_digit - code_digit ), 10 - abs ( input_digit - code_digit ) );
input /= 10;
unlock_code /= 10;
}
return rotation;
}
int f_filled ( int input, int unlock_code ) {}
+= min ( abs ( input_digit - code_digit ), 10 - abs ( input_digit - code_digit ) );
input /= 10;
unlock_code /= 10;
}
return rotation;
}
int f_filled ( int input, int unlock_code ) {}
int main(void) {
int n_success = 0;
int param0[] = {71,90,28,41,32,39,33,89,50,92};
int param1[] = {46,65,84,23,58,82,58,32,51,77};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int input, int [MASK] ) { int rotation = 0; int input_digit, code_digit; while ( input || unlock_code ) { input_digit = input % 10; code_digit = unlock_code % 10; rotation += min ( abs ( input_digit - code_digit ), 10 - abs ( input_digit - code_digit ) ); input /= 10; unlock_code /= 10; } return rotation; } int f_filled ( int input, int unlock_code ) {}+= min ( abs ( input_digit - code_digit ), 10 - abs ( input_digit - code_digit ) );
input /= 10;
unlock_code /= 10;
}
return rotation;
}
int f_filled ( int input, int unlock_code ) {}
int main(void) {
int n_success = 0;
int param0[] = {71,90,28,41,32,39,33,89,50,92};
int param1[] = {46,65,84,23,58,82,58,32,51,77};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | unlock_code | [
"a) res",
"b) ]",
"c) ;",
"d) <cstdlib>",
"e) unlock_code"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( long n ) {
return pow ( n, 2 );
}
int f_filled ( long n ) {}
turn ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( long n ) {
return pow ( n, 2 );
}
int f_filled ( long n ) {}
int main(void) {
int n_success = 0;
long param0[] = {42,40,67,73,18,16,74,33,92,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; [MASK] int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( long n ) { return pow ( n, 2 ); } int f_filled ( long n ) {}turn ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( long n ) {
return pow ( n, 2 );
}
int f_filled ( long n ) {}
int main(void) {
int n_success = 0;
long param0[] = {42,40,67,73,18,16,74,33,92,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | } | [
"a) *",
"b) 2",
"c) [",
"d) }",
"e) )"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int n ) {
int count = 0;
for ( int i = 0;
i < n;
i ++ ) {
for ( int j = i + 1;
j < n;
j ++ ) if ( ( a [ i ] & a [ j ] ) == 0 ) count += 2;
}
return count;
}
int f_filled ( int a [ ], int n ) {}
= 0;
for ( int i = 0;
i < n;
i ++ ) {
for ( int j = i + 1;
j < n;
j ++ ) if ( ( a [ i ] & a [ j ] ) == 0 ) count += 2;
}
return count;
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {17,20,32,35,35,36,43,47,59,59,68,69,70,70,75,82,88,94,96,99};
int param0_1[] = {-78,-40,58,-36,34,-12,-38,48,-66,16,50,-26,-22,46,-70,-68,-44,-52,-78,-50};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {49,57,17,37,56,61,10,3,33,33,70,35,50,85,48,65,83,21,96,19,66,43,69,17,60,87,82,3,83,44,63,19,55,58,77,76,50,96};
int param0_4[] = {-94,-88,-86,-80,-80,-72,-64,-60,-58,-58,-58,-50,-44,-32,-8,-8,0,6,8,10,14,14,18,28,34,34,46,54,56,56,56,64,66,66,70,82,84,88,96};
int param0_5[] = {1,1,1,0,1,0,1,1,0,0,1,0,1,0,1,1,0};
int param0_6[] = {1,3,10,11,13,14,15,17,20,25,26,26,27,29,32,36,36,36,42,46,47,49,51,54,54,55,60,66,67,68,68,68,72,77,78,79,83,84,92,98};
int param0_7[] = {-76,-72,16,38,-60,44,-2,-76,-76,-56,40,36,50,-50,-32,48,-96,80,84,60,84,38,-54,-42,48,30,66,-62,-52,-94,64,-16,54,98};
int param0_8[] = {0,0,1,1,1,1};
int param0_9[] = {63,82,22,84,11,62,18,43,57,25,4,27,62,46,55,16,1,9,10,73,36,80,95,87,47,64,27,25,70};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {17,11,23,37,33,13,32,28,5,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return [MASK] < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a [ ], int n ) { int count = 0; for ( int i = 0; i < n; i ++ ) { for ( int j = i + 1; j < n; j ++ ) if ( ( a [ i ] & a [ j ] ) == 0 ) count += 2; } return count; } int f_filled ( int a [ ], int n ) {}= 0;
for ( int i = 0;
i < n;
i ++ ) {
for ( int j = i + 1;
j < n;
j ++ ) if ( ( a [ i ] & a [ j ] ) == 0 ) count += 2;
}
return count;
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {17,20,32,35,35,36,43,47,59,59,68,69,70,70,75,82,88,94,96,99};
int param0_1[] = {-78,-40,58,-36,34,-12,-38,48,-66,16,50,-26,-22,46,-70,-68,-44,-52,-78,-50};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {49,57,17,37,56,61,10,3,33,33,70,35,50,85,48,65,83,21,96,19,66,43,69,17,60,87,82,3,83,44,63,19,55,58,77,76,50,96};
int param0_4[] = {-94,-88,-86,-80,-80,-72,-64,-60,-58,-58,-58,-50,-44,-32,-8,-8,0,6,8,10,14,14,18,28,34,34,46,54,56,56,56,64,66,66,70,82,84,88,96};
int param0_5[] = {1,1,1,0,1,0,1,1,0,0,1,0,1,0,1,1,0};
int param0_6[] = {1,3,10,11,13,14,15,17,20,25,26,26,27,29,32,36,36,36,42,46,47,49,51,54,54,55,60,66,67,68,68,68,72,77,78,79,83,84,92,98};
int param0_7[] = {-76,-72,16,38,-60,44,-2,-76,-76,-56,40,36,50,-50,-32,48,-96,80,84,60,84,38,-54,-42,48,30,66,-62,-52,-94,64,-16,54,98};
int param0_8[] = {0,0,1,1,1,1};
int param0_9[] = {63,82,22,84,11,62,18,43,57,25,4,27,62,46,55,16,1,9,10,73,36,80,95,87,47,64,27,25,70};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {17,11,23,37,33,13,32,28,5,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | (x | [
"a) }",
"b) (x",
"c) for",
"d) 2",
"e) ("
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
long long int f_gold ( int A [ ], int B [ ], int m, int n ) {
long long int dp [ n + 1 ] [ m + 1 ];
memset ( dp, 0, sizeof ( dp ) );
for ( int i = 1;
i <= n;
i ++ ) for ( int j = i;
j <= m;
j ++ ) dp [ i ] [ j ] = max ( ( dp [ i - 1 ] [ j - 1 ] + ( A [ j - 1 ] * B [ i - 1 ] ) ), dp [ i ] [ j - 1 ] );
return dp [ n ] [ m ];
}
long long int f_filled ( int A [ ], int B [ ], int m, int n ) {}
p [ i ] [ j ] = max ( ( dp [ i - 1 ] [ j - 1 ] + ( A [ j - 1 ] * B [ i - 1 ] ) ), dp [ i ] [ j - 1 ] );
return dp [ n ] [ m ];
}
long long int f_filled ( int A [ ], int B [ ], int m, int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,9,22,68};
int param0_1[] = {24,40,98,58,-24,24,76,48,-92,-16,-46,-48,-70,88,66,2,44,36,34,34,46,90,-80,-24,-58,68,72,-20,-62,-40};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {32,15,41,41,4,42,22,33,33,11,68,5,41,80,39,15,36,75,41,11,25,40,50,19,39,12,75,28,52,20,63,5,27,53,19,62,98,72,10,90,74,93,52,81,91,65,90,93};
int param0_4[] = {-94,-76,-68,-50,-28,-20,18,24,30,54,74,84,98};
int param0_5[] = {1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,0,1,1,0,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,1,1,1,0,1,0};
int param0_6[] = {14,27,43,49};
int param0_7[] = {78,-26,-12,38,-90};
int param0_8[] = {0,1,1,1};
int param0_9[] = {12,69,57,7,52,14,15,83,67,57,15,86,81,43,1,64,45,68,30,23,14,70,13,51,23,33,98,68,24,43,12,82,46};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1_0[] = {14,22,54,58};
int param1_1[] = {30,-88,6,-26,-76,14,-80,-30,-58,76,40,-28,-54,38,-60,-60,88,-80,-22,90,50,-48,68,-26,26,-2,68,-16,88,-72};
int param1_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_3[] = {80,18,9,29,62,89,4,40,47,15,35,82,22,97,63,54,7,58,64,73,54,79,21,21,20,19,56,42,6,97,7,34,55,35,57,86,73,88,20,29,48,52,8,77,2,12,6,47};
int param1_4[] = {-88,-80,-78,-68,-44,-38,42,50,62,68,70,80,92};
int param1_5[] = {1,0,0,1,1,1,1,1,1,0,0,1,1,0,1,1,0,0,1,0,1,1,0,1,0,1,1,0,1,0,0,1,0,0,1,0,1,0,1,0,1};
int param1_6[] = {51,59,76,83};
int param1_7[] = {14,50,-6,-38,80};
int param1_8[] = {0,0,0,1};
int param1_9[] = {12,48,57,40,47,36,22,50,68,98,77,78,39,55,87,75,65,27,33,27,70,34,67,71,84,33,7,61,3,9,67,92,60};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2[] = {3,22,22,30,11,21,2,3,3,17};
int param3[] = {2,22,19,25,8,33,2,2,2,32};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} long long int f_gold ( int A [ ], int B [ ], int m, int n ) { long long int dp [ n + 1 ] [ m + 1 ]; memset ( dp, 0, sizeof ( dp ) ); for ( int i = 1; i <= n; i ++ ) for ( int j = i; j <= m; j ++ ) dp [ i ] [ j ] = max ( ( dp [ i - 1 ] [ j - 1 ] + ( A [ j - 1 ] * B [ i - 1 ] ) ), dp [ i ] [ j - 1 ] ); return dp [ n [MASK] [ m ]; } long long int f_filled ( int A [ ], int B [ ], int m, int n ) {}p [ i ] [ j ] = max ( ( dp [ i - 1 ] [ j - 1 ] + ( A [ j - 1 ] * B [ i - 1 ] ) ), dp [ i ] [ j - 1 ] );
return dp [ n ] [ m ];
}
long long int f_filled ( int A [ ], int B [ ], int m, int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,9,22,68};
int param0_1[] = {24,40,98,58,-24,24,76,48,-92,-16,-46,-48,-70,88,66,2,44,36,34,34,46,90,-80,-24,-58,68,72,-20,-62,-40};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {32,15,41,41,4,42,22,33,33,11,68,5,41,80,39,15,36,75,41,11,25,40,50,19,39,12,75,28,52,20,63,5,27,53,19,62,98,72,10,90,74,93,52,81,91,65,90,93};
int param0_4[] = {-94,-76,-68,-50,-28,-20,18,24,30,54,74,84,98};
int param0_5[] = {1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,0,1,1,0,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,1,1,1,0,1,0};
int param0_6[] = {14,27,43,49};
int param0_7[] = {78,-26,-12,38,-90};
int param0_8[] = {0,1,1,1};
int param0_9[] = {12,69,57,7,52,14,15,83,67,57,15,86,81,43,1,64,45,68,30,23,14,70,13,51,23,33,98,68,24,43,12,82,46};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1_0[] = {14,22,54,58};
int param1_1[] = {30,-88,6,-26,-76,14,-80,-30,-58,76,40,-28,-54,38,-60,-60,88,-80,-22,90,50,-48,68,-26,26,-2,68,-16,88,-72};
int param1_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_3[] = {80,18,9,29,62,89,4,40,47,15,35,82,22,97,63,54,7,58,64,73,54,79,21,21,20,19,56,42,6,97,7,34,55,35,57,86,73,88,20,29,48,52,8,77,2,12,6,47};
int param1_4[] = {-88,-80,-78,-68,-44,-38,42,50,62,68,70,80,92};
int param1_5[] = {1,0,0,1,1,1,1,1,1,0,0,1,1,0,1,1,0,0,1,0,1,1,0,1,0,1,1,0,1,0,0,1,0,0,1,0,1,0,1,0,1};
int param1_6[] = {51,59,76,83};
int param1_7[] = {14,50,-6,-38,80};
int param1_8[] = {0,0,0,1};
int param1_9[] = {12,48,57,40,47,36,22,50,68,98,77,78,39,55,87,75,65,27,33,27,70,34,67,71,84,33,7,61,3,9,67,92,60};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2[] = {3,22,22,30,11,21,2,3,3,17};
int param3[] = {2,22,19,25,8,33,2,2,2,32};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ] | [
"a) import",
"b) res",
"c) [",
"d) ]",
"e) ("
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int high = 0;
for ( int i = 0;
i < n;
i ++ ) high = max ( high, arr [ i ] );
int divisors [ high + 1 ] = {
0 };
for ( int i = 0;
i < n;
i ++ ) {
for ( int j = 1;
j <= sqrt ( arr [ i ] );
j ++ ) {
if ( arr [ i ] % j == 0 ) {
divisors [ j ] ++;
if ( j != arr [ i ] / j ) divisors [ arr [ i ] / j ] ++;
}
}
}
for ( int i = high;
i >= 1;
i -- ) if ( divisors [ i ] > 1 ) return i;
}
int f_filled ( int arr [ ], int n ) {}
[ i ] / j ) divisors [ arr [ i ] / j ] ++;
}
}
}
for ( int i = high;
i >= 1;
i -- ) if ( divisors [ i ] > 1 ) return i;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,3,8,10,12,13,14,16,16,19,20,21,25,29,33,35,35,35,35,36,38,41,42,45,45,45,46,48,51,52,53,55,56,57,58,62,69,73,73,76,76,80,89,91,92,93,93,96};
int param0_1[] = {12,52,-66,50,50,-78,-14,26,56,74,8,-58,58,-66,-58,-12,80};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {23,98,12,45,83,85,30,92,26,12,38,20,86,52,71,20,56,78,10,34,86,55,99,84,26,2,1,89,60,26,16,37,98,11,73,42,36,60,28};
int param0_4[] = {-98,-84,-80,-72,-66,-64,-52,-36,-28,-18,-12,-12,-4,8,12,40,42,56,68,70,90,94};
int param0_5[] = {1,0,0,1,1,1,0,0,0,1,0,0,1,1,0,1,0,1,1,0,0,1,0,0,1,0,1};
int param0_6[] = {3,5,6,7,8,9,11,13,18,20,24,25,26,27,36,41,41,45,48,48,49,65,69,70,85,90,99,99};
int param0_7[] = {80,-26,-38,-40,22,-28,0,-36,70,-32,38,58,76,-42,38,92,68,-70,36,-62,24,-84,42,4,0,8,-36,98,-84,82,-70,-12,6,-82,-20,-68,48,-12,42,18,58,-14,94,84};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {36,60,45,76,43,71,10,18,52,52,53,73,48,95,13,50,97,30,73,13,18,34,51};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {45,11,26,28,17,14,20,39,26,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], [MASK] n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int high = 0; for ( int i = 0; i < n; i ++ ) high = max ( high, arr [ i ] ); int divisors [ high + 1 ] = { 0 }; for ( int i = 0; i < n; i ++ ) { for ( int j = 1; j <= sqrt ( arr [ i ] ); j ++ ) { if ( arr [ i ] % j == 0 ) { divisors [ j ] ++; if ( j != arr [ i ] / j ) divisors [ arr [ i ] / j ] ++; } } } for ( int i = high; i >= 1; i -- ) if ( divisors [ i ] > 1 ) return i; } int f_filled ( int arr [ ], int n ) {} [ i ] / j ) divisors [ arr [ i ] / j ] ++;
}
}
}
for ( int i = high;
i >= 1;
i -- ) if ( divisors [ i ] > 1 ) return i;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,3,8,10,12,13,14,16,16,19,20,21,25,29,33,35,35,35,35,36,38,41,42,45,45,45,46,48,51,52,53,55,56,57,58,62,69,73,73,76,76,80,89,91,92,93,93,96};
int param0_1[] = {12,52,-66,50,50,-78,-14,26,56,74,8,-58,58,-66,-58,-12,80};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {23,98,12,45,83,85,30,92,26,12,38,20,86,52,71,20,56,78,10,34,86,55,99,84,26,2,1,89,60,26,16,37,98,11,73,42,36,60,28};
int param0_4[] = {-98,-84,-80,-72,-66,-64,-52,-36,-28,-18,-12,-12,-4,8,12,40,42,56,68,70,90,94};
int param0_5[] = {1,0,0,1,1,1,0,0,0,1,0,0,1,1,0,1,0,1,1,0,0,1,0,0,1,0,1};
int param0_6[] = {3,5,6,7,8,9,11,13,18,20,24,25,26,27,36,41,41,45,48,48,49,65,69,70,85,90,99,99};
int param0_7[] = {80,-26,-38,-40,22,-28,0,-36,70,-32,38,58,76,-42,38,92,68,-70,36,-62,24,-84,42,4,0,8,-36,98,-84,82,-70,-12,6,-82,-20,-68,48,-12,42,18,58,-14,94,84};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {36,60,45,76,43,71,10,18,52,52,53,73,48,95,13,50,97,30,73,13,18,34,51};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {45,11,26,28,17,14,20,39,26,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | int | [
"a) unsigned",
"b) int",
"c) in",
"d) (",
"e) ]"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n, int x ) {
int curr_sum = 0, min_len = n + 1;
int start = 0, end = 0;
while ( end < n ) {
while ( curr_sum <= x && end < n ) curr_sum += arr [ end ++ ];
while ( curr_sum > x && start < n ) {
if ( end - start < min_len ) min_len = end - start;
curr_sum -= arr [ start ++ ];
}
}
return min_len;
}
int f_filled ( int arr [ ], int n, int x ) {}
_sum > x && start < n ) {
if ( end - start < min_len ) min_len = end - start;
curr_sum -= arr [ start ++ ];
}
}
return min_len;
}
int f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {6,11,11,14,18,19,21,22,22,23,26,27,28,28,29,30,31,34,39,42,42,44,45,49,49,53,57,61,65,66,67,70,71,73,74,74,78,85,88,94,95,97};
int param0_1[] = {-30,-22,-66,-80,18,-64,-28,-46,94,60,-64,2,26,-94,58,56,56,88,50,-78,-12,68,54,-78,42,-30,24,-48,84,12,-88,0,54,-92,-4,42,-60,-72,-32};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param0_3[] = {86,8,23,40,55,93,11,35,33,37,96,91,35,66,37,57,83,99,96,15,18,93};
int param0_4[] = {-92,-68,-48,-48,-42,-26,-22,-18,2,4,8,14,20,22,32,46,52,62,70,96,98};
int param0_5[] = {0,0,0,0,1,0,1,1,0,1,0,0,0};
int param0_6[] = {4,4,11,11,13,15,16,18,19,19,19,23,26,27,34,39,39,40,41,46,47,51,52,52,53,57,58,58,60,64,68,70,72,84,84,85,95,98,99};
int param0_7[] = {12,-22,2,-90,-92,84,-26,-76,-72,50,-36,30,78,-18,-94,-30,22,28,10,32,34,-86,0,-4,40,0,80,50,66,-48,-40,-94,64,58,-14,0,-32,-58,-22,-94,-68,-36,-94,-48,40,78,-74};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {1,33,20,32,76,27,8,95,78,72,25,56};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {37,31,8,16,17,11,31,42,25,9};
int param2[] = {23,29,12,13,14,10,35,26,21,10};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n, int x [MASK] { int curr_sum = 0, min_len = n + 1; int start = 0, end = 0; while ( end < n ) { while ( curr_sum <= x && end < n ) curr_sum += arr [ end ++ ]; while ( curr_sum > x && start < n ) { if ( end - start < min_len ) min_len = end - start; curr_sum -= arr [ start ++ ]; } } return min_len; } int f_filled ( int arr [ ], int n, int x ) {}_sum > x && start < n ) {
if ( end - start < min_len ) min_len = end - start;
curr_sum -= arr [ start ++ ];
}
}
return min_len;
}
int f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {6,11,11,14,18,19,21,22,22,23,26,27,28,28,29,30,31,34,39,42,42,44,45,49,49,53,57,61,65,66,67,70,71,73,74,74,78,85,88,94,95,97};
int param0_1[] = {-30,-22,-66,-80,18,-64,-28,-46,94,60,-64,2,26,-94,58,56,56,88,50,-78,-12,68,54,-78,42,-30,24,-48,84,12,-88,0,54,-92,-4,42,-60,-72,-32};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param0_3[] = {86,8,23,40,55,93,11,35,33,37,96,91,35,66,37,57,83,99,96,15,18,93};
int param0_4[] = {-92,-68,-48,-48,-42,-26,-22,-18,2,4,8,14,20,22,32,46,52,62,70,96,98};
int param0_5[] = {0,0,0,0,1,0,1,1,0,1,0,0,0};
int param0_6[] = {4,4,11,11,13,15,16,18,19,19,19,23,26,27,34,39,39,40,41,46,47,51,52,52,53,57,58,58,60,64,68,70,72,84,84,85,95,98,99};
int param0_7[] = {12,-22,2,-90,-92,84,-26,-76,-72,50,-36,30,78,-18,-94,-30,22,28,10,32,34,-86,0,-4,40,0,80,50,66,-48,-40,-94,64,58,-14,0,-32,-58,-22,-94,-68,-36,-94,-48,40,78,-74};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {1,33,20,32,76,27,8,95,78,72,25,56};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {37,31,8,16,17,11,31,42,25,9};
int param2[] = {23,29,12,13,14,10,35,26,21,10};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ) | [
"a) )",
"b) 2",
"c) +",
"d) +",
"e) j"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int l, int w ) {
return ( 2 * ( l + w ) );
}
int f_filled ( int l, int w ) {}
of (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int l, int w ) {
return ( 2 * ( l + w ) );
}
int f_filled ( int l, int w ) {}
int main(void) {
int n_success = 0;
int param0[] = {58,37,56,22,77,34,74,37,21,75};
int param1[] = {39,49,52,43,12,31,54,52,37,30};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int [MASK] int w ) { return ( 2 * ( l + w ) ); } int f_filled ( int l, int w ) {}of (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int l, int w ) {
return ( 2 * ( l + w ) );
}
int f_filled ( int l, int w ) {}
int main(void) {
int n_success = 0;
int param0[] = {58,37,56,22,77,34,74,37,21,75};
int param1[] = {39,49,52,43,12,31,54,52,37,30};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | l, | [
"a) x",
"b) #include",
"c) l,",
"d) ]",
"e) of"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int n ) {
if ( n == 1 ) return a [ 0 ];
int max_neg = INT_MIN;
int count_neg = 0, count_zero = 0;
int prod = 1;
for ( int i = 0;
i < n;
i ++ ) {
if ( a [ i ] == 0 ) {
count_zero ++;
continue;
}
if ( a [ i ] < 0 ) {
count_neg ++;
max_neg = max ( max_neg, a [ i ] );
}
prod = prod * a [ i ];
}
if ( count_zero == n ) return 0;
if ( count_neg & 1 ) {
if ( count_neg == 1 && count_zero > 0 && count_zero + count_neg == n ) return 0;
prod = prod / max_neg;
}
return prod;
}
int f_filled ( int a [ ], int n ) {}
if ( count_neg & 1 ) {
if ( count_neg == 1 && count_zero > 0 && count_zero + count_neg == n ) return 0;
prod = prod / max_neg;
}
return prod;
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {22,62,97};
int param0_1[] = {-96,30,34,16,82,12,68,6,-2,-78,-74,-52,38,62,20,4,-32,44,-34,12,-44,-66,-94,24,-86,56,-20,-62,90,-16,-2,54,80,-16,-56,-98,20,84,30,-44,-78,66,-62,18};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {9,1,90,53,67,14,42,52,55,52,86,99,43,74,48,71,55,85,87,73,41,55,52};
int param0_4[] = {-92,-78,-74,-72,-70,-66,-46,-44,-42,-34,-32,-30,-10,18,30,34,56,64,66};
int param0_5[] = {0,1,1,1,0,1,0,0,0,1,0,1,0,1,1,1,0,1,1,0,0,0,1,0,0,0,0,0,0,1,0};
int param0_6[] = {1,2,3,18,20,33,38,53,55,56,67,80,83,87,90,97,98};
int param0_7[] = {-78,-14,20,70,-40,-96,78,70,-36,-30,24,-36,86,42,24,86,-52,-34,72,-58,-36,-24,-10,-68,-20,-64,34,42,-2,-8};
int param0_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {1,6,32,4,63,85,48,64,11,29,77,59,1,99,17,17,38,49,78,82,50,87,75,18,75,73,98,17,27,51,4,98,96,6,74,5};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {2,41,43,20,10,16,9,16,11,32};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a [ ], int n ) { if ( n == 1 ) return a [ 0 ]; int max_neg = INT_MIN; int count_neg = 0, count_zero = 0; int prod = 1; for ( int i = 0; i < n; i ++ ) { if ( [MASK] [ i ] == 0 ) { count_zero ++; continue; } if ( a [ i ] < 0 ) { count_neg ++; max_neg = max ( max_neg, a [ i ] ); } prod = prod * a [ i ]; } if ( count_zero == n ) return 0; if ( count_neg & 1 ) { if ( count_neg == 1 && count_zero > 0 && count_zero + count_neg == n ) return 0; prod = prod / max_neg; } return prod; } int f_filled ( int a [ ], int n ) {}
if ( count_neg & 1 ) {
if ( count_neg == 1 && count_zero > 0 && count_zero + count_neg == n ) return 0;
prod = prod / max_neg;
}
return prod;
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {22,62,97};
int param0_1[] = {-96,30,34,16,82,12,68,6,-2,-78,-74,-52,38,62,20,4,-32,44,-34,12,-44,-66,-94,24,-86,56,-20,-62,90,-16,-2,54,80,-16,-56,-98,20,84,30,-44,-78,66,-62,18};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {9,1,90,53,67,14,42,52,55,52,86,99,43,74,48,71,55,85,87,73,41,55,52};
int param0_4[] = {-92,-78,-74,-72,-70,-66,-46,-44,-42,-34,-32,-30,-10,18,30,34,56,64,66};
int param0_5[] = {0,1,1,1,0,1,0,0,0,1,0,1,0,1,1,1,0,1,1,0,0,0,1,0,0,0,0,0,0,1,0};
int param0_6[] = {1,2,3,18,20,33,38,53,55,56,67,80,83,87,90,97,98};
int param0_7[] = {-78,-14,20,70,-40,-96,78,70,-36,-30,24,-36,86,42,24,86,-52,-34,72,-58,-36,-24,-10,-68,-20,-64,34,42,-2,-8};
int param0_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {1,6,32,4,63,85,48,64,11,29,77,59,1,99,17,17,38,49,78,82,50,87,75,18,75,73,98,17,27,51,4,98,96,6,74,5};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {2,41,43,20,10,16,9,16,11,32};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | a | [
"a) int",
"b) a",
"c) (",
"d) *",
"e) -"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char s [] ) {
int n = strlen(s);
int auxArr [ n ] = {
0 };
if ( s [ 0 ] == '1' ) auxArr [ 0 ] = 1;
for ( int i = 1;
i < n;
i ++ ) {
if ( s [ i ] == '1' ) auxArr [ i ] = auxArr [ i - 1 ] + 1;
else auxArr [ i ] = auxArr [ i - 1 ];
}
int count = 0;
for ( int i = n - 1;
i >= 0;
i -- ) if ( s [ i ] == '1' ) count += auxArr [ i ];
return count;
}
int f_filled ( char s [] ) {}
i ] = auxArr [ i - 1 ];
}
int count = 0;
for ( int i = n - 1;
i >= 0;
i -- ) if ( s [ i ] == '1' ) count += auxArr [ i ];
return count;
}
int f_filled ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"OGiOkJF","517376","11","Ze","8763644247018","00111010001","HGwkBKUOVu","652","101000011110","kvdpG "};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char s [] ) { int n = strlen(s); int auxArr [ n ] = { 0 }; if ( s [MASK] 0 ] == '1' ) auxArr [ 0 ] = 1; for ( int i = 1; i < n; i ++ ) { if ( s [ i ] == '1' ) auxArr [ i ] = auxArr [ i - 1 ] + 1; else auxArr [ i ] = auxArr [ i - 1 ]; } int count = 0; for ( int i = n - 1; i >= 0; i -- ) if ( s [ i ] == '1' ) count += auxArr [ i ]; return count; } int f_filled ( char s [] ) {}i ] = auxArr [ i - 1 ];
}
int count = 0;
for ( int i = n - 1;
i >= 0;
i -- ) if ( s [ i ] == '1' ) count += auxArr [ i ];
return count;
}
int f_filled ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"OGiOkJF","517376","11","Ze","8763644247018","00111010001","HGwkBKUOVu","652","101000011110","kvdpG "};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | [ | [
"a) [",
"b) (",
"c) ;",
"d) ]",
"e) ,"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a ) {
return 4 * a;
}
int f_filled ( int a ) {}
[ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a ) {
return 4 * a;
}
int f_filled ( int a ) {}
int main(void) {
int n_success = 0;
int param0[] = {98,9,18,38,84,8,39,6,60,47};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a ) { return [MASK] * a; } int f_filled ( int a ) {} [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a ) {
return 4 * a;
}
int f_filled ( int a ) {}
int main(void) {
int n_success = 0;
int param0[] = {98,9,18,38,84,8,39,6,60,47};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | 4 | [
"a) #include",
"b) return",
"c) a",
"d) arr",
"e) 4"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int notes [ ], int n ) {
int fiveCount = 0;
int tenCount = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( notes [ i ] == 5 ) fiveCount ++;
else if ( notes [ i ] == 10 ) {
if ( fiveCount > 0 ) {
fiveCount --;
tenCount ++;
}
else return 0;
}
else {
if ( fiveCount > 0 && tenCount > 0 ) {
fiveCount --;
tenCount --;
}
else if ( fiveCount >= 3 ) {
fiveCount -= 3;
}
else return 0;
}
}
return 1;
}
int f_filled ( int notes [ ], int n ) {}
fiveCount --;
tenCount --;
}
else if ( fiveCount >= 3 ) {
fiveCount -= 3;
}
else return 0;
}
}
return 1;
}
int f_filled ( int notes [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {20};
int param0_1[] = {5,5,5,20,10};
int param0_2[] = {5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,10,10,10,10,10,10,10,10,10,10,10,10,10};
int param0_3[] = {10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,18};
int param0_4[] = {5,5,20};
int param0_5[] = {10,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5};
int param0_6[] = {5,10,20,5,5,5,5,5,5,5,5,5,5,5,5};
int param0_7[] = {-82,-10,-78,-84,68,62,10,20,-86,-98,92,70,40,-12,-20,-36,8,-70,6,8,44,-24,8,-18,76,-54,-14,-94,-68,-62,-24,-36,-74,92,92,-80,48,56,94};
int param0_8[] = {10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5};
int param0_9[] = {46,46,93,57,82,34,83,80,77,36,80,85,69,28,9,56,49,27,83,25,1,80,99,14,69,82,79,71,74,34};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {4,5,27,12,2,17,7,31,25,20};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int notes [ ], int n ) { int fiveCount = 0; int tenCount = 0; for ( int i = 0; i < n; i ++ ) { if ( notes [ i ] == 5 ) fiveCount ++; else if ( notes [ i ] == 10 ) { if ( fiveCount > 0 [MASK] { fiveCount --; tenCount ++; } else return 0; } else { if ( fiveCount > 0 && tenCount > 0 ) { fiveCount --; tenCount --; } else if ( fiveCount >= 3 ) { fiveCount -= 3; } else return 0; } } return 1; } int f_filled ( int notes [ ], int n ) {}fiveCount --;
tenCount --;
}
else if ( fiveCount >= 3 ) {
fiveCount -= 3;
}
else return 0;
}
}
return 1;
}
int f_filled ( int notes [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {20};
int param0_1[] = {5,5,5,20,10};
int param0_2[] = {5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,10,10,10,10,10,10,10,10,10,10,10,10,10};
int param0_3[] = {10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,18};
int param0_4[] = {5,5,20};
int param0_5[] = {10,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5};
int param0_6[] = {5,10,20,5,5,5,5,5,5,5,5,5,5,5,5};
int param0_7[] = {-82,-10,-78,-84,68,62,10,20,-86,-98,92,70,40,-12,-20,-36,8,-70,6,8,44,-24,8,-18,76,-54,-14,-94,-68,-62,-24,-36,-74,92,92,-80,48,56,94};
int param0_8[] = {10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5};
int param0_9[] = {46,46,93,57,82,34,83,80,77,36,80,85,69,28,9,56,49,27,83,25,1,80,99,14,69,82,79,71,74,34};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {4,5,27,12,2,17,7,31,25,20};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ) | [
"a) ],",
"b) )",
"c) ]",
"d) int",
"e) f_gold"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b ) {
return ( a / 2 ) + ( b / 2 ) + ( ( a % 2 + b % 2 ) / 2 );
}
int f_filled ( int a, int b ) {}
oid sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b ) {
return ( a / 2 ) + ( b / 2 ) + ( ( a % 2 + b % 2 ) / 2 );
}
int f_filled ( int a, int b ) {}
int main(void) {
int n_success = 0;
int param0[] = {9,68,51,31,14,73,51,75,98,83};
int param1[] = {81,79,2,49,10,9,13,67,51,74};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, [MASK] void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a, int b ) { return ( a / 2 ) + ( b / 2 ) + ( ( a % 2 + b % 2 ) / 2 ); } int f_filled ( int a, int b ) {}oid sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b ) {
return ( a / 2 ) + ( b / 2 ) + ( ( a % 2 + b % 2 ) / 2 );
}
int f_filled ( int a, int b ) {}
int main(void) {
int n_success = 0;
int param0[] = {9,68,51,31,14,73,51,75,98,83};
int param1[] = {81,79,2,49,10,9,13,67,51,74};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | const | [
"a) /",
"b) const",
"c) in",
"d) int",
"e) void"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int arr [ ], int N ) {
if ( N < 3 ) return false;
sort ( arr, arr + N );
for ( int i = 0;
i < N - 2;
i ++ ) if ( arr [ i ] + arr [ i + 1 ] > arr [ i + 2 ] ) return true;
}
bool f_filled ( int arr [ ], int N ) {}
f ( N < 3 ) return false;
sort ( arr, arr + N );
for ( int i = 0;
i < N - 2;
i ++ ) if ( arr [ i ] + arr [ i + 1 ] > arr [ i + 2 ] ) return true;
}
bool f_filled ( int arr [ ], int N ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,6,8,10,14,15,16,19,21,26,26,26,28,29,30,33,33,35,36,36,41,44,45,45,45,49,51,54,57,59,61,64,68,70,70,72,73,74,76,78,87,89,89,91,92,93,94,95,97};
int param0_1[] = {50,-58,-44,90,18,-26,-74,-46,96,32,72,46,-90,86,-10,82,-72,86,-64,-96,-12,-14,-36,16,38,56,54,10,74,-86,-64,-56,30,-50,46,4,88,-94,-4,-78,22,-78};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {80,24,41,90,24,95};
int param0_4[] = {-90,-88,-84,-82,-82,-80,-70,-66,-62,-60,-60,-48,-46,-44,-42,-20,-16,-4,18,26,28,32,36,46,60,62,68,72,78,98};
int param0_5[] = {0,0,0,1,0,0,1,1,0,1,0,1,1,0,0,1,1,1,0,0,0,1,1,0,0,1,0,0,0,1,0,1,1,1,0,0};
int param0_6[] = {3,9,14,16,16,26,30,31,32,37,42,42,43,49,51,56,64,69,76,77,77,79,85,88,89,91,94,95};
int param0_7[] = {-60,-90,-30,-42,80,-66,94,60,-68,-74,-50,42,-38,-34,-84,-58,30,98,-52,6,-60,-60};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param0_9[] = {24,80,16,31,5,31,66,1,13,77,88,40,34,15,90,46,8,26,39,52,22,33,3,30,49,51,69,50,39,59};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {25,23,10,4,21,25,19,11,18,23};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include [MASK] #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int arr [ ], int N ) { if ( N < 3 ) return false; sort ( arr, arr + N ); for ( int i = 0; i < N - 2; i ++ ) if ( arr [ i ] + arr [ i + 1 ] > arr [ i + 2 ] ) return true; } bool f_filled ( int arr [ ], int N ) {}f ( N < 3 ) return false;
sort ( arr, arr + N );
for ( int i = 0;
i < N - 2;
i ++ ) if ( arr [ i ] + arr [ i + 1 ] > arr [ i + 2 ] ) return true;
}
bool f_filled ( int arr [ ], int N ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,6,8,10,14,15,16,19,21,26,26,26,28,29,30,33,33,35,36,36,41,44,45,45,45,49,51,54,57,59,61,64,68,70,70,72,73,74,76,78,87,89,89,91,92,93,94,95,97};
int param0_1[] = {50,-58,-44,90,18,-26,-74,-46,96,32,72,46,-90,86,-10,82,-72,86,-64,-96,-12,-14,-36,16,38,56,54,10,74,-86,-64,-56,30,-50,46,4,88,-94,-4,-78,22,-78};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {80,24,41,90,24,95};
int param0_4[] = {-90,-88,-84,-82,-82,-80,-70,-66,-62,-60,-60,-48,-46,-44,-42,-20,-16,-4,18,26,28,32,36,46,60,62,68,72,78,98};
int param0_5[] = {0,0,0,1,0,0,1,1,0,1,0,1,1,0,0,1,1,1,0,0,0,1,1,0,0,1,0,0,0,1,0,1,1,1,0,0};
int param0_6[] = {3,9,14,16,16,26,30,31,32,37,42,42,43,49,51,56,64,69,76,77,77,79,85,88,89,91,94,95};
int param0_7[] = {-60,-90,-30,-42,80,-66,94,60,-68,-74,-50,42,-38,-34,-84,-58,30,98,-52,6,-60,-60};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param0_9[] = {24,80,16,31,5,31,66,1,13,77,88,40,34,15,90,46,8,26,39,52,22,33,3,30,49,51,69,50,39,59};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {25,23,10,4,21,25,19,11,18,23};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | <limits.h> | [
"a) <limits.h>",
"b) int",
"c) cmpfunc);}",
"d) return",
"e) int"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int l = sqrt ( n );
int sq = l * l;
if ( sq == n ) return l * 4;
else {
long long int row = n / l;
long long int perimeter = 2 * ( l + row );
if ( n % l != 0 ) perimeter += 2;
return perimeter;
}
}
int f_filled ( int n ) {}
) return l * 4;
else {
long long int row = n / l;
long long int perimeter = 2 * ( l + row );
if ( n % l != 0 ) perimeter += 2;
return perimeter;
}
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {45,80,54,48,83,68,32,20,68,66};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { [MASK] (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { int l = sqrt ( n ); int sq = l * l; if ( sq == n ) return l * 4; else { long long int row = n / l; long long int perimeter = 2 * ( l + row ); if ( n % l != 0 ) perimeter += 2; return perimeter; } } int f_filled ( int n ) {} ) return l * 4;
else {
long long int row = n / l;
long long int perimeter = 2 * ( l + row );
if ( n % l != 0 ) perimeter += 2;
return perimeter;
}
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {45,80,54,48,83,68,32,20,68,66};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | return | [
"a) a",
"b) cmpfunc);}",
"c) return",
"d) k,",
"e) x"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int n, int k ) {
unordered_map < int, int > m;
for ( int i = 0;
i < n;
i ++ ) m [ a [ i ] ] ++;
int res = INT_MAX;
for ( auto it = m . begin ( );
it != m . end ( );
++ it ) if ( it -> second == k ) res = min ( res, it -> first );
return ( res != INT_MAX ) ? res : - 1;
}
int f_filled ( int a [ ], int n, int k ) {}
it = m . begin ( );
it != m . end ( );
++ it ) if ( it -> second == k ) res = min ( res, it -> first );
return ( res != INT_MAX ) ? res : - 1;
}
int f_filled ( int a [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,5,5,8,11,13,14,15,15,16,18,23,24,26,28,31,33,39,39,39,40,41,44,51,53,55,55,59,59,61,64,65,74,74,76,76,76,77,87,88,88,94,95,96};
int param0_1[] = {-98,-64,-44,20,-46,96,-48,-54,-26,30,-42,94,58,-58,-54,50,6,-34,-44,-50,-66,-14,-96,74,4,-86,56,-46,-94,-24,-80,58,34,24};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {55,78,71,60,41,82,45,66,46,5,92,49,57,16,49,40,77,40,44,47,52,58,33,3,27,37,38,56,3,32,7,17,43,35,79,66,50,63,97,12,16};
int param0_4[] = {-90,-86,-74,-68,-64,-56,-30,-24,-14,-2,0,2,8,16,18,20,24,30,32,36,42,54,62,62,62,62,76,78,90,92,94};
int param0_5[] = {0,1,0,1,1,0,0,1,1,1,1,1,1,1,0,0,0,0,1,0,0,1,1};
int param0_6[] = {4,5,5,5,10,13,17,17,20,20,22,25,28,36,40,42,49,51,57,59,65,66,66,68,72,74,78,81,87,88,94,95};
int param0_7[] = {-12,-20,-78,-10,6,26,-94,-48,22,-2,12,-68,-90,-22,-94,-94,-10,-66,62,-20,74,-90,54,-52,90,50,60,10,56,-32,52,-12,-84,66,-82,34,24,-8,-60,-20,-94,80};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {2,57,53,3,63,29,12,99,21,26,3,35,96,84,48,61};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {27,26,26,32,22,18,28,28,29,10};
int param2[] = {2,2,1,3,2,8,7,3,2,1};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void [MASK] (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a [ ], int n, int k ) { unordered_map < int, int > m; for ( int i = 0; i < n; i ++ ) m [ a [ i ] ] ++; int res = INT_MAX; for ( auto it = m . begin ( ); it != m . end ( ); ++ it ) if ( it -> second == k ) res = min ( res, it -> first ); return ( res != INT_MAX ) ? res : - 1; } int f_filled ( int a [ ], int n, int k ) {} it = m . begin ( );
it != m . end ( );
++ it ) if ( it -> second == k ) res = min ( res, it -> first );
return ( res != INT_MAX ) ? res : - 1;
}
int f_filled ( int a [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,5,5,8,11,13,14,15,15,16,18,23,24,26,28,31,33,39,39,39,40,41,44,51,53,55,55,59,59,61,64,65,74,74,76,76,76,77,87,88,88,94,95,96};
int param0_1[] = {-98,-64,-44,20,-46,96,-48,-54,-26,30,-42,94,58,-58,-54,50,6,-34,-44,-50,-66,-14,-96,74,4,-86,56,-46,-94,-24,-80,58,34,24};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {55,78,71,60,41,82,45,66,46,5,92,49,57,16,49,40,77,40,44,47,52,58,33,3,27,37,38,56,3,32,7,17,43,35,79,66,50,63,97,12,16};
int param0_4[] = {-90,-86,-74,-68,-64,-56,-30,-24,-14,-2,0,2,8,16,18,20,24,30,32,36,42,54,62,62,62,62,76,78,90,92,94};
int param0_5[] = {0,1,0,1,1,0,0,1,1,1,1,1,1,1,0,0,0,0,1,0,0,1,1};
int param0_6[] = {4,5,5,5,10,13,17,17,20,20,22,25,28,36,40,42,49,51,57,59,65,66,66,68,72,74,78,81,87,88,94,95};
int param0_7[] = {-12,-20,-78,-10,6,26,-94,-48,22,-2,12,-68,-90,-22,-94,-94,-10,-66,62,-20,74,-90,54,-52,90,50,60,10,56,-32,52,-12,-84,66,-82,34,24,-8,-60,-20,-94,80};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {2,57,53,3,63,29,12,99,21,26,3,35,96,84,48,61};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {27,26,26,32,22,18,28,28,29,10};
int param2[] = {2,2,1,3,2,8,7,3,2,1};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | sort | [
"a) s1",
"b) java.util.",
"c) sort",
"d) (",
"e) 1;"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int ar [ ], int n ) {
int res = 0;
sort ( ar, ar + n );
for ( int i = 0;
i < n;
i ++ ) {
int count = 1;
for (;
i < n - 1;
i ++ ) {
if ( ar [ i ] == ar [ i + 1 ] ) count ++;
else break;
}
res = max ( res, count );
}
return res;
}
int f_filled ( int ar [ ], int n ) {}
for (;
i < n - 1;
i ++ ) {
if ( ar [ i ] == ar [ i + 1 ] ) count ++;
else break;
}
res = max ( res, count );
}
return res;
}
int f_filled ( int ar [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,5,8,16,21,21,22,23,26,26,27,27,29,31,33,36,37,37,38,42,45,47,50,57,58,60,60,62,63,66,66,76,84,84,88,96,99};
int param0_1[] = {-30,-60,34,4,86,80,-96,-94,52,46,8,82,-94,-96,78,82,-22,-36,78,50,-46,-36,80,24,-14,94,-46,-38,82,4,-24,2,4,-82,-82,-18,-62,12,8,92,70,-10};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {38,47,84,49,48,62,48,41,38,48,92,16,99};
int param0_4[] = {-88,-64,-40,-38,-38,-16,16,20,28,40,56,58,60,68,74,92};
int param0_5[] = {1,1,0,1,0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,1,1,1,1};
int param0_6[] = {14,24,82,87,95};
int param0_7[] = {-34,62,40,-84,52,-76,2,-58,94,22,2,-18,-88,62,-14,46,50,-58,-80,68,-64,90,-58,12,76,-40,40,-46,8,-80,4,-90,14,-10,64,-68};
int param0_8[] = {0,1,1,1};
int param0_9[] = {43,41,90,5,6,17,68,68,86,89};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {25,35,34,6,12,29,3,34,3,7};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * [MASK] {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int ar [ ], int n ) { int res = 0; sort ( ar, ar + n ); for ( int i = 0; i < n; i ++ ) { int count = 1; for (; i < n - 1; i ++ ) { if ( ar [ i ] == ar [ i + 1 ] ) count ++; else break; } res = max ( res, count ); } return res; } int f_filled ( int ar [ ], int n ) {} for (;
i < n - 1;
i ++ ) {
if ( ar [ i ] == ar [ i + 1 ] ) count ++;
else break;
}
res = max ( res, count );
}
return res;
}
int f_filled ( int ar [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,5,8,16,21,21,22,23,26,26,27,27,29,31,33,36,37,37,38,42,45,47,50,57,58,60,60,62,63,66,66,76,84,84,88,96,99};
int param0_1[] = {-30,-60,34,4,86,80,-96,-94,52,46,8,82,-94,-96,78,82,-22,-36,78,50,-46,-36,80,24,-14,94,-46,-38,82,4,-24,2,4,-82,-82,-18,-62,12,8,92,70,-10};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {38,47,84,49,48,62,48,41,38,48,92,16,99};
int param0_4[] = {-88,-64,-40,-38,-38,-16,16,20,28,40,56,58,60,68,74,92};
int param0_5[] = {1,1,0,1,0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,1,1,1,1};
int param0_6[] = {14,24,82,87,95};
int param0_7[] = {-34,62,40,-84,52,-76,2,-58,94,22,2,-18,-88,62,-14,46,50,-58,-80,68,-64,90,-58,12,76,-40,40,-46,8,-80,4,-90,14,-10,64,-68};
int param0_8[] = {0,1,1,1};
int param0_9[] = {43,41,90,5,6,17,68,68,86,89};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {25,35,34,6,12,29,3,34,3,7};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | b) | [
"a) ,",
"b) <",
"c) 10",
"d) b)",
"e) ],"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int m, int n, int x ) {
int table [ n + 1 ] [ x + 1 ];
memset ( table, 0, sizeof ( table ) );
for ( int j = 1;
j <= m && j <= x;
j ++ ) table [ 1 ] [ j ] = 1;
for ( int i = 2;
i <= n;
i ++ ) for ( int j = 1;
j <= x;
j ++ ) for ( int k = 1;
k <= m && k < j;
k ++ ) table [ i ] [ j ] += table [ i - 1 ] [ j - k ];
return table [ n ] [ x ];
}
int f_filled ( int m, int n, int x ) {}
( int j = 1;
j <= x;
j ++ ) for ( int k = 1;
k <= m && k < j;
k ++ ) table [ i ] [ j ] += table [ i - 1 ] [ j - k ];
return table [ n ] [ x ];
}
int f_filled ( int m, int n, int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {94,7,20,90,50,32,46,82,43,6};
int param1[] = {4,12,44,94,58,90,25,50,82,83};
int param2[] = {69,33,24,88,27,29,6,87,70,19};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int m, int n, int x ) { int table [ n + 1 ] [ x + 1 ]; memset ( table, 0, sizeof ( table ) ); for ( int j = 1; j <= m && j <= x; j ++ ) table [ 1 ] [ j ] = 1; for ( int i = 2; i <= n; i ++ ) for [MASK] int j = 1; j <= x; j ++ ) for ( int k = 1; k <= m && k < j; k ++ ) table [ i ] [ j ] += table [ i - 1 ] [ j - k ]; return table [ n ] [ x ]; } int f_filled ( int m, int n, int x ) {} ( int j = 1;
j <= x;
j ++ ) for ( int k = 1;
k <= m && k < j;
k ++ ) table [ i ] [ j ] += table [ i - 1 ] [ j - k ];
return table [ n ] [ x ];
}
int f_filled ( int m, int n, int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {94,7,20,90,50,32,46,82,43,6};
int param1[] = {4,12,44,94,58,90,25,50,82,83};
int param2[] = {69,33,24,88,27,29,6,87,70,19};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ( | [
"a) import",
"b) >",
"c) (",
"d) in",
"e) {"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( n == 1 || n == 0 ) ? 1 : n * f_gold ( n - 1 );
}
int f_filled ( int n ) {}
f (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( n == 1 || n == 0 ) ? 1 : n * f_gold ( n - 1 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {58,42,76,16,49,60,99,45,6,70};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? [MASK] y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { return ( n == 1 || n == 0 ) ? 1 : n * f_gold ( n - 1 ); } int f_filled ( int n ) {}f (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( n == 1 || n == 0 ) ? 1 : n * f_gold ( n - 1 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {58,42,76,16,49,60,99,45,6,70};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | x: | [
"a) y;",
"b) java.util.stream.*;",
"c) <iomanip>",
"d) (",
"e) x:"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n, int k ) {
if ( n + 1 >= k ) return ( k - 1 );
else return ( 2 * n + 1 - k );
}
int f_filled ( int n, int k ) {}
nt arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n, int k ) {
if ( n + 1 >= k ) return ( k - 1 );
else return ( 2 * n + 1 - k );
}
int f_filled ( int n, int k ) {}
int main(void) {
int n_success = 0;
int param0[] = {90,86,92,72,25,11,94,91,66,34};
int param1[] = {74,36,38,71,57,53,80,75,58,88};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> [MASK] <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n, int k ) { if ( n + 1 >= k ) return ( k - 1 ); else return ( 2 * n + 1 - k ); } int f_filled ( int n, int k ) {}nt arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n, int k ) {
if ( n + 1 >= k ) return ( k - 1 );
else return ( 2 * n + 1 - k );
}
int f_filled ( int n, int k ) {}
int main(void) {
int n_success = 0;
int param0[] = {90,86,92,72,25,11,94,91,66,34};
int param1[] = {74,36,38,71,57,53,80,75,58,88};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include | [
"a) return",
"b) using",
"c) #include",
"d) <iomanip>",
"e) )"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
sort ( arr, arr + n );
int minXor = INT_MAX;
int val = 0;
for ( int i = 0;
i < n - 1;
i ++ ) {
val = arr [ i ] ^ arr [ i + 1 ];
minXor = min ( minXor, val );
}
return minXor;
}
int f_filled ( int arr [ ], int n ) {}
MAX;
int val = 0;
for ( int i = 0;
i < n - 1;
i ++ ) {
val = arr [ i ] ^ arr [ i + 1 ];
minXor = min ( minXor, val );
}
return minXor;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {8,11,12,27,32,32,36,56,57,66,68,70,74,78,82,83,96};
int param0_1[] = {40,48,66,4,-60,42,-8,38};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {98,6,82,95,87,20,11,63,78,70,37,12,57,67,10,49,38,28,86,7,61,50,32,68,91,66,57,29,2,64,65,15,16,4,7,76,44,52,81,89,3,36,57,95,48,24};
int param0_4[] = {-88,-84,-76,-58,-40,-38,-28,-24,-20,-14,-12,16,20,28,28,30,40,44,56,58,60,92,92};
int param0_5[] = {0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,1,1,0,1,0};
int param0_6[] = {6,6,19,31,41,45,49,56,78,96,98};
int param0_7[] = {62,-90,22,-84,-4};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {83,13,43,99,34,74,56,20,93,65,92,58,91,72,37,10,39,7,29,69,42,28};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {10,7,19,36,13,20,6,3,21,14};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int [MASK] { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { sort ( arr, arr + n ); int minXor = INT_MAX; int val = 0; for ( int i = 0; i < n - 1; i ++ ) { val = arr [ i ] ^ arr [ i + 1 ]; minXor = min ( minXor, val ); } return minXor; } int f_filled ( int arr [ ], int n ) {}MAX;
int val = 0;
for ( int i = 0;
i < n - 1;
i ++ ) {
val = arr [ i ] ^ arr [ i + 1 ];
minXor = min ( minXor, val );
}
return minXor;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {8,11,12,27,32,32,36,56,57,66,68,70,74,78,82,83,96};
int param0_1[] = {40,48,66,4,-60,42,-8,38};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {98,6,82,95,87,20,11,63,78,70,37,12,57,67,10,49,38,28,86,7,61,50,32,68,91,66,57,29,2,64,65,15,16,4,7,76,44,52,81,89,3,36,57,95,48,24};
int param0_4[] = {-88,-84,-76,-58,-40,-38,-28,-24,-20,-14,-12,16,20,28,28,30,40,44,56,58,60,92,92};
int param0_5[] = {0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,1,1,0,1,0};
int param0_6[] = {6,6,19,31,41,45,49,56,78,96,98};
int param0_7[] = {62,-90,22,-84,-4};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {83,13,43,99,34,74,56,20,93,65,92,58,91,72,37,10,39,7,29,69,42,28};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {10,7,19,36,13,20,6,3,21,14};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | y) | [
"a) for",
"b) int",
"c) <<",
"d) y)",
"e) arr_size"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int r, int R, int r1, int x1, int y1 ) {
int dis = sqrt ( x1 * x1 + y1 * y1 );
return ( dis - r1 >= R && dis + r1 <= r );
}
bool f_filled ( int r, int R, int r1, int x1, int y1 ) {}
f_gold ( int r, int R, int r1, int x1, int y1 ) {
int dis = sqrt ( x1 * x1 + y1 * y1 );
return ( dis - r1 >= R && dis + r1 <= r );
}
bool f_filled ( int r, int R, int r1, int x1, int y1 ) {}
int main(void) {
int n_success = 0;
int param0[] = {8,400,1,61,60,88,60,26,33,70};
int param1[] = {4,1,400,40,49,10,79,88,65,57};
int param2[] = {2,10,10,2,68,69,92,75,57,77};
int param3[] = {6,74,74,50,77,71,29,84,21,52};
int param4[] = {0,38,38,0,71,26,38,10,61,87};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i],param4[i]) == f_gold(param0[i],param1[i],param2[i],param3[i],param4[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int r, int R, int r1, int x1, int y1 ) { int dis = sqrt ( x1 * x1 + y1 * y1 ); return ( dis - r1 [MASK] R && dis + r1 <= r ); } bool f_filled ( int r, int R, int r1, int x1, int y1 ) {} f_gold ( int r, int R, int r1, int x1, int y1 ) {
int dis = sqrt ( x1 * x1 + y1 * y1 );
return ( dis - r1 >= R && dis + r1 <= r );
}
bool f_filled ( int r, int R, int r1, int x1, int y1 ) {}
int main(void) {
int n_success = 0;
int param0[] = {8,400,1,61,60,88,60,26,33,70};
int param1[] = {4,1,400,40,49,10,79,88,65,57};
int param2[] = {2,10,10,2,68,69,92,75,57,77};
int param3[] = {6,74,74,50,77,71,29,84,21,52};
int param4[] = {0,38,38,0,71,26,38,10,61,87};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i],param4[i]) == f_gold(param0[i],param1[i],param2[i],param3[i],param4[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | >= | [
"a) >=",
"b) ]",
"c) j",
"d) )",
"e) x:"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int arr [ ], int n, int x ) {
if ( n < 2 ) return false;
unordered_set < int > s;
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == 0 ) {
if ( x == 0 ) return true;
else continue;
}
if ( x % arr [ i ] == 0 ) {
if ( s . find ( x / arr [ i ] ) != s . end ( ) ) return true;
s . insert ( arr [ i ] );
}
}
return false;
}
bool f_filled ( int arr [ ], int n, int x ) {}
% arr [ i ] == 0 ) {
if ( s . find ( x / arr [ i ] ) != s . end ( ) ) return true;
s . insert ( arr [ i ] );
}
}
return false;
}
bool f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,3,7,23,23,25,27,37,42,53,56,58,61,69,78,79,84,85,86,90,93,95};
int param0_1[] = {-10,-18,88,-36,78,66,-70,-34,-88,-98,-70,-4,-94,-92,-76,-78,-30,-48,-72,86,-64,38,-80,20,70,-32,-90,74,-78,12,-54,88,38,-96,28};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1};
int param0_3[] = {83,61,55,89,16,78,44,54,22,49,58,62,53,99,35,83,29,19,96,39,60,6,34,67,43,29,46,3,81,78,80,39,86,78,21};
int param0_4[] = {-96,-88,-80,-62,-58,-56,-54,-52,-34,-20,-6,-2,6,20,52,54,70,72,80,82,94};
int param0_5[] = {0,1,1,0,0,1,1,1};
int param0_6[] = {8,11,11,20,22,23,26,27,31,38,40,40,45,46,46,48,50,61,73,76,78,78,79,80,81,84,90,91,93,95};
int param0_7[] = {18};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {19,37,47,40,72,59,51,53,92,3,21,81,29,48,97,59,10,74,11,37,49,95,88,85,6,26,76,33};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {15,17,9,23,18,4,24,0,37,22};
int param2[] = {17,22,5,27,12,6,28,0,39,21};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int arr [ ], int n, int [MASK] ) { if ( n < 2 ) return false; unordered_set < int > s; for ( int i = 0; i < n; i ++ ) { if ( arr [ i ] == 0 ) { if ( x == 0 ) return true; else continue; } if ( x % arr [ i ] == 0 ) { if ( s . find ( x / arr [ i ] ) != s . end ( ) ) return true; s . insert ( arr [ i ] ); } } return false; } bool f_filled ( int arr [ ], int n, int x ) {}% arr [ i ] == 0 ) {
if ( s . find ( x / arr [ i ] ) != s . end ( ) ) return true;
s . insert ( arr [ i ] );
}
}
return false;
}
bool f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,3,7,23,23,25,27,37,42,53,56,58,61,69,78,79,84,85,86,90,93,95};
int param0_1[] = {-10,-18,88,-36,78,66,-70,-34,-88,-98,-70,-4,-94,-92,-76,-78,-30,-48,-72,86,-64,38,-80,20,70,-32,-90,74,-78,12,-54,88,38,-96,28};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1};
int param0_3[] = {83,61,55,89,16,78,44,54,22,49,58,62,53,99,35,83,29,19,96,39,60,6,34,67,43,29,46,3,81,78,80,39,86,78,21};
int param0_4[] = {-96,-88,-80,-62,-58,-56,-54,-52,-34,-20,-6,-2,6,20,52,54,70,72,80,82,94};
int param0_5[] = {0,1,1,0,0,1,1,1};
int param0_6[] = {8,11,11,20,22,23,26,27,31,38,40,40,45,46,46,48,50,61,73,76,78,78,79,80,81,84,90,91,93,95};
int param0_7[] = {18};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {19,37,47,40,72,59,51,53,92,3,21,81,29,48,97,59,10,74,11,37,49,95,88,85,6,26,76,33};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {15,17,9,23,18,4,24,0,37,22};
int param2[] = {17,22,5,27,12,6,28,0,39,21};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | x | [
"a) )",
"b) x",
"c) (",
"d) #include",
"e) );"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
if ( n <= 1 ) return n;
int a = 0, b = 1, c = 1;
int res = 1;
while ( c < n ) {
c = a + b;
res ++;
a = b;
b = c;
}
return res;
}
int f_filled ( int n ) {}
( int n ) {
if ( n <= 1 ) return n;
int a = 0, b = 1, c = 1;
int res = 1;
while ( c < n ) {
c = a + b;
res ++;
a = b;
b = c;
}
return res;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {5,19,7,94,58,65,69,96,80,14};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold [MASK] int n ) { if ( n <= 1 ) return n; int a = 0, b = 1, c = 1; int res = 1; while ( c < n ) { c = a + b; res ++; a = b; b = c; } return res; } int f_filled ( int n ) {} ( int n ) {
if ( n <= 1 ) return n;
int a = 0, b = 1, c = 1;
int res = 1;
while ( c < n ) {
c = a + b;
res ++;
a = b;
b = c;
}
return res;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {5,19,7,94,58,65,69,96,80,14};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ( | [
"a) if",
"b) f_gold",
"c) (",
"d) {",
"e) str"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
char f_gold ( char str [] ) {
int len = strlen(str);
int count = 0;
char res = str [ 0 ];
for ( int i = 0;
i < len;
i ++ ) {
int cur_count = 1;
for ( int j = i + 1;
j < len;
j ++ ) {
if ( str [ i ] != str [ j ] ) break;
cur_count ++;
}
if ( cur_count > count ) {
count = cur_count;
res = str [ i ];
}
}
return res;
}
char f_filled ( char str [] ) {}
str [ i ] != str [ j ] ) break;
cur_count ++;
}
if ( cur_count > count ) {
count = cur_count;
res = str [ i ];
}
}
return res;
}
char f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"geeekk","3786868","110","aaaabbcbbb","11","011101","WoHNyJYLC","3141711779","10111101101","aabbabababcc"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} char f_gold ( char str [] ) { int len = strlen(str); int count = 0; char res = str [ 0 ]; for ( int i = 0; i < len; i [MASK] ) { int cur_count = 1; for ( int j = i + 1; j < len; j ++ ) { if ( str [ i ] != str [ j ] ) break; cur_count ++; } if ( cur_count > count ) { count = cur_count; res = str [ i ]; } } return res; } char f_filled ( char str [] ) {}str [ i ] != str [ j ] ) break;
cur_count ++;
}
if ( cur_count > count ) {
count = cur_count;
res = str [ i ];
}
}
return res;
}
char f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"geeekk","3786868","110","aaaabbcbbb","11","011101","WoHNyJYLC","3141711779","10111101101","aabbabababcc"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ++ | [
"a) j",
"b) sum",
"c) ++",
"d) =",
"e) j"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int arr [ ], int n, int x ) {
int i;
for ( i = 0;
i < n - 1;
i ++ ) if ( arr [ i ] > arr [ i + 1 ] ) break;
int l = ( i + 1 ) % n;
int r = i;
while ( l != r ) {
if ( arr [ l ] + arr [ r ] == x ) return true;
if ( arr [ l ] + arr [ r ] < x ) l = ( l + 1 ) % n;
else r = ( n + r - 1 ) % n;
}
return false;
}
bool f_filled ( int arr [ ], int n, int x ) {}
[ l ] + arr [ r ] == x ) return true;
if ( arr [ l ] + arr [ r ] < x ) l = ( l + 1 ) % n;
else r = ( n + r - 1 ) % n;
}
return false;
}
bool f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,8,10,15,18,19,20,20,21,22,26,30,32,34,43,45,50,50,51,52,53,56,57,58,62,63,65,82,86,91,91,92,92,93,97};
int param0_1[] = {30,-34,86,-30,-26,2,90,8,26,-8,-8,0,-86,68,22,72,-76,48,-24,90,-22,-58,-54,90,-12,-12,88,72,-58,68,84,22,60,66,-52,-38,-90,62,30,-26,88,-36,92,32,-32,-42,-90,-40,-10};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {20,68,40,19,74,69};
int param0_4[] = {-98,-94,-94,-94,-90,-88,-88,-78,-74,-70,-68,-66,-64,-62,-54,-50,-40,-40,-40,-40,-28,-22,-22,-18,-14,-12,0,6,6,8,12,20,22,26,28,36,42,44,48,52,56,60,68,84};
int param0_5[] = {1,1,0};
int param0_6[] = {12,22,38,76,80,86};
int param0_7[] = {-36,-10,-26,34,-50,66,-2,-14,-62,60,-48,94,-70,6,-60,-90,28,-4,-20,-52,40,-76,-92,-14,54,4,-58,38,-74,-96,-88,86,-54,98,48,68,78,-28,-80,-46};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {69,99,25,52,41,51,7,33,42,91,85,57,91,89,86,11,70,67,30,92,81,23,51,98,85,5,50,44};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {17,41,26,4,28,2,4,26,17,21};
int param2[] = {30,10,1,88,-94,60,3,37,20,27};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int arr [ ], int n, int x ) { int i; for ( i = 0; i < n - 1; i ++ ) if ( arr [ i ] > arr [ i + 1 ] ) break; int l = ( i + 1 ) % n; int r = i; while ( l != r ) { if ( arr [ l ] + arr [ r ] == x [MASK] return true; if ( arr [ l ] + arr [ r ] < x ) l = ( l + 1 ) % n; else r = ( n + r - 1 ) % n; } return false; } bool f_filled ( int arr [ ], int n, int x ) {} [ l ] + arr [ r ] == x ) return true;
if ( arr [ l ] + arr [ r ] < x ) l = ( l + 1 ) % n;
else r = ( n + r - 1 ) % n;
}
return false;
}
bool f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,8,10,15,18,19,20,20,21,22,26,30,32,34,43,45,50,50,51,52,53,56,57,58,62,63,65,82,86,91,91,92,92,93,97};
int param0_1[] = {30,-34,86,-30,-26,2,90,8,26,-8,-8,0,-86,68,22,72,-76,48,-24,90,-22,-58,-54,90,-12,-12,88,72,-58,68,84,22,60,66,-52,-38,-90,62,30,-26,88,-36,92,32,-32,-42,-90,-40,-10};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {20,68,40,19,74,69};
int param0_4[] = {-98,-94,-94,-94,-90,-88,-88,-78,-74,-70,-68,-66,-64,-62,-54,-50,-40,-40,-40,-40,-28,-22,-22,-18,-14,-12,0,6,6,8,12,20,22,26,28,36,42,44,48,52,56,60,68,84};
int param0_5[] = {1,1,0};
int param0_6[] = {12,22,38,76,80,86};
int param0_7[] = {-36,-10,-26,34,-50,66,-2,-14,-62,60,-48,94,-70,6,-60,-90,28,-4,-20,-52,40,-76,-92,-14,54,4,-58,38,-74,-96,-88,86,-54,98,48,68,78,-28,-80,-46};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {69,99,25,52,41,51,7,33,42,91,85,57,91,89,86,11,70,67,30,92,81,23,51,98,85,5,50,44};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {17,41,26,4,28,2,4,26,17,21};
int param2[] = {30,10,1,88,-94,60,3,37,20,27};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ) | [
"a) import",
"b) )",
"c) return",
"d) -",
"e) ans"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int price [ ], int n ) {
int * profit = new int [ n ];
for ( int i = 0;
i < n;
i ++ ) profit [ i ] = 0;
int max_price = price [ n - 1 ];
for ( int i = n - 2;
i >= 0;
i -- ) {
if ( price [ i ] > max_price ) max_price = price [ i ];
profit [ i ] = max ( profit [ i + 1 ], max_price - price [ i ] );
}
int min_price = price [ 0 ];
for ( int i = 1;
i < n;
i ++ ) {
if ( price [ i ] < min_price ) min_price = price [ i ];
profit [ i ] = max ( profit [ i - 1 ], profit [ i ] + ( price [ i ] - min_price ) );
}
int result = profit [ n - 1 ];
delete [ ] profit;
return result;
}
int f_filled ( int price [ ], int n ) {}
[ i ] = max ( profit [ i - 1 ], profit [ i ] + ( price [ i ] - min_price ) );
}
int result = profit [ n - 1 ];
delete [ ] profit;
return result;
}
int f_filled ( int price [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,10,10,12,17,18,23,32,41,44,47,50,59,69,69,75,82,84,87,89,97,99};
int param0_1[] = {6,6,60,40,32,-70,-92,88,10,-8,-54,4,16,8,-44,80,-70,36,36,-74,-94,18,-64,-66,-46,0,-54,-84,16,-88,-34,-24,92,84,62};
int param0_2[] = {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {2,67,50,8,20,42,37,69,86,74,85,96,78,89,91};
int param0_4[] = {-68,-52,-14,-2,18,22,30,34,64,64,70};
int param0_5[] = {1,1,0,0,0,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,0,1,0,0,1,1,0,1};
int param0_6[] = {4,17,19,28,29,30,30,30,35,36,36,38,40,40,42,43,45,51,55,57,58,59,64,65,66,82,84,85,87,91,92,94,98,98};
int param0_7[] = {52,88,-40,60,30,8,-96,66,-96,-28,-56,-14,76,-92,56,58,64,-60,-90,26,64,-2,54,-24,54,-46,-44};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {82,14,51,12,5,15,50,88,91,82,16,98,23,58,86,91,30,81,7,73,67,47,10,50,43,31,19,2,22};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {20,34,13,8,9,21,25,14,22,18};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int price [ ], int n ) { int * profit = new int [ n ]; for ( int i = 0; i < n; i ++ ) profit [ i ] = 0; int max_price = price [ n - 1 ]; for ( int i = n - 2; i >= 0; i -- ) { if ( price [ i ] > max_price ) max_price = price [ i ]; profit [ i ] = max ( profit [ i + 1 ], max_price - price [ i ] ); } int min_price = price [ 0 ]; for ( int i = 1; i < n; i ++ ) { if ( price [ i ] < min_price ) min_price = price [ i ]; profit [ i ] = max ( profit [ i - 1 ], profit [ i ] + ( price [ i ] - min_price ) ); } int result = profit [ n - 1 ]; delete [ ] profit; return result; } int f_filled ( int price [ [MASK] int n ) {}[ i ] = max ( profit [ i - 1 ], profit [ i ] + ( price [ i ] - min_price ) );
}
int result = profit [ n - 1 ];
delete [ ] profit;
return result;
}
int f_filled ( int price [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,10,10,12,17,18,23,32,41,44,47,50,59,69,69,75,82,84,87,89,97,99};
int param0_1[] = {6,6,60,40,32,-70,-92,88,10,-8,-54,4,16,8,-44,80,-70,36,36,-74,-94,18,-64,-66,-46,0,-54,-84,16,-88,-34,-24,92,84,62};
int param0_2[] = {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {2,67,50,8,20,42,37,69,86,74,85,96,78,89,91};
int param0_4[] = {-68,-52,-14,-2,18,22,30,34,64,64,70};
int param0_5[] = {1,1,0,0,0,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,0,1,0,0,1,1,0,1};
int param0_6[] = {4,17,19,28,29,30,30,30,35,36,36,38,40,40,42,43,45,51,55,57,58,59,64,65,66,82,84,85,87,91,92,94,98,98};
int param0_7[] = {52,88,-40,60,30,8,-96,66,-96,-28,-56,-14,76,-92,56,58,64,-60,-90,26,64,-2,54,-24,54,-46,-44};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {82,14,51,12,5,15,50,88,91,82,16,98,23,58,86,91,30,81,7,73,67,47,10,50,43,31,19,2,22};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {20,34,13,8,9,21,25,14,22,18};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ], | [
"a) 1",
"b) ],",
"c) j",
"d) (",
"e) n)"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int f_gold [ n ];
f_gold [ 0 ] = 1;
for ( int i = 1;
i < n;
i ++ ) {
f_gold [ i ] = 1;
for ( int j = 0;
j < i;
j ++ ) if ( arr [ i ] > arr [ j ] && f_gold [ i ] < f_gold [ j ] + 1 ) f_gold [ i ] = f_gold [ j ] + 1;
}
return * max_element ( f_gold, f_gold + n );
}
int f_filled ( int arr [ ], int n ) {}
j ++ ) if ( arr [ i ] > arr [ j ] && f_gold [ i ] < f_gold [ j ] + 1 ) f_gold [ i ] = f_gold [ j ] + 1;
}
return * max_element ( f_gold, f_gold + n );
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {14,17,27,28,36,38,40,49,51,57,58,61,62,71,91,94,99};
int param0_1[] = {-48,54,98,68,24,-46,4,-28,-34,40};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {94,74,27,59,3,71,67,91,91,87,1,79,42,33,85,37,76,86,80,84,62,8,31,54,17,48,4,12,88,63,12,51,36,20,73,48,41,88,21,98,57,3,54};
int param0_4[] = {-96,-94,-90,-88,-86,-82,-76,-74,-68,-54,-54,-50,-50,-46,-46,-40,-36,-34,-34,-32,-30,-26,-26,-20,-16,-6,-4,2,10,14,22,26,26,28,28,30,30,36,54,64,68,74,78,80,84,90,92,94};
int param0_5[] = {0,0,0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,0,1,1,0,1,0,1,1,0,0,0,0,0,1,0,0,1,1,0,0,1,1,1,0,1,1,0,0,1,0,0};
int param0_6[] = {6,12,18,34,37,37,37,40,45,60,64,66,73,78,79,80,92};
int param0_7[] = {64,-18,-22,96,-92,6,-46,-54,76,0,46,74,-8,22,-46,-44,-94,-88,-52,-54,2,98,-22,46,26,2,-64,-84,20,22,12,-32,-16,-96,46,-4,-8,46,-64,-58,58,92,0,-26,-58,82};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {57,34,3,67,21,69,31,49,7,70,27,53,94,23,74,24,44,53,78,46,6,29,5,41,38,22,40,38,40,59,9};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {14,8,17,24,36,34,11,24,33,16};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { [MASK] (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int f_gold [ n ]; f_gold [ 0 ] = 1; for ( int i = 1; i < n; i ++ ) { f_gold [ i ] = 1; for ( int j = 0; j < i; j ++ ) if ( arr [ i ] > arr [ j ] && f_gold [ i ] < f_gold [ j ] + 1 ) f_gold [ i ] = f_gold [ j ] + 1; } return * max_element ( f_gold, f_gold + n ); } int f_filled ( int arr [ ], int n ) {}j ++ ) if ( arr [ i ] > arr [ j ] && f_gold [ i ] < f_gold [ j ] + 1 ) f_gold [ i ] = f_gold [ j ] + 1;
}
return * max_element ( f_gold, f_gold + n );
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {14,17,27,28,36,38,40,49,51,57,58,61,62,71,91,94,99};
int param0_1[] = {-48,54,98,68,24,-46,4,-28,-34,40};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {94,74,27,59,3,71,67,91,91,87,1,79,42,33,85,37,76,86,80,84,62,8,31,54,17,48,4,12,88,63,12,51,36,20,73,48,41,88,21,98,57,3,54};
int param0_4[] = {-96,-94,-90,-88,-86,-82,-76,-74,-68,-54,-54,-50,-50,-46,-46,-40,-36,-34,-34,-32,-30,-26,-26,-20,-16,-6,-4,2,10,14,22,26,26,28,28,30,30,36,54,64,68,74,78,80,84,90,92,94};
int param0_5[] = {0,0,0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,0,1,1,0,1,0,1,1,0,0,0,0,0,1,0,0,1,1,0,0,1,1,1,0,1,1,0,0,1,0,0};
int param0_6[] = {6,12,18,34,37,37,37,40,45,60,64,66,73,78,79,80,92};
int param0_7[] = {64,-18,-22,96,-92,6,-46,-54,76,0,46,74,-8,22,-46,-44,-94,-88,-52,-54,2,98,-22,46,26,2,-64,-84,20,22,12,-32,-16,-96,46,-4,-8,46,-64,-58,58,92,0,-26,-58,82};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {57,34,3,67,21,69,31,49,7,70,27,53,94,23,74,24,44,53,78,46,6,29,5,41,38,22,40,38,40,59,9};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {14,8,17,24,36,34,11,24,33,16};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | return | [
"a) )",
"b) #include",
"c) [",
"d) return",
"e) end"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int diff = INT_MAX;
for ( int i = 0;
i < n - 1;
i ++ ) for ( int j = i + 1;
j < n;
j ++ ) if ( abs ( arr [ i ] - arr [ j ] ) < diff ) diff = abs ( arr [ i ] - arr [ j ] );
return diff;
}
int f_filled ( int arr [ ], int n ) {}
< n - 1;
i ++ ) for ( int j = i + 1;
j < n;
j ++ ) if ( abs ( arr [ i ] - arr [ j ] ) < diff ) diff = abs ( arr [ i ] - arr [ j ] );
return diff;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,2,3,5,8,10,11,15,15,16,20,26,28,30,30,33,33,39,50,50,50,54,62,66,68,69,69,74,74,75,75,76,78,82,83,85,86,86,89,89,91,91,92,92,92,93,94,98};
int param0_1[] = {6,6,-20,88,-78,-18,74,72,80,76,-62,38};
int param0_2[] = {0,1,1,1,1};
int param0_3[] = {75,85,49,66,44,89,80,39,64,70,25,21,81,33,90,68,51};
int param0_4[] = {-96,-10,0,4,54,64};
int param0_5[] = {1,0,1,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,0,1,1,0,1,1,0,0,1,0,1,1,1,0,1,1,1,1,1,0,1,1,0,0};
int param0_6[] = {3,3,5,5,7,7,9,11,11,18,18,18,20,29,29,31,31,32,37,43,44,46,48,50,52,52,53,63,63,65,69,72,76,76,81,84,85,86,87,87,90,94,97,97};
int param0_7[] = {40,-46,72,-28,8,90,86,-90,8,-66,-98,6,42,86,88,42,-50,74,-34,-16,-94,-56,-18,-18,84,-44,34,80,96,42,-50,-92,70,80,62,-38,-4,68,54,-14,30,-18,-58};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {15,41,32,19,68,36,61,59,5,91,53,95,10,64,15,32,14,64,48,70,85,19,83,2,33,58,93,88,21,88,45,45,18,8};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {32,11,3,16,3,41,27,33,26,24};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int diff = INT_MAX; for ( int i = [MASK] i < n - 1; i ++ ) for ( int j = i + 1; j < n; j ++ ) if ( abs ( arr [ i ] - arr [ j ] ) < diff ) diff = abs ( arr [ i ] - arr [ j ] ); return diff; } int f_filled ( int arr [ ], int n ) {} < n - 1;
i ++ ) for ( int j = i + 1;
j < n;
j ++ ) if ( abs ( arr [ i ] - arr [ j ] ) < diff ) diff = abs ( arr [ i ] - arr [ j ] );
return diff;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,2,3,5,8,10,11,15,15,16,20,26,28,30,30,33,33,39,50,50,50,54,62,66,68,69,69,74,74,75,75,76,78,82,83,85,86,86,89,89,91,91,92,92,92,93,94,98};
int param0_1[] = {6,6,-20,88,-78,-18,74,72,80,76,-62,38};
int param0_2[] = {0,1,1,1,1};
int param0_3[] = {75,85,49,66,44,89,80,39,64,70,25,21,81,33,90,68,51};
int param0_4[] = {-96,-10,0,4,54,64};
int param0_5[] = {1,0,1,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,0,1,1,0,1,1,0,0,1,0,1,1,1,0,1,1,1,1,1,0,1,1,0,0};
int param0_6[] = {3,3,5,5,7,7,9,11,11,18,18,18,20,29,29,31,31,32,37,43,44,46,48,50,52,52,53,63,63,65,69,72,76,76,81,84,85,86,87,87,90,94,97,97};
int param0_7[] = {40,-46,72,-28,8,90,86,-90,8,-66,-98,6,42,86,88,42,-50,74,-34,-16,-94,-56,-18,-18,84,-44,34,80,96,42,-50,-92,70,80,62,-38,-4,68,54,-14,30,-18,-58};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {15,41,32,19,68,36,61,59,5,91,53,95,10,64,15,32,14,64,48,70,85,19,83,2,33,58,93,88,21,88,45,45,18,8};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {32,11,3,16,3,41,27,33,26,24};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | 0; | [
"a) ],",
"b) 0;",
"c) arr",
"d) :",
"e) ="
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int N ) {
int lis [ N ];
for ( int i = 0;
i < N;
i ++ ) lis [ i ] = 1;
for ( int i = 1;
i < N;
i ++ ) for ( int j = 0;
j < i;
j ++ ) if ( arr [ i ] >= arr [ j ] && lis [ i ] < lis [ j ] + 1 ) lis [ i ] = lis [ j ] + 1;
int max = 0;
for ( int i = 0;
i < N;
i ++ ) if ( max < lis [ i ] ) max = lis [ i ];
return ( N - max );
}
int f_filled ( int arr [ ], int N ) {}
s [ j ] + 1 ) lis [ i ] = lis [ j ] + 1;
int max = 0;
for ( int i = 0;
i < N;
i ++ ) if ( max < lis [ i ] ) max = lis [ i ];
return ( N - max );
}
int f_filled ( int arr [ ], int N ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,7,20,22,23,31,33,36,47,61,63,63,71,74,82,91,95,99};
int param0_1[] = {-84,12,-42,-78,22,72,56,70,28,-72};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {29,41,4,62,77,74,30,2,14,90,93,10,78,36,66,22,48,89,36,73,70,23,90};
int param0_4[] = {-80,-72,-68,-66,-58,-50,-48,-32,-28,-24,-22,-18,0,2,6,10,12,14,14,18,24,24,24,28,28,28,34,38,42,42,46,46,46,58,80,82,82,84,84,86,88,90,92,96};
int param0_5[] = {1,1,0,1,0,1,0,0,1,0};
int param0_6[] = {26,36,58,64,69,72,79,82,82,87,89,90,95};
int param0_7[] = {-52,-40,98,40,42,-50,60,-64,-92,36,-88,72,-72,38,-80,-52,68,70,16,22,-30,-74,56,-80,62,-54,-32,-22,-86,-70,88,-76,-46,28,40,-2,-84,68,-98,-16,90,36,-38,-86,20,-40,82,98,54};
int param0_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {36,62,58,24,99,12,46,3,4,40,54,97,48,94,98,7,17,5,3,36,3};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {15,7,16,13,36,8,8,41,10,16};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int N ) { int lis [ N ]; for ( int i = 0; i < N; i ++ ) lis [ i ] = 1; for ( int i = 1; i < N; i ++ ) for ( int j = 0; j < i; j ++ ) if ( arr [ i ] >= arr [ j ] [MASK] lis [ i ] < lis [ j ] + 1 ) lis [ i ] = lis [ j ] + 1; int max = 0; for ( int i = 0; i < N; i ++ ) if ( max < lis [ i ] ) max = lis [ i ]; return ( N - max ); } int f_filled ( int arr [ ], int N ) {}s [ j ] + 1 ) lis [ i ] = lis [ j ] + 1;
int max = 0;
for ( int i = 0;
i < N;
i ++ ) if ( max < lis [ i ] ) max = lis [ i ];
return ( N - max );
}
int f_filled ( int arr [ ], int N ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,7,20,22,23,31,33,36,47,61,63,63,71,74,82,91,95,99};
int param0_1[] = {-84,12,-42,-78,22,72,56,70,28,-72};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {29,41,4,62,77,74,30,2,14,90,93,10,78,36,66,22,48,89,36,73,70,23,90};
int param0_4[] = {-80,-72,-68,-66,-58,-50,-48,-32,-28,-24,-22,-18,0,2,6,10,12,14,14,18,24,24,24,28,28,28,34,38,42,42,46,46,46,58,80,82,82,84,84,86,88,90,92,96};
int param0_5[] = {1,1,0,1,0,1,0,0,1,0};
int param0_6[] = {26,36,58,64,69,72,79,82,82,87,89,90,95};
int param0_7[] = {-52,-40,98,40,42,-50,60,-64,-92,36,-88,72,-72,38,-80,-52,68,70,16,22,-30,-74,56,-80,62,-54,-32,-22,-86,-70,88,-76,-46,28,40,-2,-84,68,-98,-16,90,36,-38,-86,20,-40,82,98,54};
int param0_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {36,62,58,24,99,12,46,3,4,40,54,97,48,94,98,7,17,5,3,36,3};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {15,7,16,13,36,8,8,41,10,16};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | && | [
"a) java.lang.*;",
"b) i",
"c) &&",
"d) void",
"e) *"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int leftMax [ n ];
leftMax [ 0 ] = INT_MIN;
for ( int i = 1;
i < n;
i ++ ) leftMax [ i ] = max ( leftMax [ i - 1 ], arr [ i - 1 ] );
int rightMin = INT_MAX;
for ( int i = n - 1;
i >= 0;
i -- ) {
if ( leftMax [ i ] < arr [ i ] && rightMin > arr [ i ] ) return i;
rightMin = min ( rightMin, arr [ i ] );
}
return - 1;
}
int f_filled ( int arr [ ], int n ) {}
i >= 0;
i -- ) {
if ( leftMax [ i ] < arr [ i ] && rightMin > arr [ i ] ) return i;
rightMin = min ( rightMin, arr [ i ] );
}
return - 1;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,24,30,33,56,67,87,90};
int param0_1[] = {72,-48,12,4,46,36,2,58,82,-88,-14,56,90,76,18,-6,-28,18,88,90,40,-68,-10,-82,-28,16,32,-90,12,-86,-16,78,-98,-52,-26,80,6,50,40,-12,52,38,-92,94,-32,14,-80,-88,48};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {51,87,46,76,2,89,56,34,49,61,44,73,14,60,89};
int param0_4[] = {-90,-90,-80,-72,-68,-64,-62,-62,-60,-46,-44,-44,-44,-42,-42,-32,-22,-22,-18,-2,4,6,10,12,14,30,34,34,40,56,56,56,58,68,74,78,78,82,84,86,88,90,92};
int param0_5[] = {0,0,0,1,1,0,1,1,1,0,0,1,1,1,0,0,1,1,1,0,1,0,1,0,0,0,0,0,1,0,0,1,1,1,0,0,0,1,1,0};
int param0_6[] = {7,8,11,12,15,17,28,34,57,61,66,76,92};
int param0_7[] = {-22,-96,-78,-60,34,-18,86,-42,-78,76,8,28,-80,80,6,-72,34,66,84,50,-4,18,72,-66,-68,-24,56,-12,-70,24,-82};
int param0_8[] = {0,0,0,0,0,0,1,1,1,1,1};
int param0_9[] = {79,81,55,6,78,93,81,33,29,1,27,49,21,58,22,65,44,95,6,51,75,42,14,55,79,82,90,8,15,15,53,98,76,43,33};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {4,28,30,11,29,26,9,19,9,30};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( [MASK] - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int leftMax [ n ]; leftMax [ 0 ] = INT_MIN; for ( int i = 1; i < n; i ++ ) leftMax [ i ] = max ( leftMax [ i - 1 ], arr [ i - 1 ] ); int rightMin = INT_MAX; for ( int i = n - 1; i >= 0; i -- ) { if ( leftMax [ i ] < arr [ i ] && rightMin > arr [ i ] ) return i; rightMin = min ( rightMin, arr [ i ] ); } return - 1; } int f_filled ( int arr [ ], int n ) {}
i >= 0;
i -- ) {
if ( leftMax [ i ] < arr [ i ] && rightMin > arr [ i ] ) return i;
rightMin = min ( rightMin, arr [ i ] );
}
return - 1;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,24,30,33,56,67,87,90};
int param0_1[] = {72,-48,12,4,46,36,2,58,82,-88,-14,56,90,76,18,-6,-28,18,88,90,40,-68,-10,-82,-28,16,32,-90,12,-86,-16,78,-98,-52,-26,80,6,50,40,-12,52,38,-92,94,-32,14,-80,-88,48};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {51,87,46,76,2,89,56,34,49,61,44,73,14,60,89};
int param0_4[] = {-90,-90,-80,-72,-68,-64,-62,-62,-60,-46,-44,-44,-44,-42,-42,-32,-22,-22,-18,-2,4,6,10,12,14,30,34,34,40,56,56,56,58,68,74,78,78,82,84,86,88,90,92};
int param0_5[] = {0,0,0,1,1,0,1,1,1,0,0,1,1,1,0,0,1,1,1,0,1,0,1,0,0,0,0,0,1,0,0,1,1,1,0,0,0,1,1,0};
int param0_6[] = {7,8,11,12,15,17,28,34,57,61,66,76,92};
int param0_7[] = {-22,-96,-78,-60,34,-18,86,-42,-78,76,8,28,-80,80,6,-72,34,66,84,50,-4,18,72,-66,-68,-24,56,-12,-70,24,-82};
int param0_8[] = {0,0,0,0,0,0,1,1,1,1,1};
int param0_9[] = {79,81,55,6,78,93,81,33,29,1,27,49,21,58,22,65,44,95,6,51,75,42,14,55,79,82,90,8,15,15,53,98,76,43,33};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {4,28,30,11,29,26,9,19,9,30};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | *(int*)a | [
"a) else",
"b) [",
"c) *(int*)a",
"d) =",
"e) ["
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( char str [] ) {
int zeros = 0, ones = 0;
for ( char ch : str ) ( ch == '0' ) ? ++ zeros : ++ ones;
return ( zeros == 1 || ones == 1 );
}
bool f_filled ( char str [] ) {}
c);}
bool f_gold ( char str [] ) {
int zeros = 0, ones = 0;
for ( char ch : str ) ( ch == '0' ) ? ++ zeros : ++ ones;
return ( zeros == 1 || ones == 1 );
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"00001","0000","11","111110","1","111010111010","hUInqJXNdbfP","5191","1110101101","NupSrU xz"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} [MASK] sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( char str [] ) { int zeros = 0, ones = 0; for ( char ch : str ) ( ch == '0' ) ? ++ zeros : ++ ones; return ( zeros == 1 || ones == 1 ); } bool f_filled ( char str [] ) {}c);}
bool f_gold ( char str [] ) {
int zeros = 0, ones = 0;
for ( char ch : str ) ( ch == '0' ) ? ++ zeros : ++ ones;
return ( zeros == 1 || ones == 1 );
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"00001","0000","11","111110","1","111010111010","hUInqJXNdbfP","5191","1110101101","NupSrU xz"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | void | [
"a) void",
"b) {",
"c) str2",
"d) ++",
"e) import"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char N [] ) {
int len = strlen(N);
int l = ( len ) / 2;
int count = 0;
for ( int i = 1;
i <= l;
i ++ ) {
char s [] = N . substr ( 0, i );
int l1 = strlen(s);
char t [] = N . substr ( i, l1 );
if ( s [ 0 ] == '0' || t [ 0 ] == '0' ) continue;
if ( s . compare ( t ) == 0 ) count ++;
}
return count;
}
int f_filled ( char N [] ) {}
len(s);
char t [] = N . substr ( i, l1 );
if ( s [ 0 ] == '0' || t [ 0 ] == '0' ) continue;
if ( s . compare ( t ) == 0 ) count ++;
}
return count;
}
int f_filled ( char N [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"ZCoQhuM","2674377254","11","LbuGlvRyWAPBpo","26382426486138","111010111010","hUInqJXNdbfP","5191","1110101101","2202200"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int [MASK] x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char N [] ) { int len = strlen(N); int l = ( len ) / 2; int count = 0; for ( int i = 1; i <= l; i ++ ) { char s [] = N . substr ( 0, i ); int l1 = strlen(s); char t [] = N . substr ( i, l1 ); if ( s [ 0 ] == '0' || t [ 0 ] == '0' ) continue; if ( s . compare ( t ) == 0 ) count ++; } return count; } int f_filled ( char N [] ) {}len(s);
char t [] = N . substr ( i, l1 );
if ( s [ 0 ] == '0' || t [ 0 ] == '0' ) continue;
if ( s . compare ( t ) == 0 ) count ++;
}
return count;
}
int f_filled ( char N [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"ZCoQhuM","2674377254","11","LbuGlvRyWAPBpo","26382426486138","111010111010","hUInqJXNdbfP","5191","1110101101","2202200"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | min(int | [
"a) )",
"b) [",
"c) }",
"d) ]",
"e) min(int"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
char f_gold [] ( char s [] ) {
int n = strlen(s);
int sub_count = n * ( n + 1 ) / 2;
char arr [] [ sub_count ];
int index = 0;
for ( int i = 0;
i < n;
i ++ ) for ( int len = 1;
len <= n - i;
len ++ ) arr [ index ++ ] = s . substr ( i, len );
sort ( arr, arr + sub_count );
char res [] = "";
for ( int i = 0;
i < sub_count;
i ++ ) res += arr [ i ];
return res;
}
char f_filled [] ( char s [] ) {}
++ ] = s . substr ( i, len );
sort ( arr, arr + sub_count );
char res [] = "";
for ( int i = 0;
i < sub_count;
i ++ ) res += arr [ i ];
return res;
}
char f_filled [] ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"sqGOi","848580","01001110011001","ZhWXUKmeiI","0917296541285","01101001111100","tjP kR","999907","011100","qJPHNSJOUj"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} char f_gold [] ( char s [] ) { int n = strlen(s); int sub_count = n * ( n + 1 ) / 2; char arr [] [ sub_count ]; int index = 0; for ( int i = 0; i < n; i ++ ) for ( int len = 1; len <= n - i; len ++ ) arr [ index ++ ] = s . substr ( i, len ); sort ( arr, arr + sub_count ); char res [] = ""; for ( int i = 0; i < sub_count; i ++ ) res += arr [ i [MASK] return res; } char f_filled [] ( char s [] ) {}++ ] = s . substr ( i, len );
sort ( arr, arr + sub_count );
char res [] = "";
for ( int i = 0;
i < sub_count;
i ++ ) res += arr [ i ];
return res;
}
char f_filled [] ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"sqGOi","848580","01001110011001","ZhWXUKmeiI","0917296541285","01101001111100","tjP kR","999907","011100","qJPHNSJOUj"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ]; | [
"a) s1",
"b) n",
"c) ];",
"d) (",
"e) ]"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int degree [ ], int n ) {
int deg_sum = 0;
for ( int i = 0;
i < n;
i ++ ) deg_sum += degree [ i ];
return ( 2 * ( n - 1 ) == deg_sum );
}
bool f_filled ( int degree [ ], int n ) {}
ld ( int degree [ ], int n ) {
int deg_sum = 0;
for ( int i = 0;
i < n;
i ++ ) deg_sum += degree [ i ];
return ( 2 * ( n - 1 ) == deg_sum );
}
bool f_filled ( int degree [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2};
int param0_1[] = {1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,1,1,0,1,1,0,0,0,1,0,1,1,1,1,1,1,0,1,1,1,0,1,0,0};
int param0_2[] = {1,6,10,13,15,17,18,23,26,28,30,32,32,33,36,39,39,41,43,50,50,51,53,54,59,59,63,63,63,66,66,71,71,74,78,89,89,93};
int param0_3[] = {66,-96,-14,74,-20};
int param0_4[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_5[] = {97,73,87,45,64,30,53,50,62,42,28,58,31,90};
int *param0[6] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5};
int param1[] = {5,5,5,6,3,19,30,4,31,10};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int degree [ ], int n ) { int deg_sum = 0; for ( int i = 0; i < n; i ++ ) deg_sum += degree [ i ]; [MASK] ( 2 * ( n - 1 ) == deg_sum ); } bool f_filled ( int degree [ ], int n ) {}ld ( int degree [ ], int n ) {
int deg_sum = 0;
for ( int i = 0;
i < n;
i ++ ) deg_sum += degree [ i ];
return ( 2 * ( n - 1 ) == deg_sum );
}
bool f_filled ( int degree [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2};
int param0_1[] = {1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,1,1,0,1,1,0,0,0,1,0,1,1,1,1,1,1,0,1,1,1,0,1,0,0};
int param0_2[] = {1,6,10,13,15,17,18,23,26,28,30,32,32,33,36,39,39,41,43,50,50,51,53,54,59,59,63,63,63,66,66,71,71,74,78,89,89,93};
int param0_3[] = {66,-96,-14,74,-20};
int param0_4[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_5[] = {97,73,87,45,64,30,53,50,62,42,28,58,31,90};
int *param0[6] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5};
int param1[] = {5,5,5,6,3,19,30,4,31,10};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | return | [
"a) ]",
"b) )",
"c) return",
"d) :",
"e) i"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int low, int high, int x ) {
int i;
if ( x <= arr [ low ] ) return low;
for ( i = low;
i < high;
i ++ ) {
if ( arr [ i ] == x ) return i;
if ( arr [ i ] < x && arr [ i + 1 ] >= x ) return i + 1;
}
return - 1;
}
int f_filled ( int arr [ ], int low, int high, int x ) {}
i < high;
i ++ ) {
if ( arr [ i ] == x ) return i;
if ( arr [ i ] < x && arr [ i + 1 ] >= x ) return i + 1;
}
return - 1;
}
int f_filled ( int arr [ ], int low, int high, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,3,4,6,8,9,9,10,11,16,19,20,21,21,21,24,24,25,28,30,30,30,32,34,35,39,41,42,49,52,57,59,61,62,66,68,71,73,76,79,83,84,85,86,87,87};
int param0_1[] = {92,50,-84,60,32,-54,84,-82,-42,-72,-64,-28,-48,66,92,-42,42,-66,52,-30,48,42,36,-4,64,62,-16,0,20,26,78,78,12,-6,-30,-14,76,72,70,-34,98,32};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {26,68,73,76,14,19,56,80,17,7,15,64,99,98,21,21,72,12,14,10,44,82,25,42,46,86,79,43,91};
int param0_4[] = {-90,-86,-84,-50,-30,-24,-12,-2,8,22,30,44,58,58,60,60,62,90};
int param0_5[] = {0,0,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,0,1,1};
int param0_6[] = {2,2,29,31,34,39,48,50,56,61,66,66,69,73,88};
int param0_7[] = {-98,48,-58,8,70,62,92,84,-58,-46,-26,-92,18,-88,40,-12,60,14,54,-64,88,52,-44,88,-46,-8,36,-22,28,-20,-50,58,-82,-44,-44,54,-86,40,10,0,-24,-84,-10,62,58,0,-88};
int param0_8[] = {0,0,0,0,1,1};
int param0_9[] = {56,30,33,5,67,35,22,54,36,55,94,89,40,65,29,76,17,14,14,49,40,44,35,69,63,2,81,78,19,67,12,14,68,30,82,85,12,2,94,33,85,75,97,31,69,31,85,26};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {23,36,11,23,9,12,9,40,5,46};
int param2[] = {37,35,9,27,16,15,12,29,5,47};
int param3[] = {44,34,13,26,10,18,10,24,5,47};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | [MASK] <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int low, int high, int x ) { int i; if ( x <= arr [ low ] ) return low; for ( i = low; i < high; i ++ ) { if ( arr [ i ] == x ) return i; if ( arr [ i ] < x && arr [ i + 1 ] >= x ) return i + 1; } return - 1; } int f_filled ( int arr [ ], int low, int high, int x ) {}i < high;
i ++ ) {
if ( arr [ i ] == x ) return i;
if ( arr [ i ] < x && arr [ i + 1 ] >= x ) return i + 1;
}
return - 1;
}
int f_filled ( int arr [ ], int low, int high, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,3,4,6,8,9,9,10,11,16,19,20,21,21,21,24,24,25,28,30,30,30,32,34,35,39,41,42,49,52,57,59,61,62,66,68,71,73,76,79,83,84,85,86,87,87};
int param0_1[] = {92,50,-84,60,32,-54,84,-82,-42,-72,-64,-28,-48,66,92,-42,42,-66,52,-30,48,42,36,-4,64,62,-16,0,20,26,78,78,12,-6,-30,-14,76,72,70,-34,98,32};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {26,68,73,76,14,19,56,80,17,7,15,64,99,98,21,21,72,12,14,10,44,82,25,42,46,86,79,43,91};
int param0_4[] = {-90,-86,-84,-50,-30,-24,-12,-2,8,22,30,44,58,58,60,60,62,90};
int param0_5[] = {0,0,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,0,1,1};
int param0_6[] = {2,2,29,31,34,39,48,50,56,61,66,66,69,73,88};
int param0_7[] = {-98,48,-58,8,70,62,92,84,-58,-46,-26,-92,18,-88,40,-12,60,14,54,-64,88,52,-44,88,-46,-8,36,-22,28,-20,-50,58,-82,-44,-44,54,-86,40,10,0,-24,-84,-10,62,58,0,-88};
int param0_8[] = {0,0,0,0,1,1};
int param0_9[] = {56,30,33,5,67,35,22,54,36,55,94,89,40,65,29,76,17,14,14,49,40,44,35,69,63,2,81,78,19,67,12,14,68,30,82,85,12,2,94,33,85,75,97,31,69,31,85,26};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {23,36,11,23,9,12,9,40,5,46};
int param2[] = {37,35,9,27,16,15,12,29,5,47};
int param3[] = {44,34,13,26,10,18,10,24,5,47};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include | [
"a) .",
"b) ;",
"c) #include",
"d) -",
"e) n"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
char f_gold [] ( char str [] ) {
stack < int > integerstack;
stack < char > stringstack;
char temp [] = "", result = "";
for ( int i = 0;
i < strlen(str);
i ++ ) {
int count = 0;
if ( str [ i ] >= '0' && str [ i ] <= '9' ) {
while ( str [ i ] >= '0' && str [ i ] <= '9' ) {
count = count * 10 + str [ i ] - '0';
i ++;
}
i --;
integerstack . push ( count );
}
else if ( str [ i ] == ']' ) {
temp = "";
count = 0;
if ( ! integerstack . empty ( ) ) {
count = integerstack . top ( );
integerstack . pop ( );
}
while ( ! stringstack . empty ( ) && stringstack . top ( ) != '[' ) {
temp = stringstack . top ( ) + temp;
stringstack . pop ( );
}
if ( ! stringstack . empty ( ) && stringstack . top ( ) == '[' ) stringstack . pop ( );
for ( int j = 0;
j < count;
j ++ ) result = result + temp;
for ( int j = 0;
j < strlen(result);
j ++ ) stringstack . push ( result [ j ] );
result = "";
}
else if ( str [ i ] == '[' ) {
if ( str [ i - 1 ] >= '0' && str [ i - 1 ] <= '9' ) stringstack . push ( str [ i ] );
else {
stringstack . push ( str [ i ] );
integerstack . push ( 1 );
}
}
else stringstack . push ( str [ i ] );
}
while ( ! stringstack . empty ( ) ) {
result = stringstack . top ( ) + result;
stringstack . pop ( );
}
return result;
}
char f_filled [] ( char str [] ) {}
push ( str [ i ] );
}
while ( ! stringstack . empty ( ) ) {
result = stringstack . top ( ) + result;
stringstack . pop ( );
}
return result;
}
char f_filled [] ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"rpaBQkHqRaTb","9916267","000010100010","XfHXbWwaRd","750","0","K","0218044","10100010011","zR"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} char f_gold [] ( char str [] ) { stack < int > integerstack; stack < char > stringstack; char temp [] = "", result = ""; for ( int i = 0; i < strlen(str); i ++ ) { int count = 0; if ( str [ i ] >= '0' && str [ i ] <= '9' ) { while ( str [ i ] >= '0' && str [ i ] <= '9' ) { count = count * 10 + str [ i ] - '0'; i ++; } i --; integerstack . push ( count ); } else if ( str [ i ] == ']' ) { temp = ""; count = 0; if ( ! integerstack . empty ( ) ) { count = integerstack . top ( ); integerstack . pop ( ); } while ( ! stringstack . empty ( ) && stringstack . top ( ) != '[' ) { temp = stringstack . top ( ) + temp; stringstack . pop ( ); } if ( ! stringstack . empty ( ) && stringstack . top ( [MASK] == '[' ) stringstack . pop ( ); for ( int j = 0; j < count; j ++ ) result = result + temp; for ( int j = 0; j < strlen(result); j ++ ) stringstack . push ( result [ j ] ); result = ""; } else if ( str [ i ] == '[' ) { if ( str [ i - 1 ] >= '0' && str [ i - 1 ] <= '9' ) stringstack . push ( str [ i ] ); else { stringstack . push ( str [ i ] ); integerstack . push ( 1 ); } } else stringstack . push ( str [ i ] ); } while ( ! stringstack . empty ( ) ) { result = stringstack . top ( ) + result; stringstack . pop ( ); } return result; } char f_filled [] ( char str [] ) {} push ( str [ i ] );
}
while ( ! stringstack . empty ( ) ) {
result = stringstack . top ( ) + result;
stringstack . pop ( );
}
return result;
}
char f_filled [] ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"rpaBQkHqRaTb","9916267","000010100010","XfHXbWwaRd","750","0","K","0218044","10100010011","zR"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ) | [
"a) n;",
"b) 1",
"c) )",
"d) <",
"e) :"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n, int x ) {
int i = 0;
while ( i <= n - 1 ) {
if ( arr [ i ] == x ) return i;
i += abs ( arr [ i ] - x );
}
return - 1;
}
int f_filled ( int arr [ ], int n, int x ) {}
r [ ], int n, int x ) {
int i = 0;
while ( i <= n - 1 ) {
if ( arr [ i ] == x ) return i;
i += abs ( arr [ i ] - x );
}
return - 1;
}
int f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2};
int param0_1[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_2[] = {50,51,52,51,50,49,48};
int param0_3[] = {-86,-68,-32,-6,6,10,30,34,58,92};
int param0_4[] = {1,1,1,0,0,1,0,0,0,1,1,1,0,1,0,0,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,1,0,1,0,1,1,1,0,0};
int param0_5[] = {58};
int param0_6[] = {-64,78,58,36,48,80,-80,74,-98,46,-48,24,80,72,90,-46,14,68,38,58,-54,80,44,-62,34,-28,92,84,90,44,-26,88,18,22,-32,54,58,92};
int param0_7[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_8[] = {5};
int *param0[9] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8};
int param1[] = {8,8,15,7,6,27,0,24,35,0};
int param2[] = {6,3,1,49,6,22,0,34,1,0};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n, int x ) { int i = 0; while ( i <= n - 1 ) { if ( arr [ i ] == x ) return i; i += abs ( arr [ i ] - x ); } return - 1; } int f_filled ( int arr [ [MASK] int n, int x ) {}r [ ], int n, int x ) {
int i = 0;
while ( i <= n - 1 ) {
if ( arr [ i ] == x ) return i;
i += abs ( arr [ i ] - x );
}
return - 1;
}
int f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2};
int param0_1[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_2[] = {50,51,52,51,50,49,48};
int param0_3[] = {-86,-68,-32,-6,6,10,30,34,58,92};
int param0_4[] = {1,1,1,0,0,1,0,0,0,1,1,1,0,1,0,0,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,1,0,1,0,1,1,1,0,0};
int param0_5[] = {58};
int param0_6[] = {-64,78,58,36,48,80,-80,74,-98,46,-48,24,80,72,90,-46,14,68,38,58,-54,80,44,-62,34,-28,92,84,90,44,-26,88,18,22,-32,54,58,92};
int param0_7[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_8[] = {5};
int *param0[9] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8};
int param1[] = {8,8,15,7,6,27,0,24,35,0};
int param2[] = {6,3,1,49,6,22,0,34,1,0};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ], | [
"a) 2",
"b) ],",
"c) )",
"d) <vector>",
"e) y;"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
if ( n == 0 || n == 1 ) return n;
int f1 = 0, f2 = 1, f3 = 1;
while ( f3 <= n ) {
f1 = f2;
f2 = f3;
f3 = f1 + f2;
}
return f2;
}
int f_filled ( int n ) {}
f_gold ( int n ) {
if ( n == 0 || n == 1 ) return n;
int f1 = 0, f2 = 1, f3 = 1;
while ( f3 <= n ) {
f1 = f2;
f2 = f3;
f3 = f1 + f2;
}
return f2;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {54,71,64,71,96,43,70,94,95,69};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - [MASK] );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { if ( n == 0 || n == 1 ) return n; int f1 = 0, f2 = 1, f3 = 1; while ( f3 <= n ) { f1 = f2; f2 = f3; f3 = f1 + f2; } return f2; } int f_filled ( int n ) {}f_gold ( int n ) {
if ( n == 0 || n == 1 ) return n;
int f1 = 0, f2 = 1, f3 = 1;
while ( f3 <= n ) {
f1 = f2;
f2 = f3;
f3 = f1 + f2;
}
return f2;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {54,71,64,71,96,43,70,94,95,69};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | *(int*)b | [
"a) 1",
"b) #include",
"c) ,",
"d) (",
"e) *(int*)b"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b ) {
long long result = 0, rem = 0;
if ( a < b ) swap ( a, b );
while ( b > 0 ) {
result += a / b;
long long rem = a % b;
a = b;
b = rem;
}
return result;
}
int f_filled ( int a, int b ) {}
ult = 0, rem = 0;
if ( a < b ) swap ( a, b );
while ( b > 0 ) {
result += a / b;
long long rem = a % b;
a = b;
b = rem;
}
return result;
}
int f_filled ( int a, int b ) {}
int main(void) {
int n_success = 0;
int param0[] = {87,18,68,80,87,64,64,65,43,97};
int param1[] = {60,35,93,20,69,29,1,95,72,41};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a, int b ) { long long result = 0, rem [MASK] 0; if ( a < b ) swap ( a, b ); while ( b > 0 ) { result += a / b; long long rem = a % b; a = b; b = rem; } return result; } int f_filled ( int a, int b ) {}ult = 0, rem = 0;
if ( a < b ) swap ( a, b );
while ( b > 0 ) {
result += a / b;
long long rem = a % b;
a = b;
b = rem;
}
return result;
}
int f_filled ( int a, int b ) {}
int main(void) {
int n_success = 0;
int param0[] = {87,18,68,80,87,64,64,65,43,97};
int param1[] = {60,35,93,20,69,29,1,95,72,41};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | = | [
"a) [",
"b) =",
"c) x",
"d) n",
"e) ++"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char str [] ) {
int len = strlen(str);
int open [ len + 1 ], close [ len + 1 ];
int index = - 1;
memset ( open, 0, sizeof ( open ) );
memset ( close, 0, sizeof ( close ) );
open [ 0 ] = 0;
close [ len ] = 0;
if ( str [ 0 ] == '(' ) open [ 1 ] = 1;
if ( str [ len - 1 ] == ')' ) close [ len - 1 ] = 1;
for ( int i = 1;
i < len;
i ++ ) {
if ( str [ i ] == '(' ) open [ i + 1 ] = open [ i ] + 1;
else open [ i + 1 ] = open [ i ];
}
for ( int i = len - 2;
i >= 0;
i -- ) {
if ( str [ i ] == ')' ) close [ i ] = close [ i + 1 ] + 1;
else close [ i ] = close [ i + 1 ];
}
if ( open [ len ] == 0 ) return len;
if ( close [ 0 ] == 0 ) return 0;
for ( int i = 0;
i <= len;
i ++ ) if ( open [ i ] == close [ i ] ) index = i;
return index;
}
int f_filled ( char str [] ) {}
len ] == 0 ) return len;
if ( close [ 0 ] == 0 ) return 0;
for ( int i = 0;
i <= len;
i ++ ) if ( open [ i ] == close [ i ] ) index = i;
return index;
}
int f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"(())))(","))","((","))(()(()()(",")((()(()","))(()","()))","()","1100110","dhfSnebD"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char str [] ) { int len = strlen(str); int open [ len + 1 ], close [ len + 1 ]; int index = - 1; memset ( open, 0, sizeof ( open ) ); memset ( close, 0, sizeof ( close ) ); open [ 0 ] = 0; close [ len ] = 0; if ( str [ 0 ] == '(' ) open [ 1 ] = 1; if ( str [ len - 1 ] == ')' ) close [ len - 1 ] = 1; for ( int i = 1; i < len; i ++ ) { if ( str [ i ] == '(' ) open [ i + 1 ] = open [ i ] + 1; else open [ i + 1 ] = open [ i ]; } [MASK] ( int i = len - 2; i >= 0; i -- ) { if ( str [ i ] == ')' ) close [ i ] = close [ i + 1 ] + 1; else close [ i ] = close [ i + 1 ]; } if ( open [ len ] == 0 ) return len; if ( close [ 0 ] == 0 ) return 0; for ( int i = 0; i <= len; i ++ ) if ( open [ i ] == close [ i ] ) index = i; return index; } int f_filled ( char str [] ) {} len ] == 0 ) return len;
if ( close [ 0 ] == 0 ) return 0;
for ( int i = 0;
i <= len;
i ++ ) if ( open [ i ] == close [ i ] ) index = i;
return index;
}
int f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"(())))(","))","((","))(()(()()(",")((()(()","))(()","()))","()","1100110","dhfSnebD"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | for | [
"a) for",
"b) return",
"c) int",
"d) positive",
"e) str1"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
double f_gold ( int n ) {
return ( 3.0 * n ) / ( 4.0 * ( n * n ) - 1 );
}
double f_filled ( int n ) {}
izeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
double f_gold ( int n ) {
return ( 3.0 * n ) / ( 4.0 * ( n * n ) - 1 );
}
double f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {46,5,44,15,72,2,86,17,30,42};
for(int i = 0; i < len(param0); ++i)
{
if(abs(1 - (0.0000001 + abs(f_gold(param0[i])) )/ (abs(f_filled(param0[i])) + 0.0000001)) < 0.001)
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> [MASK] <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} double f_gold ( int n ) { return ( 3.0 * n ) / ( 4.0 * ( n * n ) - 1 ); } double f_filled ( int n ) {}izeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
double f_gold ( int n ) {
return ( 3.0 * n ) / ( 4.0 * ( n * n ) - 1 );
}
double f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {46,5,44,15,72,2,86,17,30,42};
for(int i = 0; i < len(param0); ++i)
{
if(abs(1 - (0.0000001 + abs(f_gold(param0[i])) )/ (abs(f_filled(param0[i])) + 0.0000001)) < 0.001)
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include | [
"a) #include",
"b) dp",
"c) )",
"d) ],",
"e) ("
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( char str [] ) {
vector < char > list;
for ( int i = 0;
i < strlen(str);
i ++ ) {
auto pos = find ( list . begin ( ), list . end ( ), str [ i ] );
if ( pos != list . end ( ) ) {
auto posi = find ( list . begin ( ), list . end ( ), str [ i ] );
list . erase ( posi );
}
else list . push_back ( str [ i ] );
}
if ( strlen(str) % 2 == 0 && list . empty ( ) || ( strlen(str) % 2 == 1 && len(list) == 1 ) ) return true;
else return false;
}
bool f_filled ( char str [] ) {}
. push_back ( str [ i ] );
}
if ( strlen(str) % 2 == 0 && list . empty ( ) || ( strlen(str) % 2 == 1 && len(list) == 1 ) ) return true;
else return false;
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"abccba","2674377254","11","abcdecba","26382426486138","111010111010","hUInqJXNdbfP","5191","1110101101","NupSrU xz"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( char str [] ) { vector < char > list; for ( int i = 0; i < strlen(str); i ++ ) { auto pos = find ( list . begin ( ), list . end ( ), str [ i ] ); if ( pos != list . end ( ) ) { auto posi = find ( list . begin ( ), list . end ( ), str [ i ] ); list . erase ( posi ); } else list . push_back ( str [ i [MASK] ); } if ( strlen(str) % 2 == 0 && list . empty ( ) || ( strlen(str) % 2 == 1 && len(list) == 1 ) ) return true; else return false; } bool f_filled ( char str [] ) {}. push_back ( str [ i ] );
}
if ( strlen(str) % 2 == 0 && list . empty ( ) || ( strlen(str) % 2 == 1 && len(list) == 1 ) ) return true;
else return false;
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"abccba","2674377254","11","abcdecba","26382426486138","111010111010","hUInqJXNdbfP","5191","1110101101","NupSrU xz"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ] | [
"a) arr",
"b) while",
"c) 10",
"d) ]",
"e) x"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int n ) {
return ( n % 15 == 0 );
}
bool f_filled ( int n ) {}
n ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int n ) {
return ( n % 15 == 0 );
}
bool f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {30,-30,60,90,99,32,21,65,21,99};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, [MASK] void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int n ) { return ( n % 15 == 0 ); } bool f_filled ( int n ) {}n ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int n ) {
return ( n % 15 == 0 );
}
bool f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {30,-30,60,90,99,32,21,65,21,99};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | const | [
"a) 0",
"b) const",
"c) 1",
"d) [",
"e) ("
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int m, int x [ ], int revenue [ ], int n, int t ) {
int maxRev [ m + 1 ];
memset ( maxRev, 0, sizeof ( maxRev ) );
int nxtbb = 0;
for ( int i = 1;
i <= m;
i ++ ) {
if ( nxtbb < n ) {
if ( x [ nxtbb ] != i ) maxRev [ i ] = maxRev [ i - 1 ];
else {
if ( i <= t ) maxRev [ i ] = max ( maxRev [ i - 1 ], revenue [ nxtbb ] );
else maxRev [ i ] = max ( maxRev [ i - t - 1 ] + revenue [ nxtbb ], maxRev [ i - 1 ] );
nxtbb ++;
}
}
else maxRev [ i ] = maxRev [ i - 1 ];
}
return maxRev [ m ];
}
int f_filled ( int m, int x [ ], int revenue [ ], int n, int t ) {}
b ], maxRev [ i - 1 ] );
nxtbb ++;
}
}
else maxRev [ i ] = maxRev [ i - 1 ];
}
return maxRev [ m ];
}
int f_filled ( int m, int x [ ], int revenue [ ], int n, int t ) {}
int main(void) {
int n_success = 0;
int param0[] = {16,39,5,10,14,32,2,22,15,8};
int param1_0[] = {6,15,15,18,23,29,32,36,37,39,40,41,44,49,51,52,53,57,66,68,82,89,96};
int param1_1[] = {76,60,88,46,-20,-78,-22,54,-18,92,-42,-66,-90,-72,-48,22,-72,-42,-46,94,82,-78,14,86,10,-64,-78,66,78,-36,50,-20,-40,-12,10,-46,56,-18,4,-76,-64,74,22,34,4,-2};
int param1_2[] = {0,0,0,1,1,1,1,1,1,1};
int param1_3[] = {21,69,30,10,71,72,71,78,30,9,72,10,7,87,30,46,56,74,73,60,86};
int param1_4[] = {-76,-76,-66,-64,-62,-60,-52,-48,-42,-28,-14,-6,-6,16,20,20,38,46,58,60,70,72,86,98};
int param1_5[] = {1,1,0,0,0,0,0,0,1,1,1,1,1,0,1,0,0,0,1,0,0,1,1,0,0,1,1,1,0,1,0,1,1,0,1,0,1};
int param1_6[] = {16,38,72,82};
int param1_7[] = {28,-76,42,-2,30,-10,52,66,26,96,96,-72,26,-86,-30,-78,32,-32,58,12,-72,8,34,-68,-28,-66};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {95,12,65,97,92,49,94,32,37,97,9,35};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2_0[] = {1,2,5,5,24,26,31,32,33,41,57,59,71,75,79,87,87,88,92,94,96,96,99};
int param2_1[] = {28,8,-60,84,68,-54,-56,0,-68,-84,-6,92,-80,-24,86,-6,-44,82,74,90,-46,40,62,50,-42,38,78,94,46,-14,-48,66,70,52,10,-88,54,-10,98,34,16,-2,-62,-56,-40,86};
int param2_2[] = {0,0,0,0,0,0,0,1,1,1};
int param2_3[] = {72,45,7,30,76,35,75,72,4,7,55,56,7,52,48,27,11,76,66,48,33};
int param2_4[] = {-90,-82,-78,-76,-74,-52,-48,-44,-44,-40,-38,-14,-6,10,20,38,38,40,44,48,52,54,76,78};
int param2_5[] = {0,1,0,1,0,0,0,1,0,0,0,1,0,1,1,0,1,1,0,1,1,0,1,0,0,1,0,1,0,1,0,1,1,0,1,0,1};
int param2_6[] = {15,34,56,74};
int param2_7[] = {68,-38,34,20,40,78,52,80,58,-12,-18,10,40,34,20,-32,-8,-46,8,62,94,-30,-94,26,-40,64};
int param2_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param2_9[] = {25,32,14,49,90,37,92,1,8,75,50,9};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {12,25,9,18,15,28,2,13,25,9};
int param4[] = {12,27,6,20,17,36,3,16,15,8};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i],param4[i]) == f_gold(param0[i],param1[i],param2[i],param3[i],param4[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int m, int x [ ], int revenue [ ], int n, int t ) { int maxRev [ m + 1 ]; memset ( maxRev, 0, sizeof ( maxRev ) ); int nxtbb = 0; for ( int i = 1; i <= m; i ++ ) { if ( nxtbb < n ) { if ( x [ nxtbb ] != i ) maxRev [ i ] = maxRev [ i - 1 ]; else { [MASK] ( i <= t ) maxRev [ i ] = max ( maxRev [ i - 1 ], revenue [ nxtbb ] ); else maxRev [ i ] = max ( maxRev [ i - t - 1 ] + revenue [ nxtbb ], maxRev [ i - 1 ] ); nxtbb ++; } } else maxRev [ i ] = maxRev [ i - 1 ]; } return maxRev [ m ]; } int f_filled ( int m, int x [ ], int revenue [ ], int n, int t ) {}b ], maxRev [ i - 1 ] );
nxtbb ++;
}
}
else maxRev [ i ] = maxRev [ i - 1 ];
}
return maxRev [ m ];
}
int f_filled ( int m, int x [ ], int revenue [ ], int n, int t ) {}
int main(void) {
int n_success = 0;
int param0[] = {16,39,5,10,14,32,2,22,15,8};
int param1_0[] = {6,15,15,18,23,29,32,36,37,39,40,41,44,49,51,52,53,57,66,68,82,89,96};
int param1_1[] = {76,60,88,46,-20,-78,-22,54,-18,92,-42,-66,-90,-72,-48,22,-72,-42,-46,94,82,-78,14,86,10,-64,-78,66,78,-36,50,-20,-40,-12,10,-46,56,-18,4,-76,-64,74,22,34,4,-2};
int param1_2[] = {0,0,0,1,1,1,1,1,1,1};
int param1_3[] = {21,69,30,10,71,72,71,78,30,9,72,10,7,87,30,46,56,74,73,60,86};
int param1_4[] = {-76,-76,-66,-64,-62,-60,-52,-48,-42,-28,-14,-6,-6,16,20,20,38,46,58,60,70,72,86,98};
int param1_5[] = {1,1,0,0,0,0,0,0,1,1,1,1,1,0,1,0,0,0,1,0,0,1,1,0,0,1,1,1,0,1,0,1,1,0,1,0,1};
int param1_6[] = {16,38,72,82};
int param1_7[] = {28,-76,42,-2,30,-10,52,66,26,96,96,-72,26,-86,-30,-78,32,-32,58,12,-72,8,34,-68,-28,-66};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {95,12,65,97,92,49,94,32,37,97,9,35};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2_0[] = {1,2,5,5,24,26,31,32,33,41,57,59,71,75,79,87,87,88,92,94,96,96,99};
int param2_1[] = {28,8,-60,84,68,-54,-56,0,-68,-84,-6,92,-80,-24,86,-6,-44,82,74,90,-46,40,62,50,-42,38,78,94,46,-14,-48,66,70,52,10,-88,54,-10,98,34,16,-2,-62,-56,-40,86};
int param2_2[] = {0,0,0,0,0,0,0,1,1,1};
int param2_3[] = {72,45,7,30,76,35,75,72,4,7,55,56,7,52,48,27,11,76,66,48,33};
int param2_4[] = {-90,-82,-78,-76,-74,-52,-48,-44,-44,-40,-38,-14,-6,10,20,38,38,40,44,48,52,54,76,78};
int param2_5[] = {0,1,0,1,0,0,0,1,0,0,0,1,0,1,1,0,1,1,0,1,1,0,1,0,0,1,0,1,0,1,0,1,1,0,1,0,1};
int param2_6[] = {15,34,56,74};
int param2_7[] = {68,-38,34,20,40,78,52,80,58,-12,-18,10,40,34,20,-32,-8,-46,8,62,94,-30,-94,26,-40,64};
int param2_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param2_9[] = {25,32,14,49,90,37,92,1,8,75,50,9};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {12,25,9,18,15,28,2,13,25,9};
int param4[] = {12,27,6,20,17,36,3,16,15,8};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i],param4[i]) == f_gold(param0[i],param1[i],param2[i],param3[i],param4[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | if | [
"a) ];",
"b) 1",
"c) b",
"d) if",
"e) sum"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int b [ ], int n, int m ) {
unordered_map < int, int > countA, countB;
for ( int i = 0;
i < n;
i ++ ) countA [ a [ i ] ] ++;
for ( int i = 0;
i < m;
i ++ ) countB [ b [ i ] ] ++;
int res = 0;
for ( auto x : countA ) if ( countB . find ( x . first ) != countB . end ( ) ) res += min ( x . second, countB [ x . first ] );
return res;
}
int f_filled ( int a [ ], int b [ ], int n, int m ) {}
( auto x : countA ) if ( countB . find ( x . first ) != countB . end ( ) ) res += min ( x . second, countB [ x . first ] );
return res;
}
int f_filled ( int a [ ], int b [ ], int n, int m ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,7,10,12,12,24,29,38,45,51,53,54,59,68,72,73,85,86,88,92,92,95};
int param0_1[] = {-6,48,-70,14,-86,56,80,-64,64,-88,-14,78,14,-18,52,2,22,88};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1};
int param0_3[] = {10,93,2,16,36,49,36,86,6,99,95,2};
int param0_4[] = {-98,-96,-80,-64,-42,-30,-6,10,62,66,82};
int param0_5[] = {1,1,0,1,1};
int param0_6[] = {7,11,13,15,21,33,36,39,66,99};
int param0_7[] = {-40};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {79,91,31,16,28,45,37,43,73,73,76,28,71,60,64,60,99,36,47,38,65,34,22,94,84,51,72,45,71,2};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1_0[] = {7,9,17,23,25,26,29,32,35,56,56,58,59,59,62,63,72,82,85,86,95,97};
int param1_1[] = {-62,-58,60,-30,42,8,66,-48,-18,64,-76,-90,-48,-90,-24,64,-88,-98};
int param1_2[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param1_3[] = {99,28,7,21,62,89,82,41,43,77,8,14};
int param1_4[] = {-62,-50,-42,24,44,46,52,54,60,72,72};
int param1_5[] = {1,1,1,0,0};
int param1_6[] = {23,36,42,44,62,65,70,78,82,89};
int param1_7[] = {-98};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {58,94,12,27,98,38,75,20,94,43,32,90,23,41,88,2,62,96,53,57,48,79,6,16,11,46,73,57,67,7};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2[] = {15,15,10,6,9,4,9,0,31,18};
int param3[] = {13,9,10,10,6,2,9,0,26,18};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold [MASK] int a [ ], int b [ ], int n, int m ) { unordered_map < int, int > countA, countB; for ( int i = 0; i < n; i ++ ) countA [ a [ i ] ] ++; for ( int i = 0; i < m; i ++ ) countB [ b [ i ] ] ++; int res = 0; for ( auto x : countA ) if ( countB . find ( x . first ) != countB . end ( ) ) res += min ( x . second, countB [ x . first ] ); return res; } int f_filled ( int a [ ], int b [ ], int n, int m ) {} ( auto x : countA ) if ( countB . find ( x . first ) != countB . end ( ) ) res += min ( x . second, countB [ x . first ] );
return res;
}
int f_filled ( int a [ ], int b [ ], int n, int m ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,7,10,12,12,24,29,38,45,51,53,54,59,68,72,73,85,86,88,92,92,95};
int param0_1[] = {-6,48,-70,14,-86,56,80,-64,64,-88,-14,78,14,-18,52,2,22,88};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1};
int param0_3[] = {10,93,2,16,36,49,36,86,6,99,95,2};
int param0_4[] = {-98,-96,-80,-64,-42,-30,-6,10,62,66,82};
int param0_5[] = {1,1,0,1,1};
int param0_6[] = {7,11,13,15,21,33,36,39,66,99};
int param0_7[] = {-40};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {79,91,31,16,28,45,37,43,73,73,76,28,71,60,64,60,99,36,47,38,65,34,22,94,84,51,72,45,71,2};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1_0[] = {7,9,17,23,25,26,29,32,35,56,56,58,59,59,62,63,72,82,85,86,95,97};
int param1_1[] = {-62,-58,60,-30,42,8,66,-48,-18,64,-76,-90,-48,-90,-24,64,-88,-98};
int param1_2[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param1_3[] = {99,28,7,21,62,89,82,41,43,77,8,14};
int param1_4[] = {-62,-50,-42,24,44,46,52,54,60,72,72};
int param1_5[] = {1,1,1,0,0};
int param1_6[] = {23,36,42,44,62,65,70,78,82,89};
int param1_7[] = {-98};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {58,94,12,27,98,38,75,20,94,43,32,90,23,41,88,2,62,96,53,57,48,79,6,16,11,46,73,57,67,7};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2[] = {15,15,10,6,9,4,9,0,31,18};
int param3[] = {13,9,10,10,6,2,9,0,26,18};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ( | [
"a) j",
"b) (",
"c) n",
"d) int",
"e) )"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int low, int high, int x ) {
if ( low > high ) return - 1;
if ( x >= arr [ high ] ) return high;
int mid = ( low + high ) / 2;
if ( arr [ mid ] == x ) return mid;
if ( mid > 0 && arr [ mid - 1 ] <= x && x < arr [ mid ] ) return mid - 1;
if ( x < arr [ mid ] ) return f_gold ( arr, low, mid - 1, x );
return f_gold ( arr, mid + 1, high, x );
}
int f_filled ( int arr [ ], int low, int high, int x ) {}
r [ mid ] ) return mid - 1;
if ( x < arr [ mid ] ) return f_gold ( arr, low, mid - 1, x );
return f_gold ( arr, mid + 1, high, x );
}
int f_filled ( int arr [ ], int low, int high, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {5,11,20,42,42,55,58,98,99};
int param0_1[] = {50,-90,-38,-46,-10,-22,-66,72,-52,38,90,34,-12,-44,-6,0,-20,-38,86,26,64,-24,40,90,-26,-2,-28,12,22,-14};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_3[] = {69,28,68,98,24,67,86,2,18,22,44,77,52,62,24,46};
int param0_4[] = {-96,-94,-88,-84,-68,-60,-52,-52,-42,-34,-32,-16,-12,-6,-6,-4,-2,0,16,18,38,58,70,72,76,78,90,92,98};
int param0_5[] = {0,1,1,0,0,1,0,1,1,1,0,0,0,0,1,0,1,1,1,1,1,1,0,0,1,0,0};
int param0_6[] = {1,6,7,9,10,11,19,19,22,22,26,34,36,37,37,38,39,40,49,54,60,62,65,67,71,76,78,79,82,82,89,95,97};
int param0_7[] = {76,-32,-98,-18,-80,74,-22,-82,40,-64,58,-18,-64,34,-44,-82,-46,62,-80,-76,32,44,-32,98,-26,62,16,86,-52,-72,-90,-30,6};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {81,69,15,52,49,54,18,92,33,21,91,21,5,25,77,92,26,58,72,55,76,18,13,59,9,12,31,24,36,33,71,87,55,19,42,25};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {5,26,11,15,22,24,22,28,28,35};
int param2[] = {7,28,9,11,27,15,26,31,29,19};
int param3[] = {6,23,18,13,20,26,25,24,30,33};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int low, int high, int x ) { if ( low > high ) return - 1; if ( x >= arr [ high ] ) return high; int mid = ( low + high ) / 2; if ( arr [ mid ] == x ) return mid; if ( mid > 0 && arr [ mid - 1 ] <= x && x < arr [ mid ] ) return mid - 1; if ( x < arr [ mid ] ) [MASK] f_gold ( arr, low, mid - 1, x ); return f_gold ( arr, mid + 1, high, x ); } int f_filled ( int arr [ ], int low, int high, int x ) {}r [ mid ] ) return mid - 1;
if ( x < arr [ mid ] ) return f_gold ( arr, low, mid - 1, x );
return f_gold ( arr, mid + 1, high, x );
}
int f_filled ( int arr [ ], int low, int high, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {5,11,20,42,42,55,58,98,99};
int param0_1[] = {50,-90,-38,-46,-10,-22,-66,72,-52,38,90,34,-12,-44,-6,0,-20,-38,86,26,64,-24,40,90,-26,-2,-28,12,22,-14};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_3[] = {69,28,68,98,24,67,86,2,18,22,44,77,52,62,24,46};
int param0_4[] = {-96,-94,-88,-84,-68,-60,-52,-52,-42,-34,-32,-16,-12,-6,-6,-4,-2,0,16,18,38,58,70,72,76,78,90,92,98};
int param0_5[] = {0,1,1,0,0,1,0,1,1,1,0,0,0,0,1,0,1,1,1,1,1,1,0,0,1,0,0};
int param0_6[] = {1,6,7,9,10,11,19,19,22,22,26,34,36,37,37,38,39,40,49,54,60,62,65,67,71,76,78,79,82,82,89,95,97};
int param0_7[] = {76,-32,-98,-18,-80,74,-22,-82,40,-64,58,-18,-64,34,-44,-82,-46,62,-80,-76,32,44,-32,98,-26,62,16,86,-52,-72,-90,-30,6};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {81,69,15,52,49,54,18,92,33,21,91,21,5,25,77,92,26,58,72,55,76,18,13,59,9,12,31,24,36,33,71,87,55,19,42,25};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {5,26,11,15,22,24,22,28,28,35};
int param2[] = {7,28,9,11,27,15,26,31,29,19};
int param3[] = {6,23,18,13,20,26,25,24,30,33};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | return | [
"a) ]",
"b) return",
"c) )",
"d) def",
"e) +"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
unsigned int f_gold ( unsigned int n ) {
unsigned count = 0;
if ( n && ! ( n & ( n - 1 ) ) ) return n;
while ( n != 0 ) {
n >>= 1;
count += 1;
}
return 1 << count;
}
unsigned int f_filled ( unsigned int n ) {}
nt n ) {
unsigned count = 0;
if ( n && ! ( n & ( n - 1 ) ) ) return n;
while ( n != 0 ) {
n >>= 1;
count += 1;
}
return 1 << count;
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {13,27,1,24,98,94,36,41,74,39};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x [MASK] y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} unsigned int f_gold ( unsigned int n ) { unsigned count = 0; if ( n && ! ( n & ( n - 1 ) ) ) return n; while ( n != 0 ) { n >>= 1; count += 1; } return 1 << count; } unsigned int f_filled ( unsigned int n ) {}nt n ) {
unsigned count = 0;
if ( n && ! ( n & ( n - 1 ) ) ) return n;
while ( n != 0 ) {
n >>= 1;
count += 1;
}
return 1 << count;
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {13,27,1,24,98,94,36,41,74,39};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | > | [
"a) ;",
"b) )",
"c) int",
"d) >",
"e) class"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int low, int high ) {
if ( high >= low ) {
int mid = ( low + high ) / 2;
if ( mid == arr [ mid ] ) return mid;
if ( mid > arr [ mid ] ) return f_gold ( arr, ( mid + 1 ), high );
else return f_gold ( arr, low, ( mid - 1 ) );
}
return - 1;
}
int f_filled ( int arr [ ], int low, int high ) {}
id;
if ( mid > arr [ mid ] ) return f_gold ( arr, ( mid + 1 ), high );
else return f_gold ( arr, low, ( mid - 1 ) );
}
return - 1;
}
int f_filled ( int arr [ ], int low, int high ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9};
int param0_1[] = {1,1,0,1,1,0,1,0,0};
int param0_2[] = {1,4,16,16,19,28,34,34,35,36,37,46,49,52,54,60,60,60,63,70,75,77,80,81,81,84,85,87,93,99};
int param0_3[] = {30,30,-94,-10,2,58};
int param0_4[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_5[] = {72,38,91,63,30,67,39,29,96,42};
int *param0[6] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5};
int param1[] = {0,0,0,1,2,0,0,0,0,0};
int param2[] = {16,4,4,5,5,7,5,5,12,7};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, [MASK] cmpfunc);} int f_gold ( int arr [ ], int low, int high ) { if ( high >= low ) { int mid = ( low + high ) / 2; if ( mid == arr [ mid ] ) return mid; if ( mid > arr [ mid ] ) return f_gold ( arr, ( mid + 1 ), high ); else return f_gold ( arr, low, ( mid - 1 ) ); } return - 1; } int f_filled ( int arr [ ], int low, int high ) {}id;
if ( mid > arr [ mid ] ) return f_gold ( arr, ( mid + 1 ), high );
else return f_gold ( arr, low, ( mid - 1 ) );
}
return - 1;
}
int f_filled ( int arr [ ], int low, int high ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9};
int param0_1[] = {1,1,0,1,1,0,1,0,0};
int param0_2[] = {1,4,16,16,19,28,34,34,35,36,37,46,49,52,54,60,60,60,63,70,75,77,80,81,81,84,85,87,93,99};
int param0_3[] = {30,30,-94,-10,2,58};
int param0_4[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_5[] = {72,38,91,63,30,67,39,29,96,42};
int *param0[6] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5};
int param1[] = {0,0,0,1,2,0,0,0,0,0};
int param2[] = {16,4,4,5,5,7,5,5,12,7};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | sizeof(int), | [
"a) /",
"b) arr",
"c) sizeof(int),",
"d) .",
"e) <cstdlib>"
] | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.