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 arr [ ], int n, int k ) {
unordered_map < int, int > um;
int mod_arr [ n ], max = 0;
int curr_sum = 0;
for ( int i = 0;
i < n;
i ++ ) {
curr_sum += arr [ i ];
mod_arr [ i ] = ( ( curr_sum % k ) + k ) % k;
}
for ( int i = 0;
i < n;
i ++ ) {
if ( mod_arr [ i ] == 0 ) max = i + 1;
else if ( um . find ( mod_arr [ i ] ) == um . end ( ) ) um [ mod_arr [ i ] ] = i;
else if ( max < ( i - um [ mod_arr [ i ] ] ) ) max = i - um [ mod_arr [ i ] ];
}
return max;
}
int f_filled ( int arr [ ], int n, int k ) {}
) == um . end ( ) ) um [ mod_arr [ i ] ] = i;
else if ( max < ( i - um [ mod_arr [ i ] ] ) ) max = i - um [ mod_arr [ i ] ];
}
return max;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {14,16,17,17,31,32,34,35,37,38,39,46,47,52,57,58,60,61,69,75,76,77,81,88,97};
int param0_1[] = {-16,64,-62,-86,10,-40,52,50,-42,34,-32,-32,90,72,-96,-46,-6,92,14,98,-66,96,-48,-80,-22,-82,-50,-60,-70,82,-78,-68,88,-56,24,-52};
int param0_2[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_3[] = {33,1,92,27,17,46,79,78,95,34,3,56,12,26,24,60,58,63,98,8,76,73,26,58,38,49,43,59,83,21,13,99,3,89,32,21,14,95,8,7,99,83,59,2,69,44,66};
int param0_4[] = {-92,-76,-58,-56,-54,-20,-18,-16,-14,8,20,52,72,82,82,84};
int param0_5[] = {1,0,1,1,0,0,1,0,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,1,0,1,0,0,0,0};
int param0_6[] = {7,7,8,9,13,14,16,18,19,20,24,24,30,32,32,45,49,55,62,62,84,90,90,93,95,98};
int param0_7[] = {-28,-52,-84,-98,48,74,48,-34,-38,54};
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,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[] = {30,44,9,92,82,11,66,22,87,20};
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,35,13,40,15,34,22,7,28,9};
int param2[] = {23,21,13,37,15,26,14,8,37,9};
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 ) { unordered_map < int, int > um; int mod_arr [ n ], max = 0; int curr_sum = 0; for ( int i = 0; i < n; i ++ ) { [MASK] += arr [ i ]; mod_arr [ i ] = ( ( curr_sum % k ) + k ) % k; } for ( int i = 0; i < n; i ++ ) { if ( mod_arr [ i ] == 0 ) max = i + 1; else if ( um . find ( mod_arr [ i ] ) == um . end ( ) ) um [ mod_arr [ i ] ] = i; else if ( max < ( i - um [ mod_arr [ i ] ] ) ) max = i - um [ mod_arr [ i ] ]; } return max; } int f_filled ( int arr [ ], int n, int k ) {} ) == um . end ( ) ) um [ mod_arr [ i ] ] = i;
else if ( max < ( i - um [ mod_arr [ i ] ] ) ) max = i - um [ mod_arr [ i ] ];
}
return max;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {14,16,17,17,31,32,34,35,37,38,39,46,47,52,57,58,60,61,69,75,76,77,81,88,97};
int param0_1[] = {-16,64,-62,-86,10,-40,52,50,-42,34,-32,-32,90,72,-96,-46,-6,92,14,98,-66,96,-48,-80,-22,-82,-50,-60,-70,82,-78,-68,88,-56,24,-52};
int param0_2[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_3[] = {33,1,92,27,17,46,79,78,95,34,3,56,12,26,24,60,58,63,98,8,76,73,26,58,38,49,43,59,83,21,13,99,3,89,32,21,14,95,8,7,99,83,59,2,69,44,66};
int param0_4[] = {-92,-76,-58,-56,-54,-20,-18,-16,-14,8,20,52,72,82,82,84};
int param0_5[] = {1,0,1,1,0,0,1,0,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,1,0,1,0,0,0,0};
int param0_6[] = {7,7,8,9,13,14,16,18,19,20,24,24,30,32,32,45,49,55,62,62,84,90,90,93,95,98};
int param0_7[] = {-28,-52,-84,-98,48,74,48,-34,-38,54};
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,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[] = {30,44,9,92,82,11,66,22,87,20};
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,35,13,40,15,34,22,7,28,9};
int param2[] = {23,21,13,37,15,26,14,8,37,9};
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;
} | curr_sum | [
"a) ]",
"b) curr_sum",
"c) (int",
"d) fibo",
"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);}
float f_gold ( float x1, float y1, float x2, float y2 ) {
return ( y2 - y1 ) / ( x2 - x1 );
}
float f_filled ( float x1, float y1, float x2, float y2 ) {}
sort (arr, n, sizeof(int), cmpfunc);}
float f_gold ( float x1, float y1, float x2, float y2 ) {
return ( y2 - y1 ) / ( x2 - x1 );
}
float f_filled ( float x1, float y1, float x2, float y2 ) {}
int main(void) {
int n_success = 0;
float param0[] = {236.27324548309292F,-9201.144918204123F,3480.4716834445326F,-6915.538971485092F,8887.97173657486F,-3785.5177159369946F,3037.6696554256832F,-7925.458496016523F,1404.2919985268031F,-4748.744241168378F};
float param1[] = {5792.493225762838F,-2716.3347716140406F,3577.9608612055613F,-4113.601103381095F,1678.4080012662428F,-3084.67461899163F,4432.445827549F,-3350.27411882042F,8971.636233373416F,-675.557388148954F};
float param2[] = {7177.837879115863F,-5161.142121227645F,8611.515262945342F,-748.3462104020822F,8709.574949883017F,-7415.76208254121F,8387.304165588026F,-5619.767086756504F,3039.112051378511F,-5998.241086029875F};
float param3[] = {1289.5700425822731F,-3205.784279961129F,6744.864707668983F,-9245.271700539257F,8548.492675510739F,-887.5389305564152F,611.3373507518394F,-1185.7423219907591F,1947.6756252708972F,-4236.658178504375F};
for(int i = 0; i < len(param0); ++i)
{
if(abs(1 - (0.0000001 + abs(f_gold(param0[i],param1[i],param2[i],param3[i])) )/ (abs(f_filled(param0[i],param1[i],param2[i],param3[i])) + 0.0000001)) < 0.001F)
{
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 [MASK] void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} float f_gold ( float x1, float y1, float x2, float y2 ) { return ( y2 - y1 ) / ( x2 - x1 ); } float f_filled ( float x1, float y1, float x2, float y2 ) {}sort (arr, n, sizeof(int), cmpfunc);}
float f_gold ( float x1, float y1, float x2, float y2 ) {
return ( y2 - y1 ) / ( x2 - x1 );
}
float f_filled ( float x1, float y1, float x2, float y2 ) {}
int main(void) {
int n_success = 0;
float param0[] = {236.27324548309292F,-9201.144918204123F,3480.4716834445326F,-6915.538971485092F,8887.97173657486F,-3785.5177159369946F,3037.6696554256832F,-7925.458496016523F,1404.2919985268031F,-4748.744241168378F};
float param1[] = {5792.493225762838F,-2716.3347716140406F,3577.9608612055613F,-4113.601103381095F,1678.4080012662428F,-3084.67461899163F,4432.445827549F,-3350.27411882042F,8971.636233373416F,-675.557388148954F};
float param2[] = {7177.837879115863F,-5161.142121227645F,8611.515262945342F,-748.3462104020822F,8709.574949883017F,-7415.76208254121F,8387.304165588026F,-5619.767086756504F,3039.112051378511F,-5998.241086029875F};
float param3[] = {1289.5700425822731F,-3205.784279961129F,6744.864707668983F,-9245.271700539257F,8548.492675510739F,-887.5389305564152F,611.3373507518394F,-1185.7423219907591F,1947.6756252708972F,-4236.658178504375F};
for(int i = 0; i < len(param0); ++i)
{
if(abs(1 - (0.0000001 + abs(f_gold(param0[i],param1[i],param2[i],param3[i])) )/ (abs(f_filled(param0[i],param1[i],param2[i],param3[i])) + 0.0000001)) < 0.001F)
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | (arr)[0]));} | [
"a) ]",
"b) return",
"c) ]",
"d) <stdio.h>",
"e) (arr)[0]));}"
] | 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 str [] ) {
for ( int i = 0;
i < strlen(str);
i ++ ) if ( isupper ( str [ i ] ) ) return str [ i ];
return 0;
}
char f_filled ( char str [] ) {}
sizeof(int), cmpfunc);}
char f_gold ( char str [] ) {
for ( int i = 0;
i < strlen(str);
i ++ ) if ( isupper ( str [ i ] ) ) return str [ i ];
return 0;
}
char f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"pH","96544000","000010000","ujqpx","20684847994","111","rclkv","45173693434","11111011001101","f"};
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 [] ) { for ( int i = 0; i < strlen(str); i ++ ) if ( isupper ( str [ i ] ) ) return str [ i ]; return 0; } char [MASK] ( char str [] ) {}sizeof(int), cmpfunc);}
char f_gold ( char str [] ) {
for ( int i = 0;
i < strlen(str);
i ++ ) if ( isupper ( str [ i ] ) ) return str [ i ];
return 0;
}
char f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"pH","96544000","000010000","ujqpx","20684847994","111","rclkv","45173693434","11111011001101","f"};
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;
} | f_filled | [
"a) s",
"b) f_filled",
"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);}
bool f_gold ( int arr [ ], int n, int k ) {
unordered_map < int, int > hash;
for ( int i = 0;
i < n;
i ++ ) hash [ arr [ i ] ] ++;
for ( auto x : hash ) if ( x . second > 2 * k ) return false;
return true;
}
bool f_filled ( int arr [ ], int n, int k ) {}
> hash;
for ( int i = 0;
i < n;
i ++ ) hash [ arr [ i ] ] ++;
for ( auto x : hash ) if ( x . second > 2 * k ) return false;
return true;
}
bool f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,2,3,1};
int param0_1[] = {2,3,3,5,3,3};
int param0_2[] = {0,0,1,1,1};
int param0_3[] = {7,60,78,91,80,75,85,21,41,63,1,84,69,13,94,25,54,54,52,68,53,35,17,37,98,27,2,31};
int param0_4[] = {-96,-94,-82,-80,-78,-66,-36,-24,-18,-12,-2,-2,6,8,10,12,36,38,42,58,64,68,82,84,86,88,94};
int param0_5[] = {0,1,1,1,0,0,0,0,1,0,0,0,1,0,0,1,1,1,1,1,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,0,1,0,0,1,1,1,0};
int param0_6[] = {16,19,25,25,32,37,48,59,60,60,71,74,77,81,91,94};
int param0_7[] = {-62,-94,72,-22,86,-80,64,98,-82,-50,12,-4,56,46,-80,2,-86,-44,-26,68,-94,-82,74,26,94,40,50,-40,-42,-10};
int param0_8[] = {0,0,0,0,0,1,1,1};
int param0_9[] = {83,57,2,47,70,22,49,51,25,57,32,7,8,99,6,86,24,79,42,43,1,24,68,11,24,12,43,40,14,45,11,46,12,80,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[] = {5,6,2,24,24,34,10,20,5,21};
int param2[] = {2,2,1,2,3,2,8,4,2,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);} bool f_gold ( int arr [ ], int n, int k ) { unordered_map < int, int > hash; for ( int i = 0; i < n; i ++ ) hash [ arr [ i ] ] ++; for ( auto x : hash ) if ( x . second > 2 * k ) return [MASK] return true; } bool f_filled ( int arr [ ], int n, int k ) {}> hash;
for ( int i = 0;
i < n;
i ++ ) hash [ arr [ i ] ] ++;
for ( auto x : hash ) if ( x . second > 2 * k ) return false;
return true;
}
bool f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,2,3,1};
int param0_1[] = {2,3,3,5,3,3};
int param0_2[] = {0,0,1,1,1};
int param0_3[] = {7,60,78,91,80,75,85,21,41,63,1,84,69,13,94,25,54,54,52,68,53,35,17,37,98,27,2,31};
int param0_4[] = {-96,-94,-82,-80,-78,-66,-36,-24,-18,-12,-2,-2,6,8,10,12,36,38,42,58,64,68,82,84,86,88,94};
int param0_5[] = {0,1,1,1,0,0,0,0,1,0,0,0,1,0,0,1,1,1,1,1,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,0,1,0,0,1,1,1,0};
int param0_6[] = {16,19,25,25,32,37,48,59,60,60,71,74,77,81,91,94};
int param0_7[] = {-62,-94,72,-22,86,-80,64,98,-82,-50,12,-4,56,46,-80,2,-86,-44,-26,68,-94,-82,74,26,94,40,50,-40,-42,-10};
int param0_8[] = {0,0,0,0,0,1,1,1};
int param0_9[] = {83,57,2,47,70,22,49,51,25,57,32,7,8,99,6,86,24,79,42,43,1,24,68,11,24,12,43,40,14,45,11,46,12,80,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[] = {5,6,2,24,24,34,10,20,5,21};
int param2[] = {2,2,1,2,3,2,8,4,2,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;
} | false; | [
"a) if",
"b) b",
"c) math.pi",
"d) false;",
"e) n"
] | 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 str [] ) {
int N = strlen(str);
int dp [ N + 1 ] [ N + 1 ];
for ( int i = 0;
i <= N;
i ++ ) for ( int j = 0;
j <= N;
j ++ ) dp [ i ] [ j ] = 0;
for ( int len = 1;
len <= N;
len ++ ) {
for ( int i = 0, j = len - 1;
j < N;
i ++, j ++ ) {
if ( len == 1 ) dp [ i ] [ j ] = 1;
else {
dp [ i ] [ j ] = 1 + dp [ i + 1 ] [ j ];
if ( str [ i ] == str [ i + 1 ] ) dp [ i ] [ j ] = min ( 1 + dp [ i + 2 ] [ j ], dp [ i ] [ j ] );
for ( int K = i + 2;
K <= j;
K ++ ) if ( str [ i ] == str [ K ] ) dp [ i ] [ j ] = min ( dp [ i + 1 ] [ K - 1 ] + dp [ K + 1 ] [ j ], dp [ i ] [ j ] );
}
}
}
return dp [ 0 ] [ N - 1 ];
}
int f_filled ( char str [] ) {}
f ( str [ i ] == str [ K ] ) dp [ i ] [ j ] = min ( dp [ i + 1 ] [ K - 1 ] + dp [ K + 1 ] [ j ], dp [ i ] [ j ] );
}
}
}
return dp [ 0 ] [ N - 1 ];
}
int f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"YCtLQtHLwr","47713514383248","0100101001111","XfdIYVn","45499225407","000100111001","ZoUQhQwoap","18579027952","00000001111","JD"};
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] char str [] ) { int N = strlen(str); int dp [ N + 1 ] [ N + 1 ]; for ( int i = 0; i <= N; i ++ ) for ( int j = 0; j <= N; j ++ ) dp [ i ] [ j ] = 0; for ( int len = 1; len <= N; len ++ ) { for ( int i = 0, j = len - 1; j < N; i ++, j ++ ) { if ( len == 1 ) dp [ i ] [ j ] = 1; else { dp [ i ] [ j ] = 1 + dp [ i + 1 ] [ j ]; if ( str [ i ] == str [ i + 1 ] ) dp [ i ] [ j ] = min ( 1 + dp [ i + 2 ] [ j ], dp [ i ] [ j ] ); for ( int K = i + 2; K <= j; K ++ ) if ( str [ i ] == str [ K ] ) dp [ i ] [ j ] = min ( dp [ i + 1 ] [ K - 1 ] + dp [ K + 1 ] [ j ], dp [ i ] [ j ] ); } } } return dp [ 0 ] [ N - 1 ]; } int f_filled ( char str [] ) {}f ( str [ i ] == str [ K ] ) dp [ i ] [ j ] = min ( dp [ i + 1 ] [ K - 1 ] + dp [ K + 1 ] [ j ], dp [ i ] [ j ] );
}
}
}
return dp [ 0 ] [ N - 1 ];
}
int f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"YCtLQtHLwr","47713514383248","0100101001111","XfdIYVn","45499225407","000100111001","ZoUQhQwoap","18579027952","00000001111","JD"};
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) oneSeen",
"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 m, int n ) {
int dp [ n ] = {
1 };
dp [ 0 ] = 1;
for ( int i = 0;
i < m;
i ++ ) {
for ( int j = 1;
j < n;
j ++ ) {
dp [ j ] += dp [ j - 1 ];
}
}
return dp [ n - 1 ];
}
int f_filled ( int m, int n ) {}
t i = 0;
i < m;
i ++ ) {
for ( int j = 1;
j < n;
j ++ ) {
dp [ j ] += dp [ j - 1 ];
}
}
return dp [ n - 1 ];
}
int f_filled ( int m, int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {73,70,53,80,9,38,41,80,42,54};
int param1[] = {75,5,62,70,59,48,49,72,52,1};
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 [MASK] { 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 dp [ n ] = { 1 }; dp [ 0 ] = 1; for ( int i = 0; i < m; i ++ ) { for ( int j = 1; j < n; j ++ ) { dp [ j ] += dp [ j - 1 ]; } } return dp [ n - 1 ]; } int f_filled ( int m, int n ) {}t i = 0;
i < m;
i ++ ) {
for ( int j = 1;
j < n;
j ++ ) {
dp [ j ] += dp [ j - 1 ];
}
}
return dp [ n - 1 ];
}
int f_filled ( int m, int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {73,70,53,80,9,38,41,80,42,54};
int param1[] = {75,5,62,70,59,48,49,72,52,1};
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) y)",
"b) <vector>",
"c) )",
"d) /",
"e) class"
] | 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 ) {
sort ( arr, arr + n );
int max_count = 1, res = arr [ 0 ], curr_count = 1;
for ( int i = 1;
i < n;
i ++ ) {
if ( arr [ i ] == arr [ i - 1 ] ) curr_count ++;
else {
if ( curr_count > max_count ) {
max_count = curr_count;
res = arr [ i - 1 ];
}
curr_count = 1;
}
}
if ( curr_count > max_count ) {
max_count = curr_count;
res = arr [ n - 1 ];
}
return res;
}
int f_filled ( int arr [ ], int n ) {}
i - 1 ];
}
curr_count = 1;
}
}
if ( curr_count > max_count ) {
max_count = curr_count;
res = arr [ n - 1 ];
}
return res;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,3,11,11,11,18,20,26,26,27,30,33,39,39,42,42,48,51,51,51,51,60,66,66,68,68,69,71,72,73,76,76,77,77,77,78,90,96};
int param0_1[] = {46,-8,64,-46,-38,92,-14,-22,-32,48,72,96,30,66,94,36,42,-18,14,-74,80,96,-4};
int param0_2[] = {0,0,0,0,0,0,1};
int param0_3[] = {93,32,3,31,67,96,52,80,70,49,45,23,58,87,31,56,21,71,55,97};
int param0_4[] = {-98,-96,-84,-82,-72,-64,-62,-56,-52,-52,-48,-46,-42,-36,-32,-30,-30,-18,-16,-10,-2,0,6,18,22,22,40,42,50,54,64,68,68,72,80,82,84,96};
int param0_5[] = {1,1,0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,0,0,1,0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,1,0};
int param0_6[] = {9,12,13,28,43,46,64,66,68,89,92};
int param0_7[] = {22,-8,-56,68,-12,-26,-40,-46,-42,-80,4,-42,-72,-22,36,22,-94,48,96,80,-52,46,90,94,36,92,-12,-24,-60,-32,92,18,76,40,-32,6,-22,86,86,-88,38,50,32,78,-82,54,-40,18};
int param0_8[] = {0,0,0,0,0,0,1,1,1};
int param0_9[] = {81,74,32,41,85,65,81,74,40,64,97,4,61,43,54,96,62,2,97,86,80,25,9,31,16,29,4,63,76,41,5,95};
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,18,6,15,20,29,6,41,4,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 ) { sort ( arr, arr + n ); int max_count = 1, res = arr [ 0 ], curr_count = 1; for ( int i = 1; i < n; i ++ ) { if ( arr [ i ] == arr [MASK] i - 1 ] ) curr_count ++; else { if ( curr_count > max_count ) { max_count = curr_count; res = arr [ i - 1 ]; } curr_count = 1; } } if ( curr_count > max_count ) { max_count = curr_count; res = arr [ n - 1 ]; } return res; } int f_filled ( int arr [ ], int n ) {} i - 1 ];
}
curr_count = 1;
}
}
if ( curr_count > max_count ) {
max_count = curr_count;
res = arr [ n - 1 ];
}
return res;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,3,11,11,11,18,20,26,26,27,30,33,39,39,42,42,48,51,51,51,51,60,66,66,68,68,69,71,72,73,76,76,77,77,77,78,90,96};
int param0_1[] = {46,-8,64,-46,-38,92,-14,-22,-32,48,72,96,30,66,94,36,42,-18,14,-74,80,96,-4};
int param0_2[] = {0,0,0,0,0,0,1};
int param0_3[] = {93,32,3,31,67,96,52,80,70,49,45,23,58,87,31,56,21,71,55,97};
int param0_4[] = {-98,-96,-84,-82,-72,-64,-62,-56,-52,-52,-48,-46,-42,-36,-32,-30,-30,-18,-16,-10,-2,0,6,18,22,22,40,42,50,54,64,68,68,72,80,82,84,96};
int param0_5[] = {1,1,0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,0,0,1,0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,1,0};
int param0_6[] = {9,12,13,28,43,46,64,66,68,89,92};
int param0_7[] = {22,-8,-56,68,-12,-26,-40,-46,-42,-80,4,-42,-72,-22,36,22,-94,48,96,80,-52,46,90,94,36,92,-12,-24,-60,-32,92,18,76,40,-32,6,-22,86,86,-88,38,50,32,78,-82,54,-40,18};
int param0_8[] = {0,0,0,0,0,0,1,1,1};
int param0_9[] = {81,74,32,41,85,65,81,74,40,64,97,4,61,43,54,96,62,2,97,86,80,25,9,31,16,29,4,63,76,41,5,95};
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,18,6,15,20,29,6,41,4,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) (arr)[0]));}",
"b) <string>",
"c) [",
"d) (sizeof",
"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 text [], int s ) {
char result [] = "";
for ( int i = 0;
i < strlen(text);
i ++ ) {
if ( isupper ( text [ i ] ) ) result += char ( int ( text [ i ] + s - 65 ) % 26 + 65 );
else result += char ( int ( text [ i ] + s - 97 ) % 26 + 97 );
}
return result;
}
char f_filled [] ( char text [], int s ) {}
) ) result += char ( int ( text [ i ] + s - 65 ) % 26 + 65 );
else result += char ( int ( text [ i ] + s - 97 ) % 26 + 97 );
}
return result;
}
char f_filled [] ( char text [], int s ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"LsvbpcviVPwq","35225904","010010","QnYd","2571694","101101011010","jb","928874","11","FbvbkMb"};
int param1[] = {15,2,36,44,11,94,22,83,93,37};
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)? [MASK] 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 text [], int s ) { char result [] = ""; for ( int i = 0; i < strlen(text); i ++ ) { if ( isupper ( text [ i ] ) ) result += char ( int ( text [ i ] + s - 65 ) % 26 + 65 ); else result += char ( int ( text [ i ] + s - 97 ) % 26 + 97 ); } return result; } char f_filled [] ( char text [], int s ) {}) ) result += char ( int ( text [ i ] + s - 65 ) % 26 + 65 );
else result += char ( int ( text [ i ] + s - 97 ) % 26 + 97 );
}
return result;
}
char f_filled [] ( char text [], int s ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"LsvbpcviVPwq","35225904","010010","QnYd","2571694","101101011010","jb","928874","11","FbvbkMb"};
int param1[] = {15,2,36,44,11,94,22,83,93,37};
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) x:",
"b) import",
"c) int",
"d) =",
"e) const"
] | 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 ( long long int n ) {
while ( n / 100 ) {
int last_digit = n % 10;
n /= 10;
n += last_digit * 3;
}
return ( n % 29 == 0 );
}
bool f_filled ( long long int n ) {}
;}
bool f_gold ( long long int n ) {
while ( n / 100 ) {
int last_digit = n % 10;
n /= 10;
n += last_digit * 3;
}
return ( n % 29 == 0 );
}
bool f_filled ( long long int n ) {}
int main(void) {
int n_success = 0;
long param0[] = {50,11,65,32,8,54,7,44,34,63};
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 ( long long int n ) { while ( n / 100 ) { int last_digit = n % 10; n /= 10; n += last_digit * 3; [MASK] return ( n % 29 == 0 ); } bool f_filled ( long long int n ) {};}
bool f_gold ( long long int n ) {
while ( n / 100 ) {
int last_digit = n % 10;
n /= 10;
n += last_digit * 3;
}
return ( n % 29 == 0 );
}
bool f_filled ( long long int n ) {}
int main(void) {
int n_success = 0;
long param0[] = {50,11,65,32,8,54,7,44,34,63};
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) #include",
"c) }",
"d) return",
"e) return"
] | 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 ) {
if ( n <= 4 ) return * min_element ( ar, ar + n );
int sum [ n ];
sum [ 0 ] = ar [ 0 ];
sum [ 1 ] = ar [ 1 ];
sum [ 2 ] = ar [ 2 ];
sum [ 3 ] = ar [ 3 ];
for ( int i = 4;
i < n;
i ++ ) sum [ i ] = ar [ i ] + ( * min_element ( sum + i - 4, sum + i ) );
return * min_element ( sum + n - 4, sum + n );
}
int f_filled ( int ar [ ], int n ) {}
];
for ( int i = 4;
i < n;
i ++ ) sum [ i ] = ar [ i ] + ( * min_element ( sum + i - 4, sum + i ) );
return * min_element ( sum + n - 4, sum + n );
}
int f_filled ( int ar [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,4,9,26,31,31,33,35,40,45,48,52,57,60,69,75,82,89,90,92,95,97};
int param0_1[] = {60,-68,30,-62,-8,48,-20,30,16,-60,-20};
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,1,1,1,1,1,1,1,1};
int param0_3[] = {15,70,50,28,67,11,27,42,1,61,37,8,66,54,50,91,86,57,4};
int param0_4[] = {-98,-92,-84,-80,-70,-58,-58,-48,-42,-14,-8,24,30,32,42,62,68,70,72,88};
int param0_5[] = {1,1,1,1,0,1,0,1,1,1,0,1,1,1,0};
int param0_6[] = {4,5,5,10,12,13,16,19,19,21,22,25,26,29,30,33,34,44,46,52,55,55,56,78,86,88,88,90,92};
int param0_7[] = {40,-50,-96,78,82,-16,26,8,38,38,54,-24,88,96,-42,-84,-28,-32,-64,74,74,-10,-8,66,14,-78,56,-22,-90,66,-68};
int param0_8[] = {0,0,0,0,0,1,1,1,1,1,1,1};
int param0_9[] = {29,38,20,25,16,97,16,90,30,99};
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,5,43,15,16,7,16,26,7,9};
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*)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 ) { if ( n <= 4 ) return * min_element ( ar, ar + n ); int sum [ n ]; sum [ 0 ] = ar [ 0 ]; sum [ 1 ] = ar [ 1 ]; sum [ 2 ] = ar [ 2 ]; sum [ 3 ] = ar [ 3 ]; for ( int i = 4; i < n; i ++ ) sum [ i ] = ar [ i ] + ( * min_element ( sum + i - 4, sum + i ) ); return * min_element ( sum + n - 4, sum + n ); } int f_filled ( int ar [ ], int n ) {}];
for ( int i = 4;
i < n;
i ++ ) sum [ i ] = ar [ i ] + ( * min_element ( sum + i - 4, sum + i ) );
return * min_element ( sum + n - 4, sum + n );
}
int f_filled ( int ar [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,4,9,26,31,31,33,35,40,45,48,52,57,60,69,75,82,89,90,92,95,97};
int param0_1[] = {60,-68,30,-62,-8,48,-20,30,16,-60,-20};
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,1,1,1,1,1,1,1,1};
int param0_3[] = {15,70,50,28,67,11,27,42,1,61,37,8,66,54,50,91,86,57,4};
int param0_4[] = {-98,-92,-84,-80,-70,-58,-58,-48,-42,-14,-8,24,30,32,42,62,68,70,72,88};
int param0_5[] = {1,1,1,1,0,1,0,1,1,1,0,1,1,1,0};
int param0_6[] = {4,5,5,10,12,13,16,19,19,21,22,25,26,29,30,33,34,44,46,52,55,55,56,78,86,88,88,90,92};
int param0_7[] = {40,-50,-96,78,82,-16,26,8,38,38,54,-24,88,96,-42,-84,-28,-32,-64,74,74,-10,-8,66,14,-78,56,-22,-90,66,-68};
int param0_8[] = {0,0,0,0,0,1,1,1,1,1,1,1};
int param0_9[] = {29,38,20,25,16,97,16,90,30,99};
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,5,43,15,16,7,16,26,7,9};
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) f_gold",
"d) [",
"e) return"
] | 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 long int f_gold ( long long int y, long long int x ) {
if ( log2 ( y ) < x ) return y;
if ( x > 63 ) return y;
return ( y % ( 1 << x ) );
}
long long int f_filled ( long long int y, long long int x ) {}
ld ( long long int y, long long int x ) {
if ( log2 ( y ) < x ) return y;
if ( x > 63 ) return y;
return ( y % ( 1 << x ) );
}
long long int f_filled ( long long int y, long long int x ) {}
int main(void) {
int n_success = 0;
long param0[] = {57,80,84,35,3,42,7,99,13,44};
long param1[] = {76,46,96,16,84,79,2,83,61,8};
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);} long long int f_gold ( long long int y, long long int x ) { if ( log2 ( y ) < x ) return y; if ( x > 63 ) return y; return ( y % ( 1 << x ) ); } long long int f_filled ( long long int y, long long int x ) {}ld ( long long int y, long long int x ) {
if ( log2 ( y ) < x ) return y;
if ( x > 63 ) return y;
return ( y % ( 1 << x ) );
}
long long int f_filled ( long long int y, long long int x ) {}
int main(void) {
int n_success = 0;
long param0[] = {57,80,84,35,3,42,7,99,13,44};
long param1[] = {76,46,96,16,84,79,2,83,61,8};
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) if",
"b) [",
"c) =",
"d) int",
"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 ( char str [ ], int n ) {
int ans = ( n * ( n + 1 ) ) / 2;
int a_index = 0;
int b_index = 0;
int c_index = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( str [ i ] == 'a' ) {
a_index = i + 1;
ans -= min ( b_index, c_index );
}
else if ( str [ i ] == 'b' ) {
b_index = i + 1;
ans -= min ( a_index, c_index );
}
else {
c_index = i + 1;
ans -= min ( a_index, b_index );
}
}
return ans;
}
int f_filled ( char str [ ], int n ) {}
ex = i + 1;
ans -= min ( a_index, c_index );
}
else {
c_index = i + 1;
ans -= min ( a_index, b_index );
}
}
return ans;
}
int f_filled ( char str [ ], int n ) {}
int main(void) {
int n_success = 0;
char param0_0[] = {','Y','e','u','I','P','y','j','o','n'};
char param0_1[] = {'0','0','2','2','3','3','4','5','6','6','6','7','8','9'};
char param0_2[] = {'0','1','0','1','1','1','1','0','0','0','1','1','0','0','0','0','0','0','1','1','1','1','0','1','0','1','1','1','1','1','0','0'};
char param0_3[] = {'E','G','G','J','L','O','O','S','T','U','V','V','Y','c','d','e','f','g','g','j','m','n','p','q','q','r','u','u','x'};
char param0_4[] = {'8','1','9','6','4','3','8','2','8','5','5','3','0','1','7','3','1','5','4','8','2','3','3','2','2','4','9','6','3','1','4','1','4','0','4','9','4','8','4','7'};
char param0_5[] = {'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'};
char param0_6[] = {'j','z','H','Q'};
char *param0[7] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6};
int param1[] = {23,24,15,9,8,19,21,36,33,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 ( char str [ ], int n ) { int ans = ( n * ( n + 1 ) ) / 2; int a_index = 0; int b_index = 0; int c_index = 0; for ( int i = 0; i < n; i ++ ) { if ( str [ i ] == 'a' ) { a_index = i + 1; ans -= min ( b_index, c_index ); } else [MASK] ( str [ i ] == 'b' ) { b_index = i + 1; ans -= min ( a_index, c_index ); } else { c_index = i + 1; ans -= min ( a_index, b_index ); } } return ans; } int f_filled ( char str [ ], int n ) {}ex = i + 1;
ans -= min ( a_index, c_index );
}
else {
c_index = i + 1;
ans -= min ( a_index, b_index );
}
}
return ans;
}
int f_filled ( char str [ ], int n ) {}
int main(void) {
int n_success = 0;
char param0_0[] = {','Y','e','u','I','P','y','j','o','n'};
char param0_1[] = {'0','0','2','2','3','3','4','5','6','6','6','7','8','9'};
char param0_2[] = {'0','1','0','1','1','1','1','0','0','0','1','1','0','0','0','0','0','0','1','1','1','1','0','1','0','1','1','1','1','1','0','0'};
char param0_3[] = {'E','G','G','J','L','O','O','S','T','U','V','V','Y','c','d','e','f','g','g','j','m','n','p','q','q','r','u','u','x'};
char param0_4[] = {'8','1','9','6','4','3','8','2','8','5','5','3','0','1','7','3','1','5','4','8','2','3','3','2','2','4','9','6','3','1','4','1','4','0','4','9','4','8','4','7'};
char param0_5[] = {'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'};
char param0_6[] = {'j','z','H','Q'};
char *param0[7] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6};
int param1[] = {23,24,15,9,8,19,21,36,33,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;
} | if | [
"a) +",
"b) arr",
"c) Sum",
"d) )",
"e) if"
] | 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);
int i;
for ( i = 0;
i < n;
i ++ ) if ( str [ i ] != 'a' ) break;
if ( i * 2 != n ) return false;
int j;
for ( j = i;
j < n;
j ++ ) if ( str [ j ] != 'b' ) return false;
return true;
}
bool f_filled ( char str [] ) {}
if ( str [ i ] != 'a' ) break;
if ( i * 2 != n ) return false;
int j;
for ( j = i;
j < n;
j ++ ) if ( str [ j ] != 'b' ) return false;
return true;
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"ba","aabb","abab","aaabb","aabbb","abaabbaa","abaababb","bbaa","11001000","ZWXv te"};
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 [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);} bool f_gold ( char str [] ) { int n = strlen(str); int i; for ( i = 0; i < n; i ++ ) if ( str [ i ] != 'a' ) break; if ( i * 2 != n ) return false; int j; for ( j = i; j < n; j ++ ) if ( str [ j ] != 'b' ) return false; return true; } bool f_filled ( char str [] ) {} if ( str [ i ] != 'a' ) break;
if ( i * 2 != n ) return false;
int j;
for ( j = i;
j < n;
j ++ ) if ( str [ j ] != 'b' ) return false;
return true;
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"ba","aabb","abab","aaabb","aabbb","abaabbaa","abaababb","bbaa","11001000","ZWXv te"};
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) <math.h>",
"b) 1]",
"c) (x",
"d) import",
"e) area;"
] | 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 arr1 [ ], int arr2 [ ], int m, int n ) {
int i = 0, j = 0;
if ( m < n ) return 0;
sort ( arr1, arr1 + m );
sort ( arr2, arr2 + n );
while ( i < n && j < m ) {
if ( arr1 [ j ] < arr2 [ i ] ) j ++;
else if ( arr1 [ j ] == arr2 [ i ] ) {
j ++;
i ++;
}
else if ( arr1 [ j ] > arr2 [ i ] ) return 0;
}
return ( i < n ) ? false : true;
}
bool f_filled ( int arr1 [ ], int arr2 [ ], int m, int n ) {}
r2 [ i ] ) {
j ++;
i ++;
}
else if ( arr1 [ j ] > arr2 [ i ] ) return 0;
}
return ( i < n ) ? false : true;
}
bool f_filled ( int arr1 [ ], int arr2 [ ], int m, int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,10,10,10,13,17,23,24,25,28,30,33,37,49,49,50,57,60,60,63,63,64,65,65,72,81,84,85,85,94,96};
int param0_1[] = {12,30,-94,-92,-62,-18,-56,44,-50,-92,6,2,56,-90,0,0,18,86,-58,58,-54,62,-94,94,0,8,82,-68,-88,-18,8,-80,-42,18,62,-8,56,-76,-42,56,44,-2,-20,62,-14,74,-86,-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,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[] = {94,26,32,20,46,55,9,51,57,80,45,38,68,12,90,10,80,65,12,52,51,86,64,57,93,19,30,92,85,82,24,26,36,56};
int param0_4[] = {-98,-90,-86,-86,-84,-84,-82,-80,-78,-72,-70,-68,-66,-64,-52,-52,-50,-38,-28,-26,-24,-14,-8,16,26,26,28,34,36,40,42,44,44,46,50,60,68,78,80,86,90,92,98};
int param0_5[] = {1,0,1,0,1,0,0,0,1,0,0,0,0,1,1,0,1,1};
int param0_6[] = {6,8,11,13,14,26,26,41,48,70,82,83,84,88,96};
int param0_7[] = {-88,80,62,76,48,92,18,-94,-62,98,-46,-50,70,32,68,-54,26,16,94,0,-84,2,-16,88,26,-38,18,64,90,80,76,2,14,-90,50,4,76,30};
int param0_8[] = {0,0,0,0,0,1,1,1,1,1,1,1};
int param0_9[] = {54,44,97,92,13,54,27,8,43,70,77,84,55,64,5,59,27,19,65,68,66,26,33,38,7};
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[] = {44};
int param1_1[] = {0,0,0};
int param1_2[] = {80,58,32,2};
int param1_3[] = {-99,-90,-90,-86};
int param1_4[] = {0,0,1,1};
int param1_5[] = {1,9,12,16};
int param1_6[] = {-76,-54,4,78};
int param1_7[] = {0,1,0,1};
int param1_8[] = {93,5,9,13};
int *param1[9] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8};
int param2[] = {29,46,34,17,23,10,10,27,10,19};
int param3[] = {4,3,3,4,4,4,4,4,4,4};
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);} bool f_gold ( int arr1 [ ], int arr2 [ ], int m, int n ) { int i = 0, j = 0; if ( m < n ) return 0; sort ( arr1, arr1 + m ); sort ( arr2, arr2 + n ); while ( i < n && j < m ) { if ( arr1 [ j ] < arr2 [ i ] ) j ++; else if ( arr1 [ j ] == arr2 [ i ] ) { j ++; i ++; } else if ( arr1 [MASK] j ] > arr2 [ i ] ) return 0; } return ( i < n ) ? false : true; } bool f_filled ( int arr1 [ ], int arr2 [ ], int m, int n ) {}r2 [ i ] ) {
j ++;
i ++;
}
else if ( arr1 [ j ] > arr2 [ i ] ) return 0;
}
return ( i < n ) ? false : true;
}
bool f_filled ( int arr1 [ ], int arr2 [ ], int m, int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,10,10,10,13,17,23,24,25,28,30,33,37,49,49,50,57,60,60,63,63,64,65,65,72,81,84,85,85,94,96};
int param0_1[] = {12,30,-94,-92,-62,-18,-56,44,-50,-92,6,2,56,-90,0,0,18,86,-58,58,-54,62,-94,94,0,8,82,-68,-88,-18,8,-80,-42,18,62,-8,56,-76,-42,56,44,-2,-20,62,-14,74,-86,-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,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[] = {94,26,32,20,46,55,9,51,57,80,45,38,68,12,90,10,80,65,12,52,51,86,64,57,93,19,30,92,85,82,24,26,36,56};
int param0_4[] = {-98,-90,-86,-86,-84,-84,-82,-80,-78,-72,-70,-68,-66,-64,-52,-52,-50,-38,-28,-26,-24,-14,-8,16,26,26,28,34,36,40,42,44,44,46,50,60,68,78,80,86,90,92,98};
int param0_5[] = {1,0,1,0,1,0,0,0,1,0,0,0,0,1,1,0,1,1};
int param0_6[] = {6,8,11,13,14,26,26,41,48,70,82,83,84,88,96};
int param0_7[] = {-88,80,62,76,48,92,18,-94,-62,98,-46,-50,70,32,68,-54,26,16,94,0,-84,2,-16,88,26,-38,18,64,90,80,76,2,14,-90,50,4,76,30};
int param0_8[] = {0,0,0,0,0,1,1,1,1,1,1,1};
int param0_9[] = {54,44,97,92,13,54,27,8,43,70,77,84,55,64,5,59,27,19,65,68,66,26,33,38,7};
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[] = {44};
int param1_1[] = {0,0,0};
int param1_2[] = {80,58,32,2};
int param1_3[] = {-99,-90,-90,-86};
int param1_4[] = {0,0,1,1};
int param1_5[] = {1,9,12,16};
int param1_6[] = {-76,-54,4,78};
int param1_7[] = {0,1,0,1};
int param1_8[] = {93,5,9,13};
int *param1[9] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8};
int param2[] = {29,46,34,17,23,10,10,27,10,19};
int param3[] = {4,3,3,4,4,4,4,4,4,4};
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) i",
"c) )",
"d) import",
"e) pro"
] | 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 prime [ n + 1 ], sum = 0;
memset ( prime, 0, sizeof ( prime ) );
int max = n / 2;
for ( int p = 2;
p <= max;
p ++ ) {
if ( prime [ p ] == 0 ) {
for ( int i = p * 2;
i <= n;
i += p ) prime [ i ] = p;
}
}
for ( int p = 2;
p <= n;
p ++ ) {
if ( prime [ p ] ) sum += prime [ p ];
else sum += p;
}
return sum;
}
int f_filled ( int n ) {}
<= n;
i += p ) prime [ i ] = p;
}
}
for ( int p = 2;
p <= n;
p ++ ) {
if ( prime [ p ] ) sum += prime [ p ];
else sum += p;
}
return sum;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {6,35,87,91,63,11,66,17,92,81};
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) [MASK] (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { int prime [ n + 1 ], sum = 0; memset ( prime, 0, sizeof ( prime ) ); int max = n / 2; for ( int p = 2; p <= max; p ++ ) { if ( prime [ p ] == 0 ) { for ( int i = p * 2; i <= n; i += p ) prime [ i ] = p; } } for ( int p = 2; p <= n; p ++ ) { if ( prime [ p ] ) sum += prime [ p ]; else sum += p; } return sum; } int f_filled ( int n ) {}<= n;
i += p ) prime [ i ] = p;
}
}
for ( int p = 2;
p <= n;
p ++ ) {
if ( prime [ p ] ) sum += prime [ p ];
else sum += p;
}
return sum;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {6,35,87,91,63,11,66,17,92,81};
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) void",
"b) ord",
"c) i",
"d) f_gold",
"e) (sizeof"
] | 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 C, int l ) {
if ( l >= C ) return C;
double eq_root = ( std :: sqrt ( 1 + 8 * ( C - l ) ) - 1 ) / 2;
return std :: ceil ( eq_root ) + l;
}
int f_filled ( int C, int l ) {}
int f_gold ( int C, int l ) {
if ( l >= C ) return C;
double eq_root = ( std :: sqrt ( 1 + 8 * ( C - l ) ) - 1 ) / 2;
return std :: ceil ( eq_root ) + l;
}
int f_filled ( int C, int l ) {}
int main(void) {
int n_success = 0;
int param0[] = {91,99,11,23,12,1,18,14,13,36};
int param1[] = {29,55,56,56,97,64,5,37,55,99};
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 C, int l ) { if ( l >= C ) return C; double eq_root = ( std :: sqrt ( [MASK] + 8 * ( C - l ) ) - 1 ) / 2; return std :: ceil ( eq_root ) + l; } int f_filled ( int C, int l ) {}
int f_gold ( int C, int l ) {
if ( l >= C ) return C;
double eq_root = ( std :: sqrt ( 1 + 8 * ( C - l ) ) - 1 ) / 2;
return std :: ceil ( eq_root ) + l;
}
int f_filled ( int C, int l ) {}
int main(void) {
int n_success = 0;
int param0[] = {91,99,11,23,12,1,18,14,13,36};
int param1[] = {29,55,56,56,97,64,5,37,55,99};
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;
} | 1 | [
"a) =",
"b) 1",
"c) (",
"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 ( int price [ ], int n, int k ) {
int profit [ k + 1 ] [ n + 1 ];
for ( int i = 0;
i <= k;
i ++ ) profit [ i ] [ 0 ] = 0;
for ( int j = 0;
j <= n;
j ++ ) profit [ 0 ] [ j ] = 0;
for ( int i = 1;
i <= k;
i ++ ) {
int prevDiff = INT_MIN;
for ( int j = 1;
j < n;
j ++ ) {
prevDiff = max ( prevDiff, profit [ i - 1 ] [ j - 1 ] - price [ j - 1 ] );
profit [ i ] [ j ] = max ( profit [ i ] [ j - 1 ], price [ j ] + prevDiff );
}
}
return profit [ k ] [ n - 1 ];
}
int f_filled ( int price [ ], int n, int k ) {}
price [ j - 1 ] );
profit [ i ] [ j ] = max ( profit [ i ] [ j - 1 ], price [ j ] + prevDiff );
}
}
return profit [ k ] [ n - 1 ];
}
int f_filled ( int price [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,6,16,16,19,37,47,49,74,77,86,96};
int param0_1[] = {-6,-70,-26,78,98,-72,48,-94,-38,52,-50,58,84,16,-74,32,-44,-50,68,-48,28,94,-26,-96,-42,96,-24,42,-70,10,-16,-32,98,38,-2,26,-26,-78,44,-72,-56,-22};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1};
int param0_3[] = {22,12,58,70};
int param0_4[] = {-96,-96,-94,-92,-90,-88,-88,-84,-78,-76,-72,-72,-68,-62,-54,-52,-52,-36,-34,-32,-26,-20,-6,-4,-4,4,8,10,14,16,32,32,32,34,42,46,50,60,62,64,64,72,74,76,76,78,90,92,96};
int param0_5[] = {1,0,0,0,1,1,0,0,0,1,0,0,1,0,1,1,1,0};
int param0_6[] = {2,4,7,11,20,24,25,27,29,33,33,36,36,41,44,45,47,54,65,66,67,75,78,82,85,90};
int param0_7[] = {56,2,-10,-44,68,10,-32,-2,-68,12,-34,-36,0,40,-16,-36,92,8,-40,-10,46,98,76,-2,98,-20,6,68,32,-26,-12,70,16,-34,-50,-76,-34,-18,0,-44,-76,58};
int param0_8[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_9[] = {78,39,2,76,20,21,3,21,32,80,28,89,51,2,88,19,99,71,68,38,8,76,48,81,90,71,31};
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[] = {6,31,7,3,30,14,15,24,10,14};
int param2[] = {6,32,8,2,36,13,22,35,8,24};
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 [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);} int f_gold ( int price [ ], int n, int k ) { int profit [ k + 1 ] [ n + 1 ]; for ( int i = 0; i <= k; i ++ ) profit [ i ] [ 0 ] = 0; for ( int j = 0; j <= n; j ++ ) profit [ 0 ] [ j ] = 0; for ( int i = 1; i <= k; i ++ ) { int prevDiff = INT_MIN; for ( int j = 1; j < n; j ++ ) { prevDiff = max ( prevDiff, profit [ i - 1 ] [ j - 1 ] - price [ j - 1 ] ); profit [ i ] [ j ] = max ( profit [ i ] [ j - 1 ], price [ j ] + prevDiff ); } } return profit [ k ] [ n - 1 ]; } int f_filled ( int price [ ], int n, int k ) {} price [ j - 1 ] );
profit [ i ] [ j ] = max ( profit [ i ] [ j - 1 ], price [ j ] + prevDiff );
}
}
return profit [ k ] [ n - 1 ];
}
int f_filled ( int price [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,6,16,16,19,37,47,49,74,77,86,96};
int param0_1[] = {-6,-70,-26,78,98,-72,48,-94,-38,52,-50,58,84,16,-74,32,-44,-50,68,-48,28,94,-26,-96,-42,96,-24,42,-70,10,-16,-32,98,38,-2,26,-26,-78,44,-72,-56,-22};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1};
int param0_3[] = {22,12,58,70};
int param0_4[] = {-96,-96,-94,-92,-90,-88,-88,-84,-78,-76,-72,-72,-68,-62,-54,-52,-52,-36,-34,-32,-26,-20,-6,-4,-4,4,8,10,14,16,32,32,32,34,42,46,50,60,62,64,64,72,74,76,76,78,90,92,96};
int param0_5[] = {1,0,0,0,1,1,0,0,0,1,0,0,1,0,1,1,1,0};
int param0_6[] = {2,4,7,11,20,24,25,27,29,33,33,36,36,41,44,45,47,54,65,66,67,75,78,82,85,90};
int param0_7[] = {56,2,-10,-44,68,10,-32,-2,-68,12,-34,-36,0,40,-16,-36,92,8,-40,-10,46,98,76,-2,98,-20,6,68,32,-26,-12,70,16,-34,-50,-76,-34,-18,0,-44,-76,58};
int param0_8[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_9[] = {78,39,2,76,20,21,3,21,32,80,28,89,51,2,88,19,99,71,68,38,8,76,48,81,90,71,31};
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[] = {6,31,7,3,30,14,15,24,10,14};
int param2[] = {6,32,8,2,36,13,22,35,8,24};
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) ord",
"b) (x",
"c) ]",
"d) y;",
"e) import"
] | 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);}
void f_gold ( int arr [ ], int l, int h ) {
if ( l >= h ) return;
if ( arr [ l ] > arr [ h ] ) swap ( arr [ l ], arr [ h ] );
if ( h - l + 1 > 2 ) {
int t = ( h - l + 1 ) / 3;
f_gold ( arr, l, h - t );
f_gold ( arr, l + t, h );
f_gold ( arr, l, h - t );
}
}
void f_filled ( int arr [ ], int l, int h ) {}
f ( h - l + 1 > 2 ) {
int t = ( h - l + 1 ) / 3;
f_gold ( arr, l, h - t );
f_gold ( arr, l + t, h );
f_gold ( arr, l, h - t );
}
}
void f_filled ( int arr [ ], int l, int h ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {6,25,42,52,53,54,58,66,67,70};
int param0_1[] = {-13,-98,50,-63,48,3,-76,12,-35,93,29,17,16,5,-97,-54,-45,-25};
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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {7,49,26,33,48,79,2,71,32,4,20,36};
int param0_4[] = {88};
int param0_5[] = {1,1,1,1,0,0,0,1,1,0,0,0,1,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1,1,0,1,1,1,0};
int param0_6[] = {2,2,4,5,7,12,12,14,14,16,17,29,29,31,32,39,41,47,48,49,51,54,58,58,59,60,73,78,80,81,82,83,84,85,90,95,97,99,99};
int param0_7[] = {-31,-55,6,37,77,61,0,46,-91,-38,85,-71,25,14,53,43,34};
int param0_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {77,68,78,97,92,52,37,8,44,98,5,69,31,45,9,32,33,67,30,76,29,3,90,57,30,9,26,2,62,3,46,68,25,51,13,44,35,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[] = {6,16,28,9,0,20,28,15,12,27};
int param2[] = {6,14,24,10,0,28,29,11,17,20};
int filled_function_param0_0[] = {6,25,42,52,53,54,58,66,67,70};
int filled_function_param0_1[] = {-13,-98,50,-63,48,3,-76,12,-35,93,29,17,16,5,-97,-54,-45,-25};
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,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int filled_function_param0_3[] = {7,49,26,33,48,79,2,71,32,4,20,36};
int filled_function_param0_4[] = {88};
int filled_function_param0_5[] = {1,1,1,1,0,0,0,1,1,0,0,0,1,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1,1,0,1,1,1,0};
int filled_function_param0_6[] = {2,2,4,5,7,12,12,14,14,16,17,29,29,31,32,39,41,47,48,49,51,54,58,58,59,60,73,78,80,81,82,83,84,85,90,95,97,99,99};
int filled_function_param0_7[] = {-31,-55,6,37,77,61,0,46,-91,-38,85,-71,25,14,53,43,34};
int filled_function_param0_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int filled_function_param0_9[] = {77,68,78,97,92,52,37,8,44,98,5,69,31,45,9,32,33,67,30,76,29,3,90,57,30,9,26,2,62,3,46,68,25,51,13,44,35,55};
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[] = {6,16,28,9,0,20,28,15,12,27};
int filled_function_param2[] = {6,14,24,10,0,28,29,11,17,20};
for(int i = 0; i < len(param0); ++i)
{
f_filled(filled_function_param0[i],filled_function_param1[i],filled_function_param2[i]);
f_gold(param0[i],param1[i],param2[i]);
if(equal(begin(param0[i]), end(param0[i]), begin(filled_function_param0[i])) && param1[i] == filled_function_param1[i] && param2[i] == filled_function_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);} void f_gold ( int arr [ ], int l, int h ) { if ( l >= h ) return; if ( arr [ l ] > arr [ h ] ) swap ( arr [ l ], arr [ h ] ); if ( h - l + 1 > 2 ) { int t = ( h - l + 1 ) / 3; f_gold [MASK] arr, l, h - t ); f_gold ( arr, l + t, h ); f_gold ( arr, l, h - t ); } } void f_filled ( int arr [ ], int l, int h ) {}f ( h - l + 1 > 2 ) {
int t = ( h - l + 1 ) / 3;
f_gold ( arr, l, h - t );
f_gold ( arr, l + t, h );
f_gold ( arr, l, h - t );
}
}
void f_filled ( int arr [ ], int l, int h ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {6,25,42,52,53,54,58,66,67,70};
int param0_1[] = {-13,-98,50,-63,48,3,-76,12,-35,93,29,17,16,5,-97,-54,-45,-25};
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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {7,49,26,33,48,79,2,71,32,4,20,36};
int param0_4[] = {88};
int param0_5[] = {1,1,1,1,0,0,0,1,1,0,0,0,1,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1,1,0,1,1,1,0};
int param0_6[] = {2,2,4,5,7,12,12,14,14,16,17,29,29,31,32,39,41,47,48,49,51,54,58,58,59,60,73,78,80,81,82,83,84,85,90,95,97,99,99};
int param0_7[] = {-31,-55,6,37,77,61,0,46,-91,-38,85,-71,25,14,53,43,34};
int param0_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {77,68,78,97,92,52,37,8,44,98,5,69,31,45,9,32,33,67,30,76,29,3,90,57,30,9,26,2,62,3,46,68,25,51,13,44,35,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[] = {6,16,28,9,0,20,28,15,12,27};
int param2[] = {6,14,24,10,0,28,29,11,17,20};
int filled_function_param0_0[] = {6,25,42,52,53,54,58,66,67,70};
int filled_function_param0_1[] = {-13,-98,50,-63,48,3,-76,12,-35,93,29,17,16,5,-97,-54,-45,-25};
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,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int filled_function_param0_3[] = {7,49,26,33,48,79,2,71,32,4,20,36};
int filled_function_param0_4[] = {88};
int filled_function_param0_5[] = {1,1,1,1,0,0,0,1,1,0,0,0,1,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1,1,0,1,1,1,0};
int filled_function_param0_6[] = {2,2,4,5,7,12,12,14,14,16,17,29,29,31,32,39,41,47,48,49,51,54,58,58,59,60,73,78,80,81,82,83,84,85,90,95,97,99,99};
int filled_function_param0_7[] = {-31,-55,6,37,77,61,0,46,-91,-38,85,-71,25,14,53,43,34};
int filled_function_param0_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int filled_function_param0_9[] = {77,68,78,97,92,52,37,8,44,98,5,69,31,45,9,32,33,67,30,76,29,3,90,57,30,9,26,2,62,3,46,68,25,51,13,44,35,55};
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[] = {6,16,28,9,0,20,28,15,12,27};
int filled_function_param2[] = {6,14,24,10,0,28,29,11,17,20};
for(int i = 0; i < len(param0); ++i)
{
f_filled(filled_function_param0[i],filled_function_param1[i],filled_function_param2[i]);
f_gold(param0[i],param1[i],param2[i]);
if(equal(begin(param0[i]), end(param0[i]), begin(filled_function_param0[i])) && param1[i] == filled_function_param1[i] && param2[i] == filled_function_param2[i])
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | ( | [
"a) <",
"b) (",
"c) <string>",
"d) False",
"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 n ) {
if ( n == 0 || n == 9 ) return true;
if ( n < 9 ) return false;
return f_gold ( ( int ) ( n >> 3 ) - ( int ) ( n & 7 ) );
}
bool f_filled ( int n ) {}
), cmpfunc);}
bool f_gold ( int n ) {
if ( n == 0 || n == 9 ) return true;
if ( n < 9 ) return false;
return f_gold ( ( int ) ( n >> 3 ) - ( int ) ( n & 7 ) );
}
bool f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {96,85,54,14,47,11,49,99,28,82};
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 ( int n ) { if ( n == 0 || n == 9 ) return true; if ( n < 9 ) return false; return f_gold ( ( int ) ( n >> 3 ) - ( int ) ( n & 7 ) ); } bool f_filled ( int n ) {}), cmpfunc);}
bool f_gold ( int n ) {
if ( n == 0 || n == 9 ) return true;
if ( n < 9 ) return false;
return f_gold ( ( int ) ( n >> 3 ) - ( int ) ( n & 7 ) );
}
bool f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {96,85,54,14,47,11,49,99,28,82};
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) bin",
"b) sizeof",
"c) ;",
"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 n, int a [ ] ) {
return n * ( a [ 0 ] * a [ 0 ] - a [ 2 * n - 1 ] * a [ 2 * n - 1 ] ) / ( 2 * n - 1 );
}
int f_filled ( int n, int a [ ] ) {}
(arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n, int a [ ] ) {
return n * ( a [ 0 ] * a [ 0 ] - a [ 2 * n - 1 ] * a [ 2 * n - 1 ] ) / ( 2 * n - 1 );
}
int f_filled ( int n, int a [ ] ) {}
int main(void) {
int n_success = 0;
int param0[] = {6,23,15,25,21,26,23,27,15,18};
int param1_0[] = {2,3,5,12,17,25,73,88};
int param1_1[] = {60,-90,-84,-46,-12,0,-92,38,-14,80,88,-70,56,58,56,-68,-56,70,-34,-22,-40,-48,-56,46,-26,-50,-68,40};
int param1_2[] = {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 param1_3[] = {81,93,12,83,37,63,60,89,40,32,78,54,63,76,76,77,50,2,53,82,50,46,5,49,37,67,77,16,95,84,6,66,1,16,10};
int param1_4[] = {-98,-92,-90,-82,-68,-62,-30,-28,-10,-8,-2,-2,-2,8,16,20,28,30,38,42,50,52,62,82,86,86,96,96};
int param1_5[] = {0,0,1,1,1,0,1,0,1,0,1,0,1,1,0,1,0,1,0,0,0,1,0,0,0,1,1,1,1,0,1,0,0,1,1,0,1,1,0,1,1,0};
int param1_6[] = {5,9,15,18,18,22,22,26,27,34,52,55,59,59,68,71,71,73,78,81,82,85,86,91,97,98};
int param1_7[] = {-30,28,74,92,-54,-52,-66,-40,-60,-70,-68,68,-36,-36,-52,-90,82,34,-96,90,-96,56,84,24,-78,-50,32,-96,82,8,54,-44,88,-70,80,26,72,-98,16,-32,-86,-20,24,88,-50};
int param1_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 param1_9[] = {99,99,24,86,84,17,41,87,68,34,17,70,23,84,74,4,78,84,83,48,75,9,73,99,81,84,54,2,23,11,8,61,30};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
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> [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 n, int a [ ] ) { return n * ( a [ 0 ] * a [ 0 ] - a [ 2 * n - 1 ] * a [ 2 * n - 1 ] ) / ( 2 * n - 1 ); } int f_filled ( int n, int a [ ] ) {} (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n, int a [ ] ) {
return n * ( a [ 0 ] * a [ 0 ] - a [ 2 * n - 1 ] * a [ 2 * n - 1 ] ) / ( 2 * n - 1 );
}
int f_filled ( int n, int a [ ] ) {}
int main(void) {
int n_success = 0;
int param0[] = {6,23,15,25,21,26,23,27,15,18};
int param1_0[] = {2,3,5,12,17,25,73,88};
int param1_1[] = {60,-90,-84,-46,-12,0,-92,38,-14,80,88,-70,56,58,56,-68,-56,70,-34,-22,-40,-48,-56,46,-26,-50,-68,40};
int param1_2[] = {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 param1_3[] = {81,93,12,83,37,63,60,89,40,32,78,54,63,76,76,77,50,2,53,82,50,46,5,49,37,67,77,16,95,84,6,66,1,16,10};
int param1_4[] = {-98,-92,-90,-82,-68,-62,-30,-28,-10,-8,-2,-2,-2,8,16,20,28,30,38,42,50,52,62,82,86,86,96,96};
int param1_5[] = {0,0,1,1,1,0,1,0,1,0,1,0,1,1,0,1,0,1,0,0,0,1,0,0,0,1,1,1,1,0,1,0,0,1,1,0,1,1,0,1,1,0};
int param1_6[] = {5,9,15,18,18,22,22,26,27,34,52,55,59,59,68,71,71,73,78,81,82,85,86,91,97,98};
int param1_7[] = {-30,28,74,92,-54,-52,-66,-40,-60,-70,-68,68,-36,-36,-52,-90,82,34,-96,90,-96,56,84,24,-78,-50,32,-96,82,8,54,-44,88,-70,80,26,72,-98,16,-32,-86,-20,24,88,-50};
int param1_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 param1_9[] = {99,99,24,86,84,17,41,87,68,34,17,70,23,84,74,4,78,84,83,48,75,9,73,99,81,84,54,2,23,11,8,61,30};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
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) 2",
"b) n",
"c) 1",
"d) int",
"e) y)"
] | 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 num [], int a ) {
int res = 0;
for ( int i = 0;
i < strlen(num);
i ++ ) res = ( res * 10 + ( int ) num [ i ] - '0' ) % a;
return res;
}
int f_filled ( char num [], int a ) {}
old ( char num [], int a ) {
int res = 0;
for ( int i = 0;
i < strlen(num);
i ++ ) res = ( res * 10 + ( int ) num [ i ] - '0' ) % a;
return res;
}
int f_filled ( char num [], int a ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"RElCP","0139035510","00011110","TwanZWwLNXhFN","6247009752778","0100001011011","NCh","00714746542","101000100","MSTkXmlbPkV"};
int param1[] = {13,44,86,66,55,33,75,54,93,78};
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)? [MASK] 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 num [], int a ) { int res = 0; for ( int i = 0; i < strlen(num); i ++ ) res = ( res * 10 + ( int ) num [ i ] - '0' ) % a; return res; } int f_filled ( char num [], int a ) {}old ( char num [], int a ) {
int res = 0;
for ( int i = 0;
i < strlen(num);
i ++ ) res = ( res * 10 + ( int ) num [ i ] - '0' ) % a;
return res;
}
int f_filled ( char num [], int a ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"RElCP","0139035510","00011110","TwanZWwLNXhFN","6247009752778","0100001011011","NCh","00714746542","101000100","MSTkXmlbPkV"};
int param1[] = {13,44,86,66,55,33,75,54,93,78};
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) x:",
"b) DIVISIBILITY_BY_7{",
"c) int",
"d) )",
"e) s"
] | 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 der [ n + 1 ];
der [ 0 ] = 1;
der [ 1 ] = 0;
der [ 2 ] = 1;
for ( int i = 3;
i <= n;
++ i ) der [ i ] = ( i - 1 ) * ( der [ i - 1 ] + der [ i - 2 ] );
return der [ n ];
}
int f_filled ( int n ) {}
der [ 0 ] = 1;
der [ 1 ] = 0;
der [ 2 ] = 1;
for ( int i = 3;
i <= n;
++ i ) der [ i ] = ( i - 1 ) * ( der [ i - 1 ] + der [ i - 2 ] );
return der [ n ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {22,91,33,93,90,59,88,41,70,63};
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 der [ n + 1 ]; der [ 0 ] = 1; der [ 1 ] = 0; der [ 2 [MASK] = 1; for ( int i = 3; i <= n; ++ i ) der [ i ] = ( i - 1 ) * ( der [ i - 1 ] + der [ i - 2 ] ); return der [ n ]; } int f_filled ( int n ) {} der [ 0 ] = 1;
der [ 1 ] = 0;
der [ 2 ] = 1;
for ( int i = 3;
i <= n;
++ i ) der [ i ] = ( i - 1 ) * ( der [ i - 1 ] + der [ i - 2 ] );
return der [ n ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {22,91,33,93,90,59,88,41,70,63};
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) (x",
"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 ) {
if ( n == 1 ) return arr [ 0 ];
int dec [ n ];
memset ( dec, 0, sizeof ( dec ) );
int inc [ n ];
memset ( inc, 0, sizeof ( inc ) );
dec [ 0 ] = inc [ 0 ] = arr [ 0 ];
int flag = 0;
for ( int i = 1;
i < n;
i ++ ) {
for ( int j = 0;
j < i;
j ++ ) {
if ( arr [ j ] > arr [ i ] ) {
dec [ i ] = max ( dec [ i ], inc [ j ] + arr [ i ] );
flag = 1;
}
else if ( arr [ j ] < arr [ i ] && flag == 1 ) inc [ i ] = max ( inc [ i ], dec [ j ] + arr [ i ] );
}
}
int result = INT_MIN;
for ( int i = 0;
i < n;
i ++ ) {
if ( result < inc [ i ] ) result = inc [ i ];
if ( result < dec [ i ] ) result = dec [ i ];
}
return result;
}
int f_filled ( int arr [ ], int n ) {}
( int i = 0;
i < n;
i ++ ) {
if ( result < inc [ i ] ) result = inc [ i ];
if ( result < dec [ i ] ) result = dec [ i ];
}
return result;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,5,9,15,15,20,21,26,28,32,34,38,42,42,42,46,47,48,50,54,55,60,60,61,63,63,66,74,79,80,85,91,93};
int param0_1[] = {-98};
int param0_2[] = {0,0,0,0,0,0,0,0,0,1,1,1};
int param0_3[] = {70,5,20,22,44,94,69,89,45,92,56,58,36,91,82,95,9,60,4,34,37,95,38,47,81,68,73,15,88,8,95,28,97,12,24,5,26,82,47,88,28,33,17,28,11,71,74};
int param0_4[] = {-98,-96,-94,-94,-92,-86,-86,-84,-82,-68,-66,-66,-50,-48,-46,-36,-26,-8,-6,8,14,16,18,22,32,48,48,50,62,70,70,74,78,78,84,86,92,94,98};
int param0_5[] = {0,1,1,1,0,0,1,1,1,0,1};
int param0_6[] = {1,2,8,8,12,14,19,24,25,32,36,45,47,53,54,56,56,58,59,60,65,68,86,86,91,98};
int param0_7[] = {-94,88,94,78,-34,84,-32,68,-72,80};
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,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[] = {76,62,62,61,63,15,61,74,50,86,60,35,91,32,93,14,52,18,14,39};
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,0,6,24,32,5,13,7,30,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 arr [ ], int n ) { if ( n == 1 ) return arr [ 0 ]; int dec [ n ]; memset ( dec, 0, sizeof ( dec ) ); int inc [ n ]; memset ( inc, 0, sizeof ( inc ) ); dec [ 0 ] = inc [ 0 ] = arr [ 0 ]; int flag = 0; for ( int i = 1; i < n; i ++ ) { for ( int j = 0; j < i; j ++ ) { if ( arr [ j ] > arr [ i ] ) { dec [ i ] = max ( dec [ i ], inc [ j ] + arr [ i ] ); flag = 1; } else if ( arr [ j ] < arr [ i ] && flag == 1 ) inc [ i ] = max ( inc [ i ], dec [ j ] + arr [ i ] ); } } int result = INT_MIN; for ( int i = 0; i < n; i ++ ) { if ( result < inc [ i ] ) result = inc [ i ]; if ( result < dec [ i ] ) result = dec [ i ]; } [MASK] result; } int f_filled ( int arr [ ], int n ) {} ( int i = 0;
i < n;
i ++ ) {
if ( result < inc [ i ] ) result = inc [ i ];
if ( result < dec [ i ] ) result = dec [ i ];
}
return result;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,5,9,15,15,20,21,26,28,32,34,38,42,42,42,46,47,48,50,54,55,60,60,61,63,63,66,74,79,80,85,91,93};
int param0_1[] = {-98};
int param0_2[] = {0,0,0,0,0,0,0,0,0,1,1,1};
int param0_3[] = {70,5,20,22,44,94,69,89,45,92,56,58,36,91,82,95,9,60,4,34,37,95,38,47,81,68,73,15,88,8,95,28,97,12,24,5,26,82,47,88,28,33,17,28,11,71,74};
int param0_4[] = {-98,-96,-94,-94,-92,-86,-86,-84,-82,-68,-66,-66,-50,-48,-46,-36,-26,-8,-6,8,14,16,18,22,32,48,48,50,62,70,70,74,78,78,84,86,92,94,98};
int param0_5[] = {0,1,1,1,0,0,1,1,1,0,1};
int param0_6[] = {1,2,8,8,12,14,19,24,25,32,36,45,47,53,54,56,56,58,59,60,65,68,86,86,91,98};
int param0_7[] = {-94,88,94,78,-34,84,-32,68,-72,80};
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,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[] = {76,62,62,61,63,15,61,74,50,86,60,35,91,32,93,14,52,18,14,39};
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,0,6,24,32,5,13,7,30,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;
} | return | [
"a) return",
"b) <",
"c) n;",
"d) <string>",
"e) f2"
] | 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 ) {
return ( 3 * n * n - n ) / 2;
}
int f_filled ( int n ) {}
int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( 3 * n * n - n ) / 2;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {96,93,15,8,21,14,11,79,24,94};
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 [MASK] {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { return ( 3 * n * n - n ) / 2; } int f_filled ( int n ) {}int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( 3 * n * n - n ) / 2;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {96,93,15,8,21,14,11,79,24,94};
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;
} | n) | [
"a) <",
"b) using",
"c) for",
"d) n)",
"e) double"
] | 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 1 + ( n * 2 ) + ( n * ( ( n * n ) - 1 ) / 2 );
}
int f_filled ( int n ) {}
eof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return 1 + ( n * 2 ) + ( n * ( ( n * n ) - 1 ) / 2 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {55,36,69,92,73,16,88,19,66,68};
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 [MASK] (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { return 1 + ( n * 2 ) + ( n * ( ( n * n ) - 1 ) / 2 ); } int f_filled ( int n ) {}eof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return 1 + ( n * 2 ) + ( n * ( ( n * n ) - 1 ) / 2 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {55,36,69,92,73,16,88,19,66,68};
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;
} | sort | [
"a) ]",
"b) sort",
"c) if",
"d) ++;",
"e) return"
] | 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 a [], char b [] ) {
int n = len(a), m = len(b);
if ( m == 0 ) return 1;
int dp [ m + 1 ] [ n + 1 ];
memset ( dp, 0, sizeof ( dp ) );
for ( int i = 0;
i < m;
i ++ ) {
for ( int j = i;
j < n;
j ++ ) {
if ( i == 0 ) {
if ( j == 0 ) dp [ i ] [ j ] = ( a [ j ] == b [ i ] ) ? 1 : 0;
else if ( a [ j ] == b [ i ] ) dp [ i ] [ j ] = dp [ i ] [ j - 1 ] + 1;
else dp [ i ] [ j ] = dp [ i ] [ j - 1 ];
}
else {
if ( a [ j ] == b [ i ] ) dp [ i ] [ j ] = dp [ i ] [ j - 1 ] + dp [ i - 1 ] [ j - 1 ];
else dp [ i ] [ j ] = dp [ i ] [ j - 1 ];
}
}
}
return dp [ m - 1 ] [ n - 1 ];
}
int f_filled ( char a [], char b [] ) {}
j ] = dp [ i ] [ j - 1 ] + dp [ i - 1 ] [ j - 1 ];
else dp [ i ] [ j ] = dp [ i ] [ j - 1 ];
}
}
}
return dp [ m - 1 ] [ n - 1 ];
}
int f_filled ( char a [], char b [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"abcccdf","aabba","aabsdfljk","IONiqV","9667771256770","10001011","fczbDtMDT","298746088","01100011000","Qk"};
char param1[][100] = {"abccdf","ab","aa","XKbBiGZ","50915176","01","FbX","29888","0",""};
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 ( char a [], char b [] ) { int n = len(a), m = len(b); if ( m == 0 ) return 1; int dp [ m + 1 ] [ n + 1 ]; memset ( dp, 0, sizeof ( dp ) ); for ( int i = 0; i < m; i ++ ) { for ( int j = i; j < n; j ++ ) { if ( i == 0 ) { if ( j [MASK] 0 ) dp [ i ] [ j ] = ( a [ j ] == b [ i ] ) ? 1 : 0; else if ( a [ j ] == b [ i ] ) dp [ i ] [ j ] = dp [ i ] [ j - 1 ] + 1; else dp [ i ] [ j ] = dp [ i ] [ j - 1 ]; } else { if ( a [ j ] == b [ i ] ) dp [ i ] [ j ] = dp [ i ] [ j - 1 ] + dp [ i - 1 ] [ j - 1 ]; else dp [ i ] [ j ] = dp [ i ] [ j - 1 ]; } } } return dp [ m - 1 ] [ n - 1 ]; } int f_filled ( char a [], char b [] ) {} j ] = dp [ i ] [ j - 1 ] + dp [ i - 1 ] [ j - 1 ];
else dp [ i ] [ j ] = dp [ i ] [ j - 1 ];
}
}
}
return dp [ m - 1 ] [ n - 1 ];
}
int f_filled ( char a [], char b [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"abcccdf","aabba","aabsdfljk","IONiqV","9667771256770","10001011","fczbDtMDT","298746088","01100011000","Qk"};
char param1[][100] = {"abccdf","ab","aa","XKbBiGZ","50915176","01","FbX","29888","0",""};
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) j",
"c) int",
"d) k",
"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 n ) {
int dp [ n + 1 ];
dp [ 0 ] = 0, dp [ 1 ] = 1;
for ( int i = 2;
i <= n;
i ++ ) dp [ i ] = max ( dp [ i / 2 ] + dp [ i / 3 ] + dp [ i / 4 ], i );
return dp [ n ];
}
int f_filled ( int n ) {}
dp [ n + 1 ];
dp [ 0 ] = 0, dp [ 1 ] = 1;
for ( int i = 2;
i <= n;
i ++ ) dp [ i ] = max ( dp [ i / 2 ] + dp [ i / 3 ] + dp [ i / 4 ], i );
return dp [ n ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {50,83,18,24,31,38,94,24,13,53};
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 [MASK] (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { int dp [ n + 1 ]; dp [ 0 ] = 0, dp [ 1 ] = 1; for ( int i = 2; i <= n; i ++ ) dp [ i ] = max ( dp [ i / 2 ] + dp [ i / 3 ] + dp [ i / 4 ], i ); return dp [ n ]; } int f_filled ( int n ) {} dp [ n + 1 ];
dp [ 0 ] = 0, dp [ 1 ] = 1;
for ( int i = 2;
i <= n;
i ++ ) dp [ i ] = max ( dp [ i / 2 ] + dp [ i / 3 ] + dp [ i / 4 ], i );
return dp [ n ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {50,83,18,24,31,38,94,24,13,53};
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;
} | sort | [
"a) public",
"b) )",
"c) java.lang.*;",
"d) <string>",
"e) sort"
] | 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 arr_size ) {
for ( int i = 0;
i < arr_size;
i ++ ) {
int count = 0;
for ( int j = 0;
j < arr_size;
j ++ ) {
if ( arr [ i ] == arr [ j ] ) count ++;
}
if ( count % 2 != 0 ) return arr [ i ];
}
return - 1;
}
int f_filled ( int arr [ ], int arr_size ) {}
0;
j < arr_size;
j ++ ) {
if ( arr [ i ] == arr [ j ] ) count ++;
}
if ( count % 2 != 0 ) return arr [ i ];
}
return - 1;
}
int f_filled ( int arr [ ], int arr_size ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,5,5,8,14,15,17,17,18,23,23,25,26,35,36,39,51,53,56,56,60,62,64,64,65,66,67,68,71,75,80,82,83,88,89,91,91,92,93,95,99};
int param0_1[] = {-56,98,44,30,-88,18,60,86,4,16,10,64,-22,-86,-66,-16,70,-44,98,78,-96,-66,92,10,40,-16};
int param0_2[] = {0,0,0,0,0,1,1,1};
int param0_3[] = {36,11,83,41,42,14,46,89,91,96,57,42,74,73,9,26,79,40,31,69,44,39,14,92,34,20,52,47,14};
int param0_4[] = {-84,-84,-84,-78,-66,-62,-62,-36,-24,-10,-10,-8,-4,-2,12,14,20,22,36,42,46,66,84,96,96,98};
int param0_5[] = {1,1,0,1,0,1,1,0,1,1,0,1,0,1,0,1,0,0,1,1,1,0,1,1,1,1,1,1};
int param0_6[] = {11,12,14,28,42,48,50,58,67,74,86,89,95};
int param0_7[] = {52,-56,-6,74,10,68,74,10,16,-80,82,-32,6,-6,82,20};
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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {4,80,92};
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[] = {31,19,6,25,23,19,7,11,31,1};
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] 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 arr_size ) { for ( int i = 0; i < arr_size; i ++ ) { int count = 0; for ( int j = 0; j < arr_size; j ++ ) { if ( arr [ i ] == arr [ j ] ) count ++; } if ( count % 2 != 0 ) return arr [ i ]; } return - 1; } int f_filled ( int arr [ ], int arr_size ) {}0;
j < arr_size;
j ++ ) {
if ( arr [ i ] == arr [ j ] ) count ++;
}
if ( count % 2 != 0 ) return arr [ i ];
}
return - 1;
}
int f_filled ( int arr [ ], int arr_size ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,5,5,8,14,15,17,17,18,23,23,25,26,35,36,39,51,53,56,56,60,62,64,64,65,66,67,68,71,75,80,82,83,88,89,91,91,92,93,95,99};
int param0_1[] = {-56,98,44,30,-88,18,60,86,4,16,10,64,-22,-86,-66,-16,70,-44,98,78,-96,-66,92,10,40,-16};
int param0_2[] = {0,0,0,0,0,1,1,1};
int param0_3[] = {36,11,83,41,42,14,46,89,91,96,57,42,74,73,9,26,79,40,31,69,44,39,14,92,34,20,52,47,14};
int param0_4[] = {-84,-84,-84,-78,-66,-62,-62,-36,-24,-10,-10,-8,-4,-2,12,14,20,22,36,42,46,66,84,96,96,98};
int param0_5[] = {1,1,0,1,0,1,1,0,1,1,0,1,0,1,0,1,0,0,1,1,1,0,1,1,1,1,1,1};
int param0_6[] = {11,12,14,28,42,48,50,58,67,74,86,89,95};
int param0_7[] = {52,-56,-6,74,10,68,74,10,16,-80,82,-32,6,-6,82,20};
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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {4,80,92};
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[] = {31,19,6,25,23,19,7,11,31,1};
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",
"b) static",
"c) int",
"d) )",
"e) arr"
] | 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 sum ) {
bool subset [ 2 ] [ sum + 1 ];
for ( int i = 0;
i <= n;
i ++ ) {
for ( int j = 0;
j <= sum;
j ++ ) {
if ( j == 0 ) subset [ i % 2 ] [ j ] = true;
else if ( i == 0 ) subset [ i % 2 ] [ j ] = false;
else if ( arr [ i - 1 ] <= j ) subset [ i % 2 ] [ j ] = subset [ ( i + 1 ) % 2 ] [ j - arr [ i - 1 ] ] || subset [ ( i + 1 ) % 2 ] [ j ];
else subset [ i % 2 ] [ j ] = subset [ ( i + 1 ) % 2 ] [ j ];
}
}
return subset [ n % 2 ] [ sum ];
}
bool f_filled ( int arr [ ], int n, int sum ) {}
subset [ ( i + 1 ) % 2 ] [ j ];
else subset [ i % 2 ] [ j ] = subset [ ( i + 1 ) % 2 ] [ j ];
}
}
return subset [ n % 2 ] [ sum ];
}
bool f_filled ( int arr [ ], int n, int sum ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,6,7,9,11,23,25,33,55,81,82,90,93,98};
int param0_1[] = {-44,-96,48,90,-26,66,-82,16,80,96,64,64,-78,-8,20,-74,-32,62,88,-62,28,-46,-40,-62,18,-46,50,-32,-26,-68,66,20,6,34,-20,-96,-26,-76,-64,46,-38};
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,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[] = {78,36,15,81,56,57,73,78,88,11,93,89,68,96,32,67,6,19,17,48,64,5,74,91,36,96,57,85,96,43,98,79,73,2};
int param0_4[] = {-84,-60,-56,-32,70,82};
int param0_5[] = {0,1,0,0,1,1,1,0,1};
int param0_6[] = {42,57,77,85,87,89,90};
int param0_7[] = {-82,68,70,-18,44,-48,-24,82,8,74,90,-72,-66,24,44,24,26,-80,-70,16,90,-54,-32,-54,70,48,-56,-16,-42};
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};
int param0_9[] = {3,30,94,96,95,21,84,76,35,52,18,87,60,28,78,72,80,58,65,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[] = {10,36,29,23,4,8,3,14,23,16};
int param2[] = {7,40,39,29,4,5,6,14,24,14};
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 sum ) { bool subset [ 2 ] [ sum + 1 ]; for ( int i = 0; i <= n; i ++ ) { for ( int j = 0; j <= sum; j ++ ) { if ( j == 0 ) subset [ i % 2 ] [ j ] = true; else if ( i == 0 ) subset [ i % 2 ] [ j ] [MASK] false; else if ( arr [ i - 1 ] <= j ) subset [ i % 2 ] [ j ] = subset [ ( i + 1 ) % 2 ] [ j - arr [ i - 1 ] ] || subset [ ( i + 1 ) % 2 ] [ j ]; else subset [ i % 2 ] [ j ] = subset [ ( i + 1 ) % 2 ] [ j ]; } } return subset [ n % 2 ] [ sum ]; } bool f_filled ( int arr [ ], int n, int sum ) {}subset [ ( i + 1 ) % 2 ] [ j ];
else subset [ i % 2 ] [ j ] = subset [ ( i + 1 ) % 2 ] [ j ];
}
}
return subset [ n % 2 ] [ sum ];
}
bool f_filled ( int arr [ ], int n, int sum ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,6,7,9,11,23,25,33,55,81,82,90,93,98};
int param0_1[] = {-44,-96,48,90,-26,66,-82,16,80,96,64,64,-78,-8,20,-74,-32,62,88,-62,28,-46,-40,-62,18,-46,50,-32,-26,-68,66,20,6,34,-20,-96,-26,-76,-64,46,-38};
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,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[] = {78,36,15,81,56,57,73,78,88,11,93,89,68,96,32,67,6,19,17,48,64,5,74,91,36,96,57,85,96,43,98,79,73,2};
int param0_4[] = {-84,-60,-56,-32,70,82};
int param0_5[] = {0,1,0,0,1,1,1,0,1};
int param0_6[] = {42,57,77,85,87,89,90};
int param0_7[] = {-82,68,70,-18,44,-48,-24,82,8,74,90,-72,-66,24,44,24,26,-80,-70,16,90,-54,-32,-54,70,48,-56,-16,-42};
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};
int param0_9[] = {3,30,94,96,95,21,84,76,35,52,18,87,60,28,78,72,80,58,65,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[] = {10,36,29,23,4,8,3,14,23,16};
int param2[] = {7,40,39,29,4,5,6,14,24,14};
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) ]",
"d) ;",
"e) j"
] | 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 ) {
if ( curr_sum <= 0 && x > 0 ) {
start = end;
curr_sum = 0;
}
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[] = {2,4,5,10,14,15,16,20,23,28,31,35,36,36,43,48,49,55,57,57,58,61,64,64,68,70,70,73,74,76,76,77,81,81,82,87,89,92,99};
int param0_1[] = {66,-20,12,-48,22,28,40,-30,-6,-96,10,-88,40};
int param0_2[] = {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_3[] = {28,19,38,31,17,27,60,35,19,47,34,51,3,95,33,29,84,46,74,87};
int param0_4[] = {-48,-2};
int param0_5[] = {1,1,0,1,1,1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,1,1};
int param0_6[] = {1,4,4,6,8,10,12,12,13,15,18,20,21,23,25,28,28,33,33,35,35,36,37,38,42,44,63,63,65,65,65,66,70,74,77,78,80,80,84,87,87,89,92,93,94,97,98,99};
int param0_7[] = {-82,-12,-40,58,22,-76,-94,-28,42,36,64};
int param0_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {76,65,96,76,1,91,22,29,95,21,73,68,30,52,73,86,52,66,67,37,76,53,68,6,95,81,98,42,63,38,92,78,59,86,10,38,18,15,52,62,16,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[] = {33,11,42,15,1,12,42,10,10,23};
int param2[] = {28,12,23,15,1,15,27,6,14,35};
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 [MASK] / 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 ) { if ( curr_sum <= 0 && x > 0 ) { start = end; curr_sum = 0; } 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[] = {2,4,5,10,14,15,16,20,23,28,31,35,36,36,43,48,49,55,57,57,58,61,64,64,68,70,70,73,74,76,76,77,81,81,82,87,89,92,99};
int param0_1[] = {66,-20,12,-48,22,28,40,-30,-6,-96,10,-88,40};
int param0_2[] = {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_3[] = {28,19,38,31,17,27,60,35,19,47,34,51,3,95,33,29,84,46,74,87};
int param0_4[] = {-48,-2};
int param0_5[] = {1,1,0,1,1,1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,1,1};
int param0_6[] = {1,4,4,6,8,10,12,12,13,15,18,20,21,23,25,28,28,33,33,35,35,36,37,38,42,44,63,63,65,65,65,66,70,74,77,78,80,80,84,87,87,89,92,93,94,97,98,99};
int param0_7[] = {-82,-12,-40,58,22,-76,-94,-28,42,36,64};
int param0_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {76,65,96,76,1,91,22,29,95,21,73,68,30,52,73,86,52,66,67,37,76,53,68,6,95,81,98,42,63,38,92,78,59,86,10,38,18,15,52,62,16,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[] = {33,11,42,15,1,12,42,10,10,23};
int param2[] = {28,12,23,15,1,15,27,6,14,35};
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;
} | (arr) | [
"a) x",
"b) )",
"c) =",
"d) (arr)",
"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 ones = 0, twos = 0;
int common_bit_mask;
for ( int i = 0;
i < n;
i ++ ) {
twos = twos | ( ones & arr [ i ] );
ones = ones ^ arr [ i ];
common_bit_mask = ~ ( ones & twos );
ones &= common_bit_mask;
twos &= common_bit_mask;
}
return ones;
}
int f_filled ( int arr [ ], int n ) {}
i ] );
ones = ones ^ arr [ i ];
common_bit_mask = ~ ( ones & twos );
ones &= common_bit_mask;
twos &= common_bit_mask;
}
return ones;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,26,26,48,59,62,66,70,72,75,76,81,97,98};
int param0_1[] = {-42,-48,-64,-74,56,-34,20,16,34,-84,86,38,56,-86,30,-74,-96,96,12,10,-46,10,-36,38,34,-46,-20,14,12,62,-54,20,-82,24,96};
int param0_2[] = {0,0,1,1};
int param0_3[] = {68,91,61,6,32,47,76,69,44,71,29,79,74,33,44,33,45,75,43,82,83,81,95,16,86,33,69,61,73,21,54,17,98,62,14,72,80,31,56,82,14,48,76};
int param0_4[] = {-98,-96,-92,-62,-52,-42,-42,-26,4,10,14,38,64,66,72,74,82};
int param0_5[] = {0,1,1,1,0,0,0,1,0,1};
int param0_6[] = {53,63,63};
int param0_7[] = {-96,-38,-26,-46,68,-36,20,-18,-10,52,40,94,-8,-64,82,-22};
int param0_8[] = {0,0,0,0,0,1,1};
int param0_9[] = {99,46,48,81,27,97,26,50,77,32,45,99,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[] = {7,27,3,38,14,5,2,15,3,12};
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 [MASK] arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int ones = 0, twos = 0; int common_bit_mask; for ( int i = 0; i < n; i ++ ) { twos = twos | ( ones & arr [ i ] ); ones = ones ^ arr [ i ]; common_bit_mask = ~ ( ones & twos ); ones &= common_bit_mask; twos &= common_bit_mask; } return ones; } int f_filled ( int arr [ ], int n ) {} i ] );
ones = ones ^ arr [ i ];
common_bit_mask = ~ ( ones & twos );
ones &= common_bit_mask;
twos &= common_bit_mask;
}
return ones;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,26,26,48,59,62,66,70,72,75,76,81,97,98};
int param0_1[] = {-42,-48,-64,-74,56,-34,20,16,34,-84,86,38,56,-86,30,-74,-96,96,12,10,-46,10,-36,38,34,-46,-20,14,12,62,-54,20,-82,24,96};
int param0_2[] = {0,0,1,1};
int param0_3[] = {68,91,61,6,32,47,76,69,44,71,29,79,74,33,44,33,45,75,43,82,83,81,95,16,86,33,69,61,73,21,54,17,98,62,14,72,80,31,56,82,14,48,76};
int param0_4[] = {-98,-96,-92,-62,-52,-42,-42,-26,4,10,14,38,64,66,72,74,82};
int param0_5[] = {0,1,1,1,0,0,0,1,0,1};
int param0_6[] = {53,63,63};
int param0_7[] = {-96,-38,-26,-46,68,-36,20,-18,-10,52,40,94,-8,-64,82,-22};
int param0_8[] = {0,0,0,0,0,1,1};
int param0_9[] = {99,46,48,81,27,97,26,50,77,32,45,99,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[] = {7,27,3,38,14,5,2,15,3,12};
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) def",
"b) ugly",
"c) area;",
"d) (int",
"e) i"
] | 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 dp [ n ];
for ( int i = 0;
i < n;
i ++ ) dp [ i ] = 1;
for ( int i = 1;
i < n;
i ++ ) {
for ( int j = 0;
j < i;
j ++ ) {
if ( ( arr [ i ] == arr [ j ] + 1 ) || ( arr [ i ] == arr [ j ] - 1 ) ) dp [ i ] = max ( dp [ i ], dp [ j ] + 1 );
}
}
int result = 1;
for ( int i = 0;
i < n;
i ++ ) if ( result < dp [ i ] ) result = dp [ i ];
return result;
}
int f_filled ( int arr [ ], int n ) {}
( dp [ i ], dp [ j ] + 1 );
}
}
int result = 1;
for ( int i = 0;
i < n;
i ++ ) if ( result < dp [ i ] ) result = dp [ i ];
return result;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,13,15,17,18,20,22,24,28,34,37,43,46,47,49,51,52,54,58,64,65,77,78,79,87,90,92,93,94,97};
int param0_1[] = {-86,-56,76,86,42,-40,8,34,-48,-54,-80,6,42,48,76,-26,6};
int param0_2[] = {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[] = {5,22,15,26,29,47,22};
int param0_4[] = {-90,-84,-76,-76,-74,-74,-66,-58,-58,-56,-56,-44,-38,-36,-34,-32,-16,-10,2,6,24,24,24,34,36,54,60,68,70,76,88};
int param0_5[] = {0,1,1,1,0,0,1,0,1,0,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1,1,0,1,1,1,1,0,0,0,1,0,0,1,1,1,0,0,1};
int param0_6[] = {1,3,12,12,12,12,14,17,18,19,23,27,28,30,35,38,42,44,45,48,52,59,61,64,65,69,73,76,77,82,83,85,87,99};
int param0_7[] = {-54,-20,24,-78,-58,64,34,70,-36,-24};
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,1,1,1,1};
int param0_9[] = {5,35,75,21,82,32,28,53,20,27,42,92,32,70,81,75,72,66,97,60,11,83,14,30,5,68,17,27,62,86,26,20,97,91,44,69};
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,15,16,5,17,26,23,8,27,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 arr [ ], int n ) { int dp [ n ]; for ( int i = 0; i [MASK] n; i ++ ) dp [ i ] = 1; for ( int i = 1; i < n; i ++ ) { for ( int j = 0; j < i; j ++ ) { if ( ( arr [ i ] == arr [ j ] + 1 ) || ( arr [ i ] == arr [ j ] - 1 ) ) dp [ i ] = max ( dp [ i ], dp [ j ] + 1 ); } } int result = 1; for ( int i = 0; i < n; i ++ ) if ( result < dp [ i ] ) result = dp [ i ]; return result; } int f_filled ( int arr [ ], int n ) {} ( dp [ i ], dp [ j ] + 1 );
}
}
int result = 1;
for ( int i = 0;
i < n;
i ++ ) if ( result < dp [ i ] ) result = dp [ i ];
return result;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,13,15,17,18,20,22,24,28,34,37,43,46,47,49,51,52,54,58,64,65,77,78,79,87,90,92,93,94,97};
int param0_1[] = {-86,-56,76,86,42,-40,8,34,-48,-54,-80,6,42,48,76,-26,6};
int param0_2[] = {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[] = {5,22,15,26,29,47,22};
int param0_4[] = {-90,-84,-76,-76,-74,-74,-66,-58,-58,-56,-56,-44,-38,-36,-34,-32,-16,-10,2,6,24,24,24,34,36,54,60,68,70,76,88};
int param0_5[] = {0,1,1,1,0,0,1,0,1,0,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1,1,0,1,1,1,1,0,0,0,1,0,0,1,1,1,0,0,1};
int param0_6[] = {1,3,12,12,12,12,14,17,18,19,23,27,28,30,35,38,42,44,45,48,52,59,61,64,65,69,73,76,77,82,83,85,87,99};
int param0_7[] = {-54,-20,24,-78,-58,64,34,70,-36,-24};
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,1,1,1,1};
int param0_9[] = {5,35,75,21,82,32,28,53,20,27,42,92,32,70,81,75,72,66,97,60,11,83,14,30,5,68,17,27,62,86,26,20,97,91,44,69};
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,15,16,5,17,26,23,8,27,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) <bits/stdc++.h>",
"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 low, int high, int x ) {
int mid;
if ( x <= arr [ low ] ) return low;
if ( x > arr [ high ] ) return - 1;
mid = ( low + high ) / 2;
if ( arr [ mid ] == x ) return mid;
else if ( arr [ mid ] < x ) {
if ( mid + 1 <= high && x <= arr [ mid + 1 ] ) return mid + 1;
else return f_gold ( arr, mid + 1, high, x );
}
else {
if ( mid - 1 >= low && x > arr [ mid - 1 ] ) return mid;
else return f_gold ( arr, low, mid - 1, x );
}
}
int f_filled ( int arr [ ], int low, int high, int x ) {}
gh, x );
}
else {
if ( mid - 1 >= low && x > arr [ mid - 1 ] ) return mid;
else return f_gold ( arr, low, mid - 1, x );
}
}
int f_filled ( int arr [ ], int low, int high, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,6,13,16,23,24,24,27,30,32,34,34,55,56,56,63,66,81,83,96};
int param0_1[] = {-28,-96,48,22,-12,72,48,-70,-96,-84,-62,22,18,-92,-74,14,28,52,64,72,16,-76,46};
int param0_2[] = {0,1};
int param0_3[] = {51,98,25,10,43,91,33,25,85,51,94,6,35,48,11,97,67,21,50,9,11,51,86,61,22,88,89,11};
int param0_4[] = {-94,-92,-88,-74,-52,-50,-48,-44,-40,-36,-32,-26,20,22,30,32,46,56,56,60,62,64,80,84,86,94,96,96};
int param0_5[] = {1,0,0,1,1,0,0,1,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0};
int param0_6[] = {4,5,5,13,26,40,46,51,58,60,64,66,68,69,71,74,78,81,83,88,88,90,98,99};
int param0_7[] = {92,6,-54,84,-10,32,50,40,-38,64,-64,-10,70,-68,-6,-16,68,34,-66,-82,84,98,50,82,78,4,34,-34,78,64,32,58,-94,40,50,0,-92,-36,10,-54,58,-78,-88,32,6};
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,1,1,1,1,1};
int param0_9[] = {80,67,30,35,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[] = {13,11,1,20,20,15,12,23,24,2};
int param2[] = {11,18,1,20,15,17,17,28,17,3};
int param3[] = {18,21,1,15,15,22,14,28,22,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)? [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 arr [ ], int low, int high, int x ) { int mid; if ( x <= arr [ low ] ) return low; if ( x > arr [ high ] ) return - 1; mid = ( low + high ) / 2; if ( arr [ mid ] == x ) return mid; else if ( arr [ mid ] < x ) { if ( mid + 1 <= high && x <= arr [ mid + 1 ] ) return mid + 1; else return f_gold ( arr, mid + 1, high, x ); } else { if ( mid - 1 >= low && x > arr [ mid - 1 ] ) return mid; else return f_gold ( arr, low, mid - 1, x ); } } int f_filled ( int arr [ ], int low, int high, int x ) {}gh, x );
}
else {
if ( mid - 1 >= low && x > arr [ mid - 1 ] ) return mid;
else return f_gold ( arr, low, mid - 1, x );
}
}
int f_filled ( int arr [ ], int low, int high, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,6,13,16,23,24,24,27,30,32,34,34,55,56,56,63,66,81,83,96};
int param0_1[] = {-28,-96,48,22,-12,72,48,-70,-96,-84,-62,22,18,-92,-74,14,28,52,64,72,16,-76,46};
int param0_2[] = {0,1};
int param0_3[] = {51,98,25,10,43,91,33,25,85,51,94,6,35,48,11,97,67,21,50,9,11,51,86,61,22,88,89,11};
int param0_4[] = {-94,-92,-88,-74,-52,-50,-48,-44,-40,-36,-32,-26,20,22,30,32,46,56,56,60,62,64,80,84,86,94,96,96};
int param0_5[] = {1,0,0,1,1,0,0,1,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0};
int param0_6[] = {4,5,5,13,26,40,46,51,58,60,64,66,68,69,71,74,78,81,83,88,88,90,98,99};
int param0_7[] = {92,6,-54,84,-10,32,50,40,-38,64,-64,-10,70,-68,-6,-16,68,34,-66,-82,84,98,50,82,78,4,34,-34,78,64,32,58,-94,40,50,0,-92,-36,10,-54,58,-78,-88,32,6};
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,1,1,1,1,1};
int param0_9[] = {80,67,30,35,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[] = {13,11,1,20,20,15,12,23,24,2};
int param2[] = {11,18,1,20,15,17,17,28,17,3};
int param3[] = {18,21,1,15,15,22,14,28,22,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;
} | x: | [
"a) )",
"b) x:",
"c) /",
"d) f_gold",
"e) i"
] | 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 * dp = new int [ n + 1 ];
dp [ 0 ] = 0;
dp [ 1 ] = 1;
dp [ 2 ] = 2;
dp [ 3 ] = 3;
for ( int i = 4;
i <= n;
i ++ ) {
dp [ i ] = i;
for ( int x = 1;
x <= ceil ( sqrt ( i ) );
x ++ ) {
int temp = x * x;
if ( temp > i ) break;
else dp [ i ] = min ( dp [ i ], 1 + dp [ i - temp ] );
}
}
int res = dp [ n ];
delete [ ] dp;
return res;
}
int f_filled ( int n ) {}
temp = x * x;
if ( temp > i ) break;
else dp [ i ] = min ( dp [ i ], 1 + dp [ i - temp ] );
}
}
int res = dp [ n ];
delete [ ] dp;
return res;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {16,33,47,98,36,81,55,19,4,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; } 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 * dp = new int [ n + 1 ]; dp [ 0 ] = 0; dp [ 1 ] = 1; dp [ 2 ] = 2; dp [ 3 ] = 3; for ( int i = 4; i <= n; i ++ ) { dp [ i ] = i; for ( int x = 1; x <= ceil ( sqrt ( i ) ); x ++ ) { int temp = x * x; if ( temp > i ) break; [MASK] dp [ i ] = min ( dp [ i ], 1 + dp [ i - temp ] ); } } int res = dp [ n ]; delete [ ] dp; return res; } int f_filled ( int n ) {} temp = x * x;
if ( temp > i ) break;
else dp [ i ] = min ( dp [ i ], 1 + dp [ i - temp ] );
}
}
int res = dp [ n ];
delete [ ] dp;
return res;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {16,33,47,98,36,81,55,19,4,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;
} | else | [
"a) <=",
"b) <string>",
"c) ;",
"d) else",
"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 ( char n [] ) {
char num [] = n;
int dec_value = 0;
int base = 1;
int len = strlen(num);
for ( int i = len - 1;
i >= 0;
i -- ) {
if ( num [ i ] == '1' ) dec_value += base;
base = base * 2;
}
return dec_value;
}
int f_filled ( char n [] ) {}
int len = strlen(num);
for ( int i = len - 1;
i >= 0;
i -- ) {
if ( num [ i ] == '1' ) dec_value += base;
base = base * 2;
}
return dec_value;
}
int f_filled ( char n [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"uEmIAgF","753310137","010011010","kNi","04562016903312","000111101","bk","9","1","XxT nXLlk"};
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, [MASK] cmpfunc);} int f_gold ( char n [] ) { char num [] = n; int dec_value = 0; int base = 1; int len = strlen(num); for ( int i = len - 1; i >= 0; i -- ) { if ( num [ i ] == '1' ) dec_value += base; base = base * 2; } return dec_value; } int f_filled ( char n [] ) {}
int len = strlen(num);
for ( int i = len - 1;
i >= 0;
i -- ) {
if ( num [ i ] == '1' ) dec_value += base;
base = base * 2;
}
return dec_value;
}
int f_filled ( char n [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"uEmIAgF","753310137","010011010","kNi","04562016903312","000111101","bk","9","1","XxT nXLlk"};
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(int), | [
"a) javafx.util.Pair;",
"b) sizeof(int),",
"c) {",
"d) int",
"e) int"
] | 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 n ) {
sort ( A, A + n );
sort ( B, B + n );
int result = 0;
for ( int i = 0;
i < n;
i ++ ) result += ( A [ i ] * B [ n - i - 1 ] );
return result;
}
int f_filled ( int A [ ], int B [ ], int n ) {}
A, A + n );
sort ( B, B + n );
int result = 0;
for ( int i = 0;
i < n;
i ++ ) result += ( A [ i ] * B [ n - i - 1 ] );
return result;
}
int f_filled ( int A [ ], int B [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {31,85};
int param0_1[] = {22,-6,84,70,84,6,28,-74,-14,68,22,90,-10};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_3[] = {12,33,93,2,83,9,61,84,9,69,2};
int param0_4[] = {-92,-88,-84,-78,-78,-76,-66,-54,-52,-48,-46,-44,-40,-34,-32,-24,-20,-14,-6,-4,2,6,10,10,22,26,32,36,36,40,46,48,56,58,64,76,80,80,80,84,84,84,92};
int param0_5[] = {1,0,1,1,0,1,1,0,1,0,0,1,1,1,0,0,0,0,0,0,1,0,1,1,0,1,0,1,1,0,0,0,1,0};
int param0_6[] = {4,6,6,20,22,23,26,39,40,47,50,68,68,70,73,77,80,82,85};
int param0_7[] = {78,60,-8,46,-12};
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,1,1,1};
int param0_9[] = {60,66,84,99,85,89,28,97,85,71,53,93,23,9,45,26,49,95,64,33,70,34,10,1,68,39,53,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_0[] = {18,33};
int param1_1[] = {2,-48,-36,-4,-22,-98,-74,-92,-72,-4,48,-32,94};
int param1_2[] = {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param1_3[] = {85,92,92,1,54,31,69,4,39,81,52};
int param1_4[] = {-98,-90,-82,-80,-76,-66,-62,-62,-62,-50,-50,-50,-32,-30,-14,-12,4,6,12,14,16,30,30,30,32,34,40,42,50,52,56,58,60,62,62,64,66,68,78,82,86,90,94};
int param1_5[] = {0,1,1,1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,1,1,0,1,1,0,0,1,1,0,0,0,0,1,1,1};
int param1_6[] = {2,3,15,21,22,26,35,37,37,38,57,59,62,63,64,76,81,85,91};
int param1_7[] = {-72,-80,-30,16,-38};
int param1_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};
int param1_9[] = {37,33,33,77,78,34,28,1,63,15,51,50,90,22,71,23,68,55,2,22,31,54,76,36,2,27,96,89};
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[] = {1,6,14,7,26,32,17,2,17,15};
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 n ) { sort ( A, A + n ); sort ( B, B + n ); int result = 0; for ( int i = 0; [MASK] < n; i ++ ) result += ( A [ i ] * B [ n - i - 1 ] ); return result; } int f_filled ( int A [ ], int B [ ], int n ) {}A, A + n );
sort ( B, B + n );
int result = 0;
for ( int i = 0;
i < n;
i ++ ) result += ( A [ i ] * B [ n - i - 1 ] );
return result;
}
int f_filled ( int A [ ], int B [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {31,85};
int param0_1[] = {22,-6,84,70,84,6,28,-74,-14,68,22,90,-10};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_3[] = {12,33,93,2,83,9,61,84,9,69,2};
int param0_4[] = {-92,-88,-84,-78,-78,-76,-66,-54,-52,-48,-46,-44,-40,-34,-32,-24,-20,-14,-6,-4,2,6,10,10,22,26,32,36,36,40,46,48,56,58,64,76,80,80,80,84,84,84,92};
int param0_5[] = {1,0,1,1,0,1,1,0,1,0,0,1,1,1,0,0,0,0,0,0,1,0,1,1,0,1,0,1,1,0,0,0,1,0};
int param0_6[] = {4,6,6,20,22,23,26,39,40,47,50,68,68,70,73,77,80,82,85};
int param0_7[] = {78,60,-8,46,-12};
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,1,1,1};
int param0_9[] = {60,66,84,99,85,89,28,97,85,71,53,93,23,9,45,26,49,95,64,33,70,34,10,1,68,39,53,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_0[] = {18,33};
int param1_1[] = {2,-48,-36,-4,-22,-98,-74,-92,-72,-4,48,-32,94};
int param1_2[] = {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param1_3[] = {85,92,92,1,54,31,69,4,39,81,52};
int param1_4[] = {-98,-90,-82,-80,-76,-66,-62,-62,-62,-50,-50,-50,-32,-30,-14,-12,4,6,12,14,16,30,30,30,32,34,40,42,50,52,56,58,60,62,62,64,66,68,78,82,86,90,94};
int param1_5[] = {0,1,1,1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,1,1,0,1,1,0,0,1,1,0,0,0,0,1,1,1};
int param1_6[] = {2,3,15,21,22,26,35,37,37,38,57,59,62,63,64,76,81,85,91};
int param1_7[] = {-72,-80,-30,16,-38};
int param1_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};
int param1_9[] = {37,33,33,77,78,34,28,1,63,15,51,50,90,22,71,23,68,55,2,22,31,54,76,36,2,27,96,89};
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[] = {1,6,14,7,26,32,17,2,17,15};
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;
} | i | [
"a) (",
"b) )",
"c) [",
"d) return",
"e) i"
] | 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 sum = 0;
for ( int i = 0;
i <= n;
i ++ ) sum += C [ n ] [ i ];
return sum;
}
int f_filled ( int n ) {}
else C [ i ] [ j ] = C [ i - 1 ] [ j - 1 ] + C [ i - 1 ] [ j ];
}
}
int sum = 0;
for ( int i = 0;
i <= n;
i ++ ) sum += C [ n ] [ i ];
return sum;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {8,39,25,44,72,6,72,62,48,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 > 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 ) { 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 sum = 0; for ( int i = 0; i <= n; i ++ ) sum += C [ n ] [ i ]; return sum; } int f_filled ( int n ) {} else C [ i ] [ j ] = C [ i - 1 ] [ j - 1 ] + C [ i - 1 ] [ j ];
}
}
int sum = 0;
for ( int i = 0;
i <= n;
i ++ ) sum += C [ n ] [ i ];
return sum;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {8,39,25,44,72,6,72,62,48,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) sizeof",
"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);}
char f_gold [] ( int n, int k ) {
char res [] = "";
for ( int i = 0;
i < k;
i ++ ) res = res + ( char ) ( 'a' + i );
int count = 0;
for ( int i = 0;
i < n - k;
i ++ ) {
res = res + ( char ) ( 'a' + count );
count ++;
if ( count == k ) count = 0;
}
return res;
}
char f_filled [] ( int n, int k ) {}
t = 0;
for ( int i = 0;
i < n - k;
i ++ ) {
res = res + ( char ) ( 'a' + count );
count ++;
if ( count == k ) count = 0;
}
return res;
}
char f_filled [] ( int n, int k ) {}
int main(void) {
int n_success = 0;
int param0[] = {60,56,16,42,55,64,68,88,64,42};
int param1[] = {71,17,16,60,56,59,24,2,94,79};
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] 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 [] ( int n, int k ) { char res [] = ""; for ( int i = 0; i < k; i ++ ) res = res + ( char ) ( 'a' + i ); int count = 0; for ( int i = 0; i < n - k; i ++ ) { res = res + ( char ) ( 'a' + count ); count ++; if ( count == k ) count = 0; } return res; } char f_filled [] ( int n, int k ) {}t = 0;
for ( int i = 0;
i < n - k;
i ++ ) {
res = res + ( char ) ( 'a' + count );
count ++;
if ( count == k ) count = 0;
}
return res;
}
char f_filled [] ( int n, int k ) {}
int main(void) {
int n_success = 0;
int param0[] = {60,56,16,42,55,64,68,88,64,42};
int param1[] = {71,17,16,60,56,59,24,2,94,79};
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) in",
"b) .",
"c) import",
"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 ( int arr [ ], int n ) {
sort ( arr, arr + n, greater < int > ( ) );
int dimension [ 2 ] = {
0, 0 };
for ( int i = 0, j = 0;
i < n - 1 && j < 2;
i ++ ) if ( arr [ i ] == arr [ i + 1 ] ) dimension [ j ++ ] = arr [ i ++ ];
return ( dimension [ 0 ] * dimension [ 1 ] );
}
int f_filled ( int arr [ ], int n ) {}
i < n - 1 && j < 2;
i ++ ) if ( arr [ i ] == arr [ i + 1 ] ) dimension [ j ++ ] = arr [ i ++ ];
return ( dimension [ 0 ] * dimension [ 1 ] );
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,5,6,8,9,11,12,14,16,17,24,25,36,40,44,47,49,51,51,52,67,68,72,74,81,82,83,84,92,95,95,96,99};
int param0_1[] = {-54,-82,-92,-32};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {16,62,17,15,26,45,2,17,65,94,96,30,68,44,96,60,99};
int param0_4[] = {-88,-82,-78,-52,-50,-42,-34,-28,16,46,54,56,66,66,74,82,82,94,98};
int param0_5[] = {0,1,0,0,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,1,1,1,0};
int param0_6[] = {1,6,8,8,8,10,13,14,14,23,24,25,27,28,29,30,33,38,43,44,49,52,56,58,62,63,64,65,65,68,75,85,85,87,93,96,97};
int param0_7[] = {-90,-56,16,32,78,-20,76,-90,-68,-70,54,50,60,-64,78,-6,-92,6,16,70};
int param0_8[] = {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[] = {55,51,90,10,14,5,57,22,75,29,7,18,31,43,84,35,71,94,4,51,94,30,94,53,82};
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,2,15,8,15,18,20,19,30,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> [MASK] <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, greater < int > ( ) ); int dimension [ 2 ] = { 0, 0 }; for ( int i = 0, j = 0; i < n - 1 && j < 2; i ++ ) if ( arr [ i ] == arr [ i + 1 ] ) dimension [ j ++ ] = arr [ i ++ ]; return ( dimension [ 0 ] * dimension [ 1 ] ); } int f_filled ( int arr [ ], int n ) {} i < n - 1 && j < 2;
i ++ ) if ( arr [ i ] == arr [ i + 1 ] ) dimension [ j ++ ] = arr [ i ++ ];
return ( dimension [ 0 ] * dimension [ 1 ] );
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,5,6,8,9,11,12,14,16,17,24,25,36,40,44,47,49,51,51,52,67,68,72,74,81,82,83,84,92,95,95,96,99};
int param0_1[] = {-54,-82,-92,-32};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {16,62,17,15,26,45,2,17,65,94,96,30,68,44,96,60,99};
int param0_4[] = {-88,-82,-78,-52,-50,-42,-34,-28,16,46,54,56,66,66,74,82,82,94,98};
int param0_5[] = {0,1,0,0,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,1,1,1,0};
int param0_6[] = {1,6,8,8,8,10,13,14,14,23,24,25,27,28,29,30,33,38,43,44,49,52,56,58,62,63,64,65,65,68,75,85,85,87,93,96,97};
int param0_7[] = {-90,-56,16,32,78,-20,76,-90,-68,-70,54,50,60,-64,78,-6,-92,6,16,70};
int param0_8[] = {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[] = {55,51,90,10,14,5,57,22,75,29,7,18,31,43,84,35,71,94,4,51,94,30,94,53,82};
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,2,15,8,15,18,20,19,30,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 | [
"a) }",
"b) }",
"c) 1",
"d) #include",
"e) if"
] | 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 sum ) {
unordered_map < int, int > prevSum;
int res = 0;
int currsum = 0;
for ( int i = 0;
i < n;
i ++ ) {
currsum += arr [ i ];
if ( currsum == sum ) res ++;
if ( prevSum . find ( currsum - sum ) != prevSum . end ( ) ) res += ( prevSum [ currsum - sum ] );
prevSum [ currsum ] ++;
}
return res;
}
int f_filled ( int arr [ ], int n, int sum ) {}
if ( prevSum . find ( currsum - sum ) != prevSum . end ( ) ) res += ( prevSum [ currsum - sum ] );
prevSum [ currsum ] ++;
}
return res;
}
int f_filled ( int arr [ ], int n, int sum ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,18,27,52,70,91};
int param0_1[] = {60,-88,-48,90,-28,20,18,34,-58,76,-78,-18,68,-48,8,34,60,-34,-10,32,78,-84,-22,54,-18,-82,-70,-58,-20,-76,88,-30,-6,68};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1};
int param0_3[] = {67,39,22,32,59,44,86,26,46,60,99,12,32,46,16,22,45,85,21,92,77,50,65,23,93,26,23,20,32,83,60,22,11,45,99,31,72};
int param0_4[] = {-86,-84,-82,-82,-28,-12,4,24,62,72};
int param0_5[] = {1,0,0,1,0,1,1,1,0,1,1,1,0,0,1,1,1,1};
int param0_6[] = {8,20,25,27,28,28,30,31,32,36,39,41,51,53,53,54,56,58,59,77,78,85,88,92,99};
int param0_7[] = {60,40,-96,-76,-34,-18,38,-62,50,56,64,-94,-50,50,-80,42,-66,-42,68,70,78,-18,-24,-48,-92,64,14,24,-94,-98,18,44,-58};
int param0_8[] = {0,0,0,0,1,1,1,1,1,1,1,1};
int param0_9[] = {73,52,37,80,4,26,3,76,32,79,31,32,8,87,42,50,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[] = {5,32,11,25,7,16,13,22,11,8};
int param2[] = {4,30,11,25,5,13,18,17,8,14};
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 sum ) { unordered_map < int, int > prevSum; int res = 0; int currsum = 0; for ( int i = 0; i < n; i ++ ) [MASK] currsum += arr [ i ]; if ( currsum == sum ) res ++; if ( prevSum . find ( currsum - sum ) != prevSum . end ( ) ) res += ( prevSum [ currsum - sum ] ); prevSum [ currsum ] ++; } return res; } int f_filled ( int arr [ ], int n, int sum ) {} if ( prevSum . find ( currsum - sum ) != prevSum . end ( ) ) res += ( prevSum [ currsum - sum ] );
prevSum [ currsum ] ++;
}
return res;
}
int f_filled ( int arr [ ], int n, int sum ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,18,27,52,70,91};
int param0_1[] = {60,-88,-48,90,-28,20,18,34,-58,76,-78,-18,68,-48,8,34,60,-34,-10,32,78,-84,-22,54,-18,-82,-70,-58,-20,-76,88,-30,-6,68};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1};
int param0_3[] = {67,39,22,32,59,44,86,26,46,60,99,12,32,46,16,22,45,85,21,92,77,50,65,23,93,26,23,20,32,83,60,22,11,45,99,31,72};
int param0_4[] = {-86,-84,-82,-82,-28,-12,4,24,62,72};
int param0_5[] = {1,0,0,1,0,1,1,1,0,1,1,1,0,0,1,1,1,1};
int param0_6[] = {8,20,25,27,28,28,30,31,32,36,39,41,51,53,53,54,56,58,59,77,78,85,88,92,99};
int param0_7[] = {60,40,-96,-76,-34,-18,38,-62,50,56,64,-94,-50,50,-80,42,-66,-42,68,70,78,-18,-24,-48,-92,64,14,24,-94,-98,18,44,-58};
int param0_8[] = {0,0,0,0,1,1,1,1,1,1,1,1};
int param0_9[] = {73,52,37,80,4,26,3,76,32,79,31,32,8,87,42,50,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[] = {5,32,11,25,7,16,13,22,11,8};
int param2[] = {4,30,11,25,5,13,18,17,8,14};
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) 0.0246",
"c) for",
"d) #include",
"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 size ) {
int max_so_far = INT_MIN, max_ending_here = 0, start = 0, end = 0, s = 0;
for ( int i = 0;
i < size;
i ++ ) {
max_ending_here += a [ i ];
if ( max_so_far < max_ending_here ) {
max_so_far = max_ending_here;
start = s;
end = i;
}
if ( max_ending_here < 0 ) {
max_ending_here = 0;
s = i + 1;
}
}
return ( end - start + 1 );
}
int f_filled ( int a [ ], int size ) {}
start = s;
end = i;
}
if ( max_ending_here < 0 ) {
max_ending_here = 0;
s = i + 1;
}
}
return ( end - start + 1 );
}
int f_filled ( int a [ ], int size ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,7,16,20,21,22,34,34,37,37,49,53,54,55,58,59,60,66,67,68,73,80,80,88,90,98,99,99};
int param0_1[] = {-90,-98,-10,-84,24};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_3[] = {94,2,83,94,10,94,58,99,60,19,3,71,36,84,71,14,50,15};
int param0_4[] = {-98,-96,-70,-64,-56,-38,-34,-24,-22,-2,26,32,36,50,62,70,70,72,72,74,78,82,84,86};
int param0_5[] = {0,1,0,1,1,1,0,0,0,1,1,1,0,0,1,0,1,1,0,0,0,0,1,1,0,0,0,1,1,0,0,0,0,1,1,0,1,0,1,0};
int param0_6[] = {1,2,2,5,13,14,15,18,21,34,42,48,50,63,67,68,69,75,80,80,81,83,84,89,90,90,91,92,95,98};
int param0_7[] = {-88,-10,-88,-90,92,14,68,-90,-86};
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,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {28,39,90,39,12,90,24,89,54,44,3,26,44,36,67,92,3,79,10,45,22,21,39,91,2,5,72,21,55,48,75,47};
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[] = {21,2,19,14,13,35,22,5,24,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);} int f_gold ( int a [ ], int size ) { int max_so_far = INT_MIN, max_ending_here = 0, start = 0, end = 0, s = 0; for ( int i = 0; i < size; i ++ ) { max_ending_here += a [ i ]; if ( max_so_far < max_ending_here ) { max_so_far = max_ending_here; start = s; end = i; } if ( max_ending_here < 0 ) { max_ending_here = 0; s = i + 1; } } return [MASK] end - start + 1 ); } int f_filled ( int a [ ], int size ) {} start = s;
end = i;
}
if ( max_ending_here < 0 ) {
max_ending_here = 0;
s = i + 1;
}
}
return ( end - start + 1 );
}
int f_filled ( int a [ ], int size ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,7,16,20,21,22,34,34,37,37,49,53,54,55,58,59,60,66,67,68,73,80,80,88,90,98,99,99};
int param0_1[] = {-90,-98,-10,-84,24};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_3[] = {94,2,83,94,10,94,58,99,60,19,3,71,36,84,71,14,50,15};
int param0_4[] = {-98,-96,-70,-64,-56,-38,-34,-24,-22,-2,26,32,36,50,62,70,70,72,72,74,78,82,84,86};
int param0_5[] = {0,1,0,1,1,1,0,0,0,1,1,1,0,0,1,0,1,1,0,0,0,0,1,1,0,0,0,1,1,0,0,0,0,1,1,0,1,0,1,0};
int param0_6[] = {1,2,2,5,13,14,15,18,21,34,42,48,50,63,67,68,69,75,80,80,81,83,84,89,90,90,91,92,95,98};
int param0_7[] = {-88,-10,-88,-90,92,14,68,-90,-86};
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,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {28,39,90,39,12,90,24,89,54,44,3,26,44,36,67,92,3,79,10,45,22,21,39,91,2,5,72,21,55,48,75,47};
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[] = {21,2,19,14,13,35,22,5,24,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;
} | ( | [
"a) .",
"b) =",
"c) (",
"d) str",
"e) ((int)"
] | 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 price [ ], int n, int k ) {
int profit [ k + 1 ] [ n + 1 ];
for ( int i = 0;
i <= k;
i ++ ) profit [ i ] [ 0 ] = 0;
for ( int j = 0;
j <= n;
j ++ ) profit [ 0 ] [ j ] = 0;
for ( int i = 1;
i <= k;
i ++ ) {
for ( int j = 1;
j < n;
j ++ ) {
int max_so_far = INT_MIN;
for ( int m = 0;
m < j;
m ++ ) max_so_far = max ( max_so_far, price [ j ] - price [ m ] + profit [ i - 1 ] [ m ] );
profit [ i ] [ j ] = max ( profit [ i ] [ j - 1 ], max_so_far );
}
}
return profit [ k ] [ n - 1 ];
}
int f_filled ( int price [ ], int n, int k ) {}
m ] + profit [ i - 1 ] [ m ] );
profit [ i ] [ j ] = max ( profit [ i ] [ j - 1 ], max_so_far );
}
}
return profit [ k ] [ n - 1 ];
}
int f_filled ( int price [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,5,9,11,18,27,46,49,60,70,83,96};
int param0_1[] = {44};
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};
int param0_3[] = {53,72,2,6,99,56,73,2,72,14,23,5,66,73,45,38,96,35,75,48,73,68,41,53,10,18,95,68,48,70,87,53,95,26,35,37,56,35,93,3,44,38,3,16,62,63,21,65};
int param0_4[] = {-98,-92,-84,-80,-78,-74,-56,-54,-52,-48,-48,-30,-26,-20,-16,-12,-10,-8,-2,0,8,26,34,36,44,46,48,56,60,60,66,68,72,72,78,80,84,84,94,96};
int param0_5[] = {1,1,1,0,1,0,1,1,0,1,0,1,0};
int param0_6[] = {3,3,7,8,9,13,14,14,18,19,20,22,23,23,24,25,27,30,33,34,34,35,39,40,41,43,43,47,48,50,54,55,59,64,68,70,74,74,74,76,90,90,91,94,94,94,96,99};
int param0_7[] = {78,78,-12,32,-12,-12,-4,-8,12,60,12,-74,-52,-60,-62,76,12,24,32,-6,-70,-34,-44,50,62,-52,-32,18,44,-74,18,94,78,-44,-90,-32,44,-72,28,-34,56,98,66};
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[] = {50,81,12,65};
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,0,18,47,30,11,24,40,44,2};
int param2[] = {10,0,22,25,23,8,26,24,24,2};
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 [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 price [ ], int n, int k ) { int profit [ k + 1 ] [ n + 1 ]; for ( int i = 0; i <= k; i ++ ) profit [ i ] [ 0 ] = 0; for ( int j = 0; j <= n; j ++ ) profit [ 0 ] [ j ] = 0; for ( int i = 1; i <= k; i ++ ) { for ( int j = 1; j < n; j ++ ) { int max_so_far = INT_MIN; for ( int m = 0; m < j; m ++ ) max_so_far = max ( max_so_far, price [ j ] - price [ m ] + profit [ i - 1 ] [ m ] ); profit [ i ] [ j ] = max ( profit [ i ] [ j - 1 ], max_so_far ); } } return profit [ k ] [ n - 1 ]; } int f_filled ( int price [ ], int n, int k ) {}m ] + profit [ i - 1 ] [ m ] );
profit [ i ] [ j ] = max ( profit [ i ] [ j - 1 ], max_so_far );
}
}
return profit [ k ] [ n - 1 ];
}
int f_filled ( int price [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,5,9,11,18,27,46,49,60,70,83,96};
int param0_1[] = {44};
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};
int param0_3[] = {53,72,2,6,99,56,73,2,72,14,23,5,66,73,45,38,96,35,75,48,73,68,41,53,10,18,95,68,48,70,87,53,95,26,35,37,56,35,93,3,44,38,3,16,62,63,21,65};
int param0_4[] = {-98,-92,-84,-80,-78,-74,-56,-54,-52,-48,-48,-30,-26,-20,-16,-12,-10,-8,-2,0,8,26,34,36,44,46,48,56,60,60,66,68,72,72,78,80,84,84,94,96};
int param0_5[] = {1,1,1,0,1,0,1,1,0,1,0,1,0};
int param0_6[] = {3,3,7,8,9,13,14,14,18,19,20,22,23,23,24,25,27,30,33,34,34,35,39,40,41,43,43,47,48,50,54,55,59,64,68,70,74,74,74,76,90,90,91,94,94,94,96,99};
int param0_7[] = {78,78,-12,32,-12,-12,-4,-8,12,60,12,-74,-52,-60,-62,76,12,24,32,-6,-70,-34,-44,50,62,-52,-32,18,44,-74,18,94,78,-44,-90,-32,44,-72,28,-34,56,98,66};
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[] = {50,81,12,65};
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,0,18,47,30,11,24,40,44,2};
int param2[] = {10,0,22,25,23,8,26,24,24,2};
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) \"0\"",
"c) );}",
"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);}
int f_gold ( int arr [ ], int n, int k ) {
if ( k > n ) return - 1;
int sum = arr [ 0 ];
for ( int i = 1;
i < k;
i ++ ) sum += arr [ i ];
int max_sum = sum, max_end = k - 1;
for ( int i = k;
i < n;
i ++ ) {
int sum = sum + arr [ i ] - arr [ i - k ];
if ( sum > max_sum ) {
max_sum = sum;
max_end = i;
}
}
return max_end - k + 1;
}
int f_filled ( int arr [ ], int n, int k ) {}
int sum = sum + arr [ i ] - arr [ i - k ];
if ( sum > max_sum ) {
max_sum = sum;
max_end = i;
}
}
return max_end - k + 1;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,5,11,37,41,49,49,63,98};
int param0_1[] = {84,-72,12,0,86,-32,-18,48,60,42,8,-6,-10,-6,-52,-84,-98,76,-10,-14,-94,-48,94,-10,-20,40,-52,0,94,-68,44,-34,-26,-6,-94,34,-80,-62,-40,56,52,-20,74,-46,-88,-26,22};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {94,97,74,88,14,66,65,50,76,55,70,93,53,30,2,60,65,24,80,73,84,95,49,32,55,70,17,26,96,20,36,2,89,49,83,67,42,51,71,11,61,78,17,78,94,68};
int param0_4[] = {-98,-90,-60,-38,38,42};
int param0_5[] = {1,0,0,1,1,1,1};
int param0_6[] = {4,9,17,17,19,32,35,36,37,40,44,45,47,48,48,56,56,60,61,65,66,79,83,91,93,99};
int param0_7[] = {78,82,-92,-46,-16,-64,28,60,64,52,54,-84,70,22,24,0,-14,20,-90,30,0,86,12,72,-64,-52,86,16,-42};
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};
int param0_9[] = {81,77,6,3,72,24,75,47,17,29,69,15,15,50,30,83,11,7,59,7,12,82,45,76,9,48,98,49,29,66,3,53,37,13,72,58,37,87,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[] = {8,34,11,35,3,3,22,25,25,34};
int param2[] = {7,43,18,33,5,4,24,27,20,23};
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] 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 ) { if ( k > n ) return - 1; int sum = arr [ 0 ]; for ( int i = 1; i < k; i ++ ) sum += arr [ i ]; int max_sum = sum, max_end = k - 1; for ( int i = k; i < n; i ++ ) { int sum = sum + arr [ i ] - arr [ i - k ]; if ( sum > max_sum ) { max_sum = sum; max_end = i; } } return max_end - k + 1; } int f_filled ( int arr [ ], int n, int k ) {} int sum = sum + arr [ i ] - arr [ i - k ];
if ( sum > max_sum ) {
max_sum = sum;
max_end = i;
}
}
return max_end - k + 1;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,5,11,37,41,49,49,63,98};
int param0_1[] = {84,-72,12,0,86,-32,-18,48,60,42,8,-6,-10,-6,-52,-84,-98,76,-10,-14,-94,-48,94,-10,-20,40,-52,0,94,-68,44,-34,-26,-6,-94,34,-80,-62,-40,56,52,-20,74,-46,-88,-26,22};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {94,97,74,88,14,66,65,50,76,55,70,93,53,30,2,60,65,24,80,73,84,95,49,32,55,70,17,26,96,20,36,2,89,49,83,67,42,51,71,11,61,78,17,78,94,68};
int param0_4[] = {-98,-90,-60,-38,38,42};
int param0_5[] = {1,0,0,1,1,1,1};
int param0_6[] = {4,9,17,17,19,32,35,36,37,40,44,45,47,48,48,56,56,60,61,65,66,79,83,91,93,99};
int param0_7[] = {78,82,-92,-46,-16,-64,28,60,64,52,54,-84,70,22,24,0,-14,20,-90,30,0,86,12,72,-64,-52,86,16,-42};
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};
int param0_9[] = {81,77,6,3,72,24,75,47,17,29,69,15,15,50,30,83,11,7,59,7,12,82,45,76,9,48,98,49,29,66,3,53,37,13,72,58,37,87,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[] = {8,34,11,35,3,3,22,25,25,34};
int param2[] = {7,43,18,33,5,4,24,27,20,23};
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) [",
"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 k ) {
int sum [ n + 1 ];
sum [ 0 ] = 0;
sum [ 1 ] = arr [ 0 ];
for ( int i = 2;
i <= n;
i ++ ) sum [ i ] = sum [ i - 1 ] + arr [ i - 1 ];
priority_queue < int, vector < int >, greater < int > > Q;
for ( int i = 1;
i <= n;
i ++ ) {
for ( int j = i;
j <= n;
j ++ ) {
int x = sum [ j ] - sum [ i - 1 ];
if ( len(Q) < k ) Q . push ( x );
else {
if ( Q . top ( ) < x ) {
Q . pop ( );
Q . push ( x );
}
}
}
}
return Q . top ( );
}
int f_filled ( int arr [ ], int n, int k ) {}
);
else {
if ( Q . top ( ) < x ) {
Q . pop ( );
Q . push ( x );
}
}
}
}
return Q . top ( );
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,3,5,7,8,29,29,44,47,52,60,65,73,83,87,92,92,95};
int param0_1[] = {44,-98,-10,14,-6,-46,6,-74,-4,36,10,-2,30,28,96,-84,-36,-76,64,-74,-20,94,-4,14,78,52,-56,98,-68,-76,-10,20,88,-98,96,80,96,-32,-40,-30,82};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {58,21,97,78,78,57,29,33,57,81,66,32,11,82,28,72,46,67,42,15,60,45,16,37};
int param0_4[] = {-92,-90,-88,-84,-68,-66,-62,-58,-52,-44,-22,-16,-4,-4,2,12,14,14,24,26,44,56,80,90,92,94,98};
int param0_5[] = {1,1,1,1,1,1,1,1,0,0,0};
int param0_6[] = {3,4,8,12,13,14,17,19,23,24,28,29,30,35,35,38,44,47,47,53,55,56,56,58,66,67,70,71,72,73,74,75,77,78,82,84,87,87,87,88,88,93,94,96};
int param0_7[] = {20,-58,94,-70,18,16,-46,38,-44,-92,-20,-70,-30,50};
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};
int param0_9[] = {90,77,82,38,96,62,66,4,93,30,75,22,26,61,40,11,38,55,88,24,66,47,40,71,21,5,18,31,26,56,19,47,71,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[] = {10,34,16,14,15,5,26,11,19,28};
int param2[] = {12,37,15,20,25,5,25,7,23,32};
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 sum [ n + 1 ]; sum [ 0 ] = 0; sum [ 1 ] = [MASK] [ 0 ]; for ( int i = 2; i <= n; i ++ ) sum [ i ] = sum [ i - 1 ] + arr [ i - 1 ]; priority_queue < int, vector < int >, greater < int > > Q; for ( int i = 1; i <= n; i ++ ) { for ( int j = i; j <= n; j ++ ) { int x = sum [ j ] - sum [ i - 1 ]; if ( len(Q) < k ) Q . push ( x ); else { if ( Q . top ( ) < x ) { Q . pop ( ); Q . push ( x ); } } } } return Q . top ( ); } int f_filled ( int arr [ ], int n, int k ) {});
else {
if ( Q . top ( ) < x ) {
Q . pop ( );
Q . push ( x );
}
}
}
}
return Q . top ( );
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,3,5,7,8,29,29,44,47,52,60,65,73,83,87,92,92,95};
int param0_1[] = {44,-98,-10,14,-6,-46,6,-74,-4,36,10,-2,30,28,96,-84,-36,-76,64,-74,-20,94,-4,14,78,52,-56,98,-68,-76,-10,20,88,-98,96,80,96,-32,-40,-30,82};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {58,21,97,78,78,57,29,33,57,81,66,32,11,82,28,72,46,67,42,15,60,45,16,37};
int param0_4[] = {-92,-90,-88,-84,-68,-66,-62,-58,-52,-44,-22,-16,-4,-4,2,12,14,14,24,26,44,56,80,90,92,94,98};
int param0_5[] = {1,1,1,1,1,1,1,1,0,0,0};
int param0_6[] = {3,4,8,12,13,14,17,19,23,24,28,29,30,35,35,38,44,47,47,53,55,56,56,58,66,67,70,71,72,73,74,75,77,78,82,84,87,87,87,88,88,93,94,96};
int param0_7[] = {20,-58,94,-70,18,16,-46,38,-44,-92,-20,-70,-30,50};
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};
int param0_9[] = {90,77,82,38,96,62,66,4,93,30,75,22,26,61,40,11,38,55,88,24,66,47,40,71,21,5,18,31,26,56,19,47,71,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[] = {10,34,16,14,15,5,26,11,19,28};
int param2[] = {12,37,15,20,25,5,25,7,23,32};
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;
} | arr | [
"a) ;",
"b) <=",
"c) [",
"d) arr",
"e) a"
] | 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 x, long int y ) {
if ( x == 1 ) return ( y == 1 );
long int pow = 1;
while ( pow < y ) pow *= x;
return ( pow == y );
}
bool f_filled ( int x, long int y ) {}
mpfunc);}
bool f_gold ( int x, long int y ) {
if ( x == 1 ) return ( y == 1 );
long int pow = 1;
while ( pow < y ) pow *= x;
return ( pow == y );
}
bool f_filled ( int x, long int y ) {}
int main(void) {
int n_success = 0;
int param0[] = {57,3,10,10,6,2,1,20,96,25};
int param1[] = {1,9,101,10000,46656,2048,40,79,98,5};
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 x, long int y ) { if ( x == 1 ) return ( y == 1 ); long int pow = 1; while ( pow < y ) pow *= x; return ( pow == y ); } bool f_filled ( int x, long int y [MASK] {}mpfunc);}
bool f_gold ( int x, long int y ) {
if ( x == 1 ) return ( y == 1 );
long int pow = 1;
while ( pow < y ) pow *= x;
return ( pow == y );
}
bool f_filled ( int x, long int y ) {}
int main(void) {
int n_success = 0;
int param0[] = {57,3,10,10,6,2,1,20,96,25};
int param1[] = {1,9,101,10000,46656,2048,40,79,98,5};
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) min_price",
"c) class",
"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 ) {
if ( n == 0 || n == 1 ) return n;
return max ( ( f_gold ( n / 2 ) + f_gold ( n / 3 ) + f_gold ( n / 4 ) ), n );
}
int f_filled ( int n ) {}
n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
if ( n == 0 || n == 1 ) return n;
return max ( ( f_gold ( n / 2 ) + f_gold ( n / 3 ) + f_gold ( n / 4 ) ), n );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {39,79,7,76,48,18,58,17,36,5};
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 [MASK] arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { if ( n == 0 || n == 1 ) return n; return max ( ( f_gold ( n / 2 ) + f_gold ( n / 3 ) + f_gold ( n / 4 ) ), n ); } int f_filled ( int n ) {} n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
if ( n == 0 || n == 1 ) return n;
return max ( ( f_gold ( n / 2 ) + f_gold ( n / 3 ) + f_gold ( n / 4 ) ), n );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {39,79,7,76,48,18,58,17,36,5};
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) a",
"b) int",
"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);}
unsigned int f_gold ( unsigned int n ) {
n --;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n ++;
return n;
}
unsigned int f_filled ( unsigned int n ) {}
);}
unsigned int f_gold ( unsigned int n ) {
n --;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n ++;
return n;
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {63,78,13,5,34,69,63,78,80,19};
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);} unsigned int f_gold ( unsigned int n ) { n --; n |= n >> 1; n |= n >> 2; n |= n >> 4; n |= n >> 8; n |= n >> 16; n ++; return n; } unsigned int f_filled ( unsigned int n ) {});}
unsigned int f_gold ( unsigned int n ) {
n --;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n ++;
return n;
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {63,78,13,5,34,69,63,78,80,19};
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) [",
"b) x:",
"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 arr [ ], int n ) {
int i, j;
int leftsum, rightsum;
for ( i = 0;
i < n;
++ i ) {
leftsum = 0;
for ( j = 0;
j < i;
j ++ ) leftsum += arr [ j ];
rightsum = 0;
for ( j = i + 1;
j < n;
j ++ ) rightsum += arr [ j ];
if ( leftsum == rightsum ) return i;
}
return - 1;
}
int f_filled ( int arr [ ], int n ) {}
arr [ j ];
rightsum = 0;
for ( j = i + 1;
j < n;
j ++ ) rightsum += arr [ j ];
if ( leftsum == rightsum ) return i;
}
return - 1;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,6,7,8,15,15,19,23,27,28,29,31,37,40,41,42,50,51,57,58,63,63,64,70,71,72,78,83,85,90,90};
int param0_1[] = {-68,-92};
int param0_2[] = {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[] = {80,74,45,81,62,88,90,54};
int param0_4[] = {-92,-84,-84,-66,-64,-50,-50,-48,-46,-44,-36,-36,-30,-24,-22,-16,-6,-2,24,48,54,62,66,74,74,80,82,88,98,98};
int param0_5[] = {0,0,1,1,0,0,1,0,1,0,1,1,0,1,0,0,1,1,0,0,1,1,1,1,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,1,1};
int param0_6[] = {2,6,11,12,14,36,45,49,52,52,58,63,70,73,74,80,82,89,89};
int param0_7[] = {16,-58,-14,-58,-36,-70,36,-8,-14,-78,-26,42,16,18,0,-44,32,50,-78,58,78,16,-34,-54,50,0,46,-12,52,-74,78,-82,-26,-72,-86,-14,86,40,-8};
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};
int param0_9[] = {58,82,79,77,84,79,39,98,53,84,19,9,93,30,6,82,8,43,17,44,62,21,34,86,98,44,81,14,82,54,44,53,36,33,2,68,19,37};
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,26,4,27,43,17,26,33,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 [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { [MASK] i, j; int leftsum, rightsum; for ( i = 0; i < n; ++ i ) { leftsum = 0; for ( j = 0; j < i; j ++ ) leftsum += arr [ j ]; rightsum = 0; for ( j = i + 1; j < n; j ++ ) rightsum += arr [ j ]; if ( leftsum == rightsum ) return i; } return - 1; } int f_filled ( int arr [ ], int n ) {} arr [ j ];
rightsum = 0;
for ( j = i + 1;
j < n;
j ++ ) rightsum += arr [ j ];
if ( leftsum == rightsum ) return i;
}
return - 1;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,6,7,8,15,15,19,23,27,28,29,31,37,40,41,42,50,51,57,58,63,63,64,70,71,72,78,83,85,90,90};
int param0_1[] = {-68,-92};
int param0_2[] = {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[] = {80,74,45,81,62,88,90,54};
int param0_4[] = {-92,-84,-84,-66,-64,-50,-50,-48,-46,-44,-36,-36,-30,-24,-22,-16,-6,-2,24,48,54,62,66,74,74,80,82,88,98,98};
int param0_5[] = {0,0,1,1,0,0,1,0,1,0,1,1,0,1,0,0,1,1,0,0,1,1,1,1,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,1,1};
int param0_6[] = {2,6,11,12,14,36,45,49,52,52,58,63,70,73,74,80,82,89,89};
int param0_7[] = {16,-58,-14,-58,-36,-70,36,-8,-14,-78,-26,42,16,18,0,-44,32,50,-78,58,78,16,-34,-54,50,0,46,-12,52,-74,78,-82,-26,-72,-86,-14,86,40,-8};
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};
int param0_9[] = {58,82,79,77,84,79,39,98,53,84,19,9,93,30,6,82,8,43,17,44,62,21,34,86,98,44,81,14,82,54,44,53,36,33,2,68,19,37};
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,26,4,27,43,17,26,33,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) long",
"b) res",
"c) #include",
"d) int",
"e) java.lang.*;"
] | 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);}
void f_gold ( int arr [ ], int n, int A, int B, int C ) {
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = A * arr [ i ] * arr [ i ] + B * arr [ i ] + C;
int index, maximum = INT_MIN;
for ( int i = 0;
i < n;
i ++ ) {
if ( maximum < arr [ i ] ) {
index = i;
maximum = arr [ i ];
}
}
int i = 0, j = n - 1;
int new_arr [ n ], k = 0;
while ( i < index && j > index ) {
if ( arr [ i ] < arr [ j ] ) new_arr [ k ++ ] = arr [ i ++ ];
else new_arr [ k ++ ] = arr [ j -- ];
}
while ( i < index ) new_arr [ k ++ ] = arr [ i ++ ];
while ( j > index ) new_arr [ k ++ ] = arr [ j -- ];
new_arr [ n - 1 ] = maximum;
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = new_arr [ i ];
}
void f_filled ( int arr [ ], int n, int A, int B, int C ) {}
ex ) new_arr [ k ++ ] = arr [ j -- ];
new_arr [ n - 1 ] = maximum;
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = new_arr [ i ];
}
void f_filled ( int arr [ ], int n, int A, int B, int C ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,30,49,65,78,85,85,92};
int param0_1[] = {-48,89,-60,66,71,-37,47,-50,61,41,-22,-3,90,-57,77,-64,22,8,-90,-5,-94,-43,29,-29,86,-79,-8,27,-20,-44,16};
int param0_2[] = {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};
int param0_3[] = {87,70,77,87,73,81,66,19,83,7,63,42,42,59,20,73,17,27,47,2,63,62,19,17,69,39,82,71,81,39,36,40,45,4,25,69,30,76,68,88,29,73,68,51,24,14,69,18};
int param0_4[] = {-91,-85,-77,-73,-70,-68,-24,-21,-12,-1,9,29,48,52,56,63,88};
int param0_5[] = {0,0,0,1,1,0,1,1,1,1};
int param0_6[] = {4,5,9,14,18,20,22,23,25,28,30,31,34,35,36,38,38,39,44,48,49,51,54,55,59,64,66,71,72,72,73,76,78,82,82,84,92,93,95};
int param0_7[] = {40,6,33,8,78,-58,2,24,40,3,46,94,-26,8,22,-83,96,-29,-38,-59,19,62,98,-55,-42,79,26,62,-56,-85,-22};
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};
int param0_9[] = {3,68,40,48,54,35,95,56,89,40,77,68,46,78,13,27,6,17,36,99,81,2,77,52,66,52,92,43,90,22,55,67,99,60,58};
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,18,25,33,8,7,22,20,23,28};
int param2[] = {4,20,26,42,12,8,33,16,21,21};
int param3[] = {5,20,15,35,8,6,19,19,19,23};
int param4[] = {4,23,18,41,8,7,25,16,23,23};
int filled_function_param0_0[] = {9,30,49,65,78,85,85,92};
int filled_function_param0_1[] = {-48,89,-60,66,71,-37,47,-50,61,41,-22,-3,90,-57,77,-64,22,8,-90,-5,-94,-43,29,-29,86,-79,-8,27,-20,-44,16};
int filled_function_param0_2[] = {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};
int filled_function_param0_3[] = {87,70,77,87,73,81,66,19,83,7,63,42,42,59,20,73,17,27,47,2,63,62,19,17,69,39,82,71,81,39,36,40,45,4,25,69,30,76,68,88,29,73,68,51,24,14,69,18};
int filled_function_param0_4[] = {-91,-85,-77,-73,-70,-68,-24,-21,-12,-1,9,29,48,52,56,63,88};
int filled_function_param0_5[] = {0,0,0,1,1,0,1,1,1,1};
int filled_function_param0_6[] = {4,5,9,14,18,20,22,23,25,28,30,31,34,35,36,38,38,39,44,48,49,51,54,55,59,64,66,71,72,72,73,76,78,82,82,84,92,93,95};
int filled_function_param0_7[] = {40,6,33,8,78,-58,2,24,40,3,46,94,-26,8,22,-83,96,-29,-38,-59,19,62,98,-55,-42,79,26,62,-56,-85,-22};
int filled_function_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};
int filled_function_param0_9[] = {3,68,40,48,54,35,95,56,89,40,77,68,46,78,13,27,6,17,36,99,81,2,77,52,66,52,92,43,90,22,55,67,99,60,58};
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[] = {4,18,25,33,8,7,22,20,23,28};
int filled_function_param2[] = {4,20,26,42,12,8,33,16,21,21};
int filled_function_param3[] = {5,20,15,35,8,6,19,19,19,23};
int filled_function_param4[] = {4,23,18,41,8,7,25,16,23,23};
for(int i = 0; i < len(param0); ++i)
{
f_filled(filled_function_param0[i],filled_function_param1[i],filled_function_param2[i],filled_function_param3[i],filled_function_param4[i]);
f_gold(param0[i],param1[i],param2[i],param3[i],param4[i]);
if(equal(begin(param0[i]), end(param0[i]), begin(filled_function_param0[i])) && param1[i] == filled_function_param1[i] && param2[i] == filled_function_param2[i] && param3[i] == filled_function_param3[i] && param4[i] == filled_function_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; [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, int A, int B, int C ) { for ( int i = 0; i < n; i ++ ) arr [ i ] = A * arr [ i ] * arr [ i ] + B * arr [ i ] + C; int index, maximum = INT_MIN; for ( int i = 0; i < n; i ++ ) { if ( maximum < arr [ i ] ) { index = i; maximum = arr [ i ]; } } int i = 0, j = n - 1; int new_arr [ n ], k = 0; while ( i < index && j > index ) { if ( arr [ i ] < arr [ j ] ) new_arr [ k ++ ] = arr [ i ++ ]; else new_arr [ k ++ ] = arr [ j -- ]; } while ( i < index ) new_arr [ k ++ ] = arr [ i ++ ]; while ( j > index ) new_arr [ k ++ ] = arr [ j -- ]; new_arr [ n - 1 ] = maximum; for ( int i = 0; i < n; i ++ ) arr [ i ] = new_arr [ i ]; } void f_filled ( int arr [ ], int n, int A, int B, int C ) {}ex ) new_arr [ k ++ ] = arr [ j -- ];
new_arr [ n - 1 ] = maximum;
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = new_arr [ i ];
}
void f_filled ( int arr [ ], int n, int A, int B, int C ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,30,49,65,78,85,85,92};
int param0_1[] = {-48,89,-60,66,71,-37,47,-50,61,41,-22,-3,90,-57,77,-64,22,8,-90,-5,-94,-43,29,-29,86,-79,-8,27,-20,-44,16};
int param0_2[] = {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};
int param0_3[] = {87,70,77,87,73,81,66,19,83,7,63,42,42,59,20,73,17,27,47,2,63,62,19,17,69,39,82,71,81,39,36,40,45,4,25,69,30,76,68,88,29,73,68,51,24,14,69,18};
int param0_4[] = {-91,-85,-77,-73,-70,-68,-24,-21,-12,-1,9,29,48,52,56,63,88};
int param0_5[] = {0,0,0,1,1,0,1,1,1,1};
int param0_6[] = {4,5,9,14,18,20,22,23,25,28,30,31,34,35,36,38,38,39,44,48,49,51,54,55,59,64,66,71,72,72,73,76,78,82,82,84,92,93,95};
int param0_7[] = {40,6,33,8,78,-58,2,24,40,3,46,94,-26,8,22,-83,96,-29,-38,-59,19,62,98,-55,-42,79,26,62,-56,-85,-22};
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};
int param0_9[] = {3,68,40,48,54,35,95,56,89,40,77,68,46,78,13,27,6,17,36,99,81,2,77,52,66,52,92,43,90,22,55,67,99,60,58};
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,18,25,33,8,7,22,20,23,28};
int param2[] = {4,20,26,42,12,8,33,16,21,21};
int param3[] = {5,20,15,35,8,6,19,19,19,23};
int param4[] = {4,23,18,41,8,7,25,16,23,23};
int filled_function_param0_0[] = {9,30,49,65,78,85,85,92};
int filled_function_param0_1[] = {-48,89,-60,66,71,-37,47,-50,61,41,-22,-3,90,-57,77,-64,22,8,-90,-5,-94,-43,29,-29,86,-79,-8,27,-20,-44,16};
int filled_function_param0_2[] = {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};
int filled_function_param0_3[] = {87,70,77,87,73,81,66,19,83,7,63,42,42,59,20,73,17,27,47,2,63,62,19,17,69,39,82,71,81,39,36,40,45,4,25,69,30,76,68,88,29,73,68,51,24,14,69,18};
int filled_function_param0_4[] = {-91,-85,-77,-73,-70,-68,-24,-21,-12,-1,9,29,48,52,56,63,88};
int filled_function_param0_5[] = {0,0,0,1,1,0,1,1,1,1};
int filled_function_param0_6[] = {4,5,9,14,18,20,22,23,25,28,30,31,34,35,36,38,38,39,44,48,49,51,54,55,59,64,66,71,72,72,73,76,78,82,82,84,92,93,95};
int filled_function_param0_7[] = {40,6,33,8,78,-58,2,24,40,3,46,94,-26,8,22,-83,96,-29,-38,-59,19,62,98,-55,-42,79,26,62,-56,-85,-22};
int filled_function_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};
int filled_function_param0_9[] = {3,68,40,48,54,35,95,56,89,40,77,68,46,78,13,27,6,17,36,99,81,2,77,52,66,52,92,43,90,22,55,67,99,60,58};
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[] = {4,18,25,33,8,7,22,20,23,28};
int filled_function_param2[] = {4,20,26,42,12,8,33,16,21,21};
int filled_function_param3[] = {5,20,15,35,8,6,19,19,19,23};
int filled_function_param4[] = {4,23,18,41,8,7,25,16,23,23};
for(int i = 0; i < len(param0); ++i)
{
f_filled(filled_function_param0[i],filled_function_param1[i],filled_function_param2[i],filled_function_param3[i],filled_function_param4[i]);
f_gold(param0[i],param1[i],param2[i],param3[i],param4[i]);
if(equal(begin(param0[i]), end(param0[i]), begin(filled_function_param0[i])) && param1[i] == filled_function_param1[i] && param2[i] == filled_function_param2[i] && param3[i] == filled_function_param3[i] && param4[i] == filled_function_param4[i])
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | } | [
"a) range",
"b) (",
"c) }",
"d) #include",
"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 n ) {
return n * ( n - 1 ) * ( n - 2 ) / 6;
}
int f_filled ( int n ) {}
zeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return n * ( n - 1 ) * ( n - 2 ) / 6;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {67,58,67,60,4,97,9,16,83,87};
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);} int f_gold ( int n ) { return n * ( n - 1 ) * ( n - 2 ) / 6; } int f_filled ( int n ) {}zeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return n * ( n - 1 ) * ( n - 2 ) / 6;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {67,58,67,60,4,97,9,16,83,87};
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) i",
"b) )",
"c) \"a\";",
"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 ( int pages [ ], int n, int capacity ) {
unordered_set < int > s;
queue < int > indexes;
int page_faults = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( len(s) < capacity ) {
if ( s . find ( pages [ i ] ) == s . end ( ) ) {
s . insert ( pages [ i ] );
page_faults ++;
indexes . push ( pages [ i ] );
}
}
else {
if ( s . find ( pages [ i ] ) == s . end ( ) ) {
int val = indexes . front ( );
indexes . pop ( );
s . erase ( val );
s . insert ( pages [ i ] );
indexes . push ( pages [ i ] );
page_faults ++;
}
}
}
return page_faults;
}
int f_filled ( int pages [ ], int n, int capacity ) {}
s . insert ( pages [ i ] );
indexes . push ( pages [ i ] );
page_faults ++;
}
}
}
return page_faults;
}
int f_filled ( int pages [ ], int n, int capacity ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,4,6,7,8,11,13,18,26,35,36,37,45,46,46,47,48,49,51,52,53,56,61,74,75,77,80,83,85,86,87,90,93,95,97,98,99,99};
int param0_1[] = {78,-48,50,-20,-6,58,-8,66,72,68,4,80,58,-26,-82,-56,92,76,20,82,-46,86,38,60,-62,-48,76,8,-66,-4,-98,-96,-52,92};
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};
int param0_3[] = {98,78,94,42,62,83,7,62,60,94,16,28,50,15,18,71,86,47,62,89};
int param0_4[] = {-82,-70,-68,-56,-50,-44,4,18,28,30,30,42,66,78,80};
int param0_5[] = {1,1,0,0,1,1,0,0,1,1,1,1,1,0,0,1,1,1,1,1,1,0,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,1,0,0};
int param0_6[] = {4,5,13,15,18,28,32,40,46,46,55,57,61,63,65,68,77,79,79,96};
int param0_7[] = {-2,82,2,-74,-6,-24,54,-74,-98,8,-94,-60,-42,-38,36,-38,-58,-70,-28,-34,70,-6,-2,-76,-40,-4,0,-4,76,48,-34,-26,-48,-58,-88,-44,20,-22,78};
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};
int param0_9[] = {4,90,28,71,69,45,92,63,72,76,47,85,36,59,88,46,28,19,50,31,63,13};
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[] = {36,33,19,15,9,25,17,31,26,15};
int param2[] = {37,23,13,11,11,25,18,24,24,12};
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 pages [ ], int n, int capacity ) { unordered_set < int [MASK] s; queue < int > indexes; int page_faults = 0; for ( int i = 0; i < n; i ++ ) { if ( len(s) < capacity ) { if ( s . find ( pages [ i ] ) == s . end ( ) ) { s . insert ( pages [ i ] ); page_faults ++; indexes . push ( pages [ i ] ); } } else { if ( s . find ( pages [ i ] ) == s . end ( ) ) { int val = indexes . front ( ); indexes . pop ( ); s . erase ( val ); s . insert ( pages [ i ] ); indexes . push ( pages [ i ] ); page_faults ++; } } } return page_faults; } int f_filled ( int pages [ ], int n, int capacity ) {} s . insert ( pages [ i ] );
indexes . push ( pages [ i ] );
page_faults ++;
}
}
}
return page_faults;
}
int f_filled ( int pages [ ], int n, int capacity ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,4,6,7,8,11,13,18,26,35,36,37,45,46,46,47,48,49,51,52,53,56,61,74,75,77,80,83,85,86,87,90,93,95,97,98,99,99};
int param0_1[] = {78,-48,50,-20,-6,58,-8,66,72,68,4,80,58,-26,-82,-56,92,76,20,82,-46,86,38,60,-62,-48,76,8,-66,-4,-98,-96,-52,92};
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};
int param0_3[] = {98,78,94,42,62,83,7,62,60,94,16,28,50,15,18,71,86,47,62,89};
int param0_4[] = {-82,-70,-68,-56,-50,-44,4,18,28,30,30,42,66,78,80};
int param0_5[] = {1,1,0,0,1,1,0,0,1,1,1,1,1,0,0,1,1,1,1,1,1,0,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,1,0,0};
int param0_6[] = {4,5,13,15,18,28,32,40,46,46,55,57,61,63,65,68,77,79,79,96};
int param0_7[] = {-2,82,2,-74,-6,-24,54,-74,-98,8,-94,-60,-42,-38,36,-38,-58,-70,-28,-34,70,-6,-2,-76,-40,-4,0,-4,76,48,-34,-26,-48,-58,-88,-44,20,-22,78};
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};
int param0_9[] = {4,90,28,71,69,45,92,63,72,76,47,85,36,59,88,46,28,19,50,31,63,13};
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[] = {36,33,19,15,9,25,17,31,26,15};
int param2[] = {37,23,13,11,11,25,18,24,24,12};
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) ]",
"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 ar1 [ ], int ar2 [ ], int n ) {
int i = 0;
int j = 0;
int count;
int m1 = - 1, m2 = - 1;
for ( count = 0;
count <= n;
count ++ ) {
if ( i == n ) {
m1 = m2;
m2 = ar2 [ 0 ];
break;
}
else if ( j == n ) {
m1 = m2;
m2 = ar1 [ 0 ];
break;
}
if ( ar1 [ i ] < ar2 [ j ] ) {
m1 = m2;
m2 = ar1 [ i ];
i ++;
}
else {
m1 = m2;
m2 = ar2 [ j ];
j ++;
}
}
return ( m1 + m2 ) / 2;
}
int f_filled ( int ar1 [ ], int ar2 [ ], int n ) {}
= m2;
m2 = ar1 [ i ];
i ++;
}
else {
m1 = m2;
m2 = ar2 [ j ];
j ++;
}
}
return ( m1 + m2 ) / 2;
}
int f_filled ( int ar1 [ ], int ar2 [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,6,18,21,23,27,44,44,69,72,78,88,90,98};
int param0_1[] = {90,54,24,-10,-84,-74,58,96,-28,-92,-18,90,70,-60,72,78,10,42,-2,-18,-38,-16,18,-86,40,-46,-38,66,20,-16,48};
int param0_2[] = {0,1,1};
int param0_3[] = {53,17,94,21,16,75,67,51,44,71,65,82};
int param0_4[] = {-96,-92,-80,-68,-64,-64,-60,-56,-52,-50,-50,-22,-20,-4,-2,0,6,20,22,28,38,40,48,50,56,58,64,64,80,82,90,92,92,92};
int param0_5[] = {0,0,0,1,0,0,0,0,0,1,1,0,1,1,0,0,1,1,0,0,1,1,1,1,0,1,0,0,0,0,0,0,0,1,0,1,1,1,0,1,1,1,1};
int param0_6[] = {8,15,17,19,21,32,34,38,41,41,49,49,51,54,54,56,56,57,59,63,70,74,79,79,84,84,86,88,89,93,98};
int param0_7[] = {96,-42,-94,-46,-68,76,8,16,-54,-94,76,24,94,10,34,78,-30,0,-52,80,98,-58,92,12,26,64};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param0_9[] = {61,69,66,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_0[] = {6,12,16,18,26,34,48,48,49,56,61,79,81,89};
int param1_1[] = {-72,-62,14,-58,70,54,88,-40,-94,4,60,-16,-38,-98,-70,-46,66,42,26,36,56,-4,32,30,-46,-42,-72,44,16,4,24};
int param1_2[] = {0,1,1};
int param1_3[] = {98,50,8,11,80,41,59,24,94,41,75,78};
int param1_4[] = {-88,-72,-72,-58,-54,-50,-48,-34,-24,-14,-14,-14,-10,-6,4,12,16,18,26,30,32,34,40,46,52,54,58,62,62,72,82,82,92,98};
int param1_5[] = {1,1,1,1,0,0,0,1,1,1,0,0,0,1,0,1,1,0,0,1,0,1,0,0,0,1,1,0,0,1,1,0,1,0,1,1,0,1,0,0,0,0,1};
int param1_6[] = {5,6,17,18,22,29,32,33,36,44,45,47,59,59,60,65,67,68,69,71,72,76,78,81,84,85,85,86,86,87,92};
int param1_7[] = {88,78,-26,10,84,34,56,-8,-30,46,48,20,26,-78,96,44,92,-44,-86,24,-58,-96,-86,-12,-98,18};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param1_9[] = {39,84,97,15};
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[] = {12,16,2,10,25,40,29,17,17,3};
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 [MASK] {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int ar1 [ ], int ar2 [ ], int n ) { int i = 0; int j = 0; int count; int m1 = - 1, m2 = - 1; for ( count = 0; count <= n; count ++ ) { if ( i == n ) { m1 = m2; m2 = ar2 [ 0 ]; break; } else if ( j == n ) { m1 = m2; m2 = ar1 [ 0 ]; break; } if ( ar1 [ i ] < ar2 [ j ] ) { m1 = m2; m2 = ar1 [ i ]; i ++; } else { m1 = m2; m2 = ar2 [ j ]; j ++; } } return ( m1 + m2 ) / 2; } int f_filled ( int ar1 [ ], int ar2 [ ], int n ) {}= m2;
m2 = ar1 [ i ];
i ++;
}
else {
m1 = m2;
m2 = ar2 [ j ];
j ++;
}
}
return ( m1 + m2 ) / 2;
}
int f_filled ( int ar1 [ ], int ar2 [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,6,18,21,23,27,44,44,69,72,78,88,90,98};
int param0_1[] = {90,54,24,-10,-84,-74,58,96,-28,-92,-18,90,70,-60,72,78,10,42,-2,-18,-38,-16,18,-86,40,-46,-38,66,20,-16,48};
int param0_2[] = {0,1,1};
int param0_3[] = {53,17,94,21,16,75,67,51,44,71,65,82};
int param0_4[] = {-96,-92,-80,-68,-64,-64,-60,-56,-52,-50,-50,-22,-20,-4,-2,0,6,20,22,28,38,40,48,50,56,58,64,64,80,82,90,92,92,92};
int param0_5[] = {0,0,0,1,0,0,0,0,0,1,1,0,1,1,0,0,1,1,0,0,1,1,1,1,0,1,0,0,0,0,0,0,0,1,0,1,1,1,0,1,1,1,1};
int param0_6[] = {8,15,17,19,21,32,34,38,41,41,49,49,51,54,54,56,56,57,59,63,70,74,79,79,84,84,86,88,89,93,98};
int param0_7[] = {96,-42,-94,-46,-68,76,8,16,-54,-94,76,24,94,10,34,78,-30,0,-52,80,98,-58,92,12,26,64};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param0_9[] = {61,69,66,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_0[] = {6,12,16,18,26,34,48,48,49,56,61,79,81,89};
int param1_1[] = {-72,-62,14,-58,70,54,88,-40,-94,4,60,-16,-38,-98,-70,-46,66,42,26,36,56,-4,32,30,-46,-42,-72,44,16,4,24};
int param1_2[] = {0,1,1};
int param1_3[] = {98,50,8,11,80,41,59,24,94,41,75,78};
int param1_4[] = {-88,-72,-72,-58,-54,-50,-48,-34,-24,-14,-14,-14,-10,-6,4,12,16,18,26,30,32,34,40,46,52,54,58,62,62,72,82,82,92,98};
int param1_5[] = {1,1,1,1,0,0,0,1,1,1,0,0,0,1,0,1,1,0,0,1,0,1,0,0,0,1,1,0,0,1,1,0,1,0,1,1,0,1,0,0,0,0,1};
int param1_6[] = {5,6,17,18,22,29,32,33,36,44,45,47,59,59,60,65,67,68,69,71,72,76,78,81,84,85,85,86,86,87,92};
int param1_7[] = {88,78,-26,10,84,34,56,-8,-30,46,48,20,26,-78,96,44,92,-44,-86,24,-58,-96,-86,-12,-98,18};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param1_9[] = {39,84,97,15};
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[] = {12,16,2,10,25,40,29,17,17,3};
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;
} | n) | [
"a) n)",
"b) curr_ele",
"c) x:",
"d) int",
"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 ( int arr [ ], int n, int X ) {
if ( X < arr [ 0 ] ) return 0;
else if ( X > arr [ n - 1 ] ) return n;
int lowerPnt = 0;
int i = 1;
while ( i < n && arr [ i ] < X ) {
lowerPnt = i;
i = i * 2;
}
while ( lowerPnt < n && arr [ lowerPnt ] < X ) lowerPnt ++;
return lowerPnt;
}
int f_filled ( int arr [ ], int n, int X ) {}
( i < n && arr [ i ] < X ) {
lowerPnt = i;
i = i * 2;
}
while ( lowerPnt < n && arr [ lowerPnt ] < X ) lowerPnt ++;
return lowerPnt;
}
int f_filled ( int arr [ ], int n, int X ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,5,5,16,16,20,26,32,35,39,39,41,44,48,48,51,59,59,62,66,66,70,74,75,78,80,86,86,96};
int param0_1[] = {-76,80,-6,-2,50,72,84,-56,70,8,48,6,-24,-50,-72};
int param0_2[] = {0,0,0,0,0,1,1,1,1};
int param0_3[] = {74,65,84,71};
int param0_4[] = {-96,-92,-90,-86,-84,-76,-76,-62,-58,-54,-50,-50,-44,-42,-38,-34,-14,-8,6,12,24,38,40,50,62,84,86,92};
int param0_5[] = {1,1,0,0,0,1,1,1,0,0,1,1,0,1,0,1,0,0,0,1,1,1,1};
int param0_6[] = {6,10,14,14,16,19,23,23,25,26,29,34,42,42,43,45,47,49,50,51,51,56,59,65,69,72,75,78,79,80,82,82,82,84,85,91,98};
int param0_7[] = {-90,-2,22,-2,58,-2,96,38,36,-66,-98,22,-80,-32,22,0,-34,-16,82,76,12,84,66,8,32,18,-98,-10};
int param0_8[] = {0,0,0,1,1,1,1};
int param0_9[] = {85,59,22,52,93,14,42,71,69,15,52,78,35,61,92,90,70,48,47,72,74,46,22,74,83,32,14,24,18,27,18,68,29,31};
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,14,8,2,19,12,31,22,3,19};
int param2[] = {29,9,4,3,19,17,24,16,5,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 [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 ( int arr [ ], int n, int X ) { if ( X < arr [ 0 ] ) return 0; else if ( X > arr [ n - 1 ] ) return n; int lowerPnt = 0; int i = 1; while ( i < n && arr [ i ] < X ) { lowerPnt = i; i = i * 2; } while ( lowerPnt < n && arr [ lowerPnt ] < X ) lowerPnt ++; return lowerPnt; } int f_filled ( int arr [ ], int n, int X ) {} ( i < n && arr [ i ] < X ) {
lowerPnt = i;
i = i * 2;
}
while ( lowerPnt < n && arr [ lowerPnt ] < X ) lowerPnt ++;
return lowerPnt;
}
int f_filled ( int arr [ ], int n, int X ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,5,5,16,16,20,26,32,35,39,39,41,44,48,48,51,59,59,62,66,66,70,74,75,78,80,86,86,96};
int param0_1[] = {-76,80,-6,-2,50,72,84,-56,70,8,48,6,-24,-50,-72};
int param0_2[] = {0,0,0,0,0,1,1,1,1};
int param0_3[] = {74,65,84,71};
int param0_4[] = {-96,-92,-90,-86,-84,-76,-76,-62,-58,-54,-50,-50,-44,-42,-38,-34,-14,-8,6,12,24,38,40,50,62,84,86,92};
int param0_5[] = {1,1,0,0,0,1,1,1,0,0,1,1,0,1,0,1,0,0,0,1,1,1,1};
int param0_6[] = {6,10,14,14,16,19,23,23,25,26,29,34,42,42,43,45,47,49,50,51,51,56,59,65,69,72,75,78,79,80,82,82,82,84,85,91,98};
int param0_7[] = {-90,-2,22,-2,58,-2,96,38,36,-66,-98,22,-80,-32,22,0,-34,-16,82,76,12,84,66,8,32,18,-98,-10};
int param0_8[] = {0,0,0,1,1,1,1};
int param0_9[] = {85,59,22,52,93,14,42,71,69,15,52,78,35,61,92,90,70,48,47,72,74,46,22,74,83,32,14,24,18,27,18,68,29,31};
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,14,8,2,19,12,31,22,3,19};
int param2[] = {29,9,4,3,19,17,24,16,5,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) y)",
"b) c",
"c) {",
"d) *",
"e) in"
] | 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 sum = 0;
while ( n > 0 ) {
sum += ( n % 10 );
n /= 10;
}
if ( sum == 1 ) return 10;
return sum;
}
int f_filled ( int n ) {}
, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int sum = 0;
while ( n > 0 ) {
sum += ( n % 10 );
n /= 10;
}
if ( sum == 1 ) return 10;
return sum;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {2,39,31,45,35,94,67,50,4,63};
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 [MASK] ]) {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 sum = 0; while ( n > 0 ) { sum += ( n % 10 ); n /= 10; } if ( sum == 1 ) return 10; return sum; } int f_filled ( int n ) {}, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int sum = 0;
while ( n > 0 ) {
sum += ( n % 10 );
n /= 10;
}
if ( sum == 1 ) return 10;
return sum;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {2,39,31,45,35,94,67,50,4,63};
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) import",
"b) i",
"c) [",
"d) <fstream>",
"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 i, j;
int * lis = new int [ n ];
for ( i = 0;
i < n;
i ++ ) lis [ i ] = 1;
for ( i = 1;
i < n;
i ++ ) for ( j = 0;
j < i;
j ++ ) if ( arr [ i ] > arr [ j ] && lis [ i ] < lis [ j ] + 1 ) lis [ i ] = lis [ j ] + 1;
int * lds = new int [ n ];
for ( i = 0;
i < n;
i ++ ) lds [ i ] = 1;
for ( i = n - 2;
i >= 0;
i -- ) for ( j = n - 1;
j > i;
j -- ) if ( arr [ i ] > arr [ j ] && lds [ i ] < lds [ j ] + 1 ) lds [ i ] = lds [ j ] + 1;
int max = lis [ 0 ] + lds [ 0 ] - 1;
for ( i = 1;
i < n;
i ++ ) if ( lis [ i ] + lds [ i ] - 1 > max ) max = lis [ i ] + lds [ i ] - 1;
return max;
}
int f_filled ( int arr [ ], int n ) {}
nt max = lis [ 0 ] + lds [ 0 ] - 1;
for ( i = 1;
i < n;
i ++ ) if ( lis [ i ] + lds [ i ] - 1 > max ) max = lis [ i ] + lds [ i ] - 1;
return max;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {11,15,37,64,77,84};
int param0_1[] = {-52};
int param0_2[] = {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[] = {49,95,57,17,94,76,47,23,62,20,83,95,79,65,80,57,12,8,56,39,63,54,63,88,36,81,98,98,45};
int param0_4[] = {-68,-60,-40};
int param0_5[] = {0,0,1,0,0,1,1,0,1,1,0,1,0,0,0,1,0,0,1,1,1,1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,1,1,1,1,1,1,1};
int param0_6[] = {1,4,12,12,13,17,20,24,27,29,31,41,44,58,62,62,64,70,73,78,82,92,97};
int param0_7[] = {-62,30};
int param0_8[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {41,81,35,27,29,74,48,21,3,49,90,17,93,11,69,43,30,50,67,33,21,34,13,3,46,20,92,67,97,20,51,24,22,39,35,29,71};
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,0,20,24,2,27,21,1,8,29};
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, j; int * lis = new int [ n ]; for ( i = 0; i < n; i ++ ) lis [ i ] = 1; for ( i = 1; i < n; i ++ ) for ( j = 0; j < i; j ++ ) if ( arr [ i ] > arr [ j ] && lis [ i ] < lis [ j ] + 1 ) lis [ i ] = lis [ j ] + 1; int * lds = new int [ n ]; for ( i = 0; i < n; i ++ ) lds [ i ] = 1; for ( i = n - 2; i >= 0; i -- ) for ( j = n - 1; j > i; j -- ) if ( arr [ i ] > arr [ j ] && lds [ i ] < lds [ j ] + 1 ) lds [ i ] = lds [ j ] + 1; int max = lis [ 0 ] + lds [ 0 ] - 1; for ( [MASK] = 1; i < n; i ++ ) if ( lis [ i ] + lds [ i ] - 1 > max ) max = lis [ i ] + lds [ i ] - 1; return max; } int f_filled ( int arr [ ], int n ) {}nt max = lis [ 0 ] + lds [ 0 ] - 1;
for ( i = 1;
i < n;
i ++ ) if ( lis [ i ] + lds [ i ] - 1 > max ) max = lis [ i ] + lds [ i ] - 1;
return max;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {11,15,37,64,77,84};
int param0_1[] = {-52};
int param0_2[] = {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[] = {49,95,57,17,94,76,47,23,62,20,83,95,79,65,80,57,12,8,56,39,63,54,63,88,36,81,98,98,45};
int param0_4[] = {-68,-60,-40};
int param0_5[] = {0,0,1,0,0,1,1,0,1,1,0,1,0,0,0,1,0,0,1,1,1,1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,1,1,1,1,1,1,1};
int param0_6[] = {1,4,12,12,13,17,20,24,27,29,31,41,44,58,62,62,64,70,73,78,82,92,97};
int param0_7[] = {-62,30};
int param0_8[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {41,81,35,27,29,74,48,21,3,49,90,17,93,11,69,43,30,50,67,33,21,34,13,3,46,20,92,67,97,20,51,24,22,39,35,29,71};
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,0,20,24,2,27,21,1,8,29};
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;
} | i | [
"a) int",
"b) *",
"c) def",
"d) i",
"e) for"
] | 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 table [ n + 1 ];
for ( int i = 0;
i <= n;
i ++ ) table [ i ] = n - i;
for ( int i = n;
i >= 1;
i -- ) {
if ( ! ( i % 2 ) ) table [ i / 2 ] = min ( table [ i ] + 1, table [ i / 2 ] );
if ( ! ( i % 3 ) ) table [ i / 3 ] = min ( table [ i ] + 1, table [ i / 3 ] );
}
return table [ 1 ];
}
int f_filled ( int n ) {}
able [ i / 2 ] = min ( table [ i ] + 1, table [ i / 2 ] );
if ( ! ( i % 3 ) ) table [ i / 3 ] = min ( table [ i ] + 1, table [ i / 3 ] );
}
return table [ 1 ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {59,7,90,78,49,15,45,56,7,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)? 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 table [ n + 1 ]; for ( int i = 0; i <= n; i ++ ) table [ i ] = n - i; for ( int i = n; i >= 1; i -- ) { if ( ! ( i % 2 ) ) table [ i / 2 ] = min ( table [ i ] + 1, table [ i / 2 ] ); if ( ! ( i % 3 ) ) table [ i / 3 ] = min ( table [ i ] + 1, [MASK] [ i / 3 ] ); } return table [ 1 ]; } int f_filled ( int n ) {}able [ i / 2 ] = min ( table [ i ] + 1, table [ i / 2 ] );
if ( ! ( i % 3 ) ) table [ i / 3 ] = min ( table [ i ] + 1, table [ i / 3 ] );
}
return table [ 1 ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {59,7,90,78,49,15,45,56,7,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;
} | table | [
"a) )",
"b) table",
"c) #include",
"d) public",
"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 ) {
int a [ n + 1 ] [ 10 ];
for ( int i = 0;
i <= 9;
i ++ ) a [ 0 ] [ i ] = 1;
for ( int i = 1;
i <= n;
i ++ ) a [ i ] [ 9 ] = 1;
for ( int i = 1;
i <= n;
i ++ ) for ( int j = 8;
j >= 0;
j -- ) a [ i ] [ j ] = a [ i - 1 ] [ j ] + a [ i ] [ j + 1 ];
return a [ n ] [ 0 ];
}
int f_filled ( int n ) {}
i ] [ 9 ] = 1;
for ( int i = 1;
i <= n;
i ++ ) for ( int j = 8;
j >= 0;
j -- ) a [ i ] [ j ] = a [ i - 1 ] [ j ] + a [ i ] [ j + 1 ];
return a [ n ] [ 0 ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {2,19,79,62,93,39,7,31,3,21};
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), [MASK] int f_gold ( int n ) { int a [ n + 1 ] [ 10 ]; for ( int i = 0; i <= 9; i ++ ) a [ 0 ] [ i ] = 1; for ( int i = 1; i <= n; i ++ ) a [ i ] [ 9 ] = 1; for ( int i = 1; i <= n; i ++ ) for ( int j = 8; j >= 0; j -- ) a [ i ] [ j ] = a [ i - 1 ] [ j ] + a [ i ] [ j + 1 ]; return a [ n ] [ 0 ]; } int f_filled ( int n ) {}i ] [ 9 ] = 1;
for ( int i = 1;
i <= n;
i ++ ) for ( int j = 8;
j >= 0;
j -- ) a [ i ] [ j ] = a [ i - 1 ] [ j ] + a [ i ] [ j + 1 ];
return a [ n ] [ 0 ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {2,19,79,62,93,39,7,31,3,21};
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;
} | cmpfunc);} | [
"a) i",
"b) bool",
"c) (",
"d) cmpfunc);}",
"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);}
char f_gold [] ( char num [] ) {
int n = len(num);
int rightMin [ n ], right;
rightMin [ n - 1 ] = - 1;
right = n - 1;
for ( int i = n - 2;
i >= 1;
i -- ) {
if ( num [ i ] >= num [ right ] ) rightMin [ i ] = right;
else {
if ( num [ i ] == num [ i + 1 ] ) {
rightMin [ i ] = right;
}
else {
rightMin [ i ] = - 1;
right = i;
}
}
}
int small = - 1;
for ( int i = 1;
i < n;
i ++ ) if ( num [ i ] != '0' ) {
if ( small == - 1 ) {
if ( num [ i ] < num [ 0 ] ) small = i;
}
else if ( num [ i ] <= num [ small ] ) small = i;
}
if ( small != - 1 ) swap ( num [ 0 ], num [ small ] );
else {
for ( int i = 1;
i < n;
i ++ ) {
if ( rightMin [ i ] != - 1 && num [ i ] != num [ rightMin [ i ] ] ) {
swap ( num [ i ], num [ rightMin [ i ] ] );
break;
}
}
}
return num;
}
char f_filled [] ( char num [] ) {}
in [ i ] != - 1 && num [ i ] != num [ rightMin [ i ] ] ) {
swap ( num [ i ], num [ rightMin [ i ] ] );
break;
}
}
}
return num;
}
char f_filled [] ( char num [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"ncYltuhSxEfG","26615541616459","0101","hK","422162103899","0010","zfcSh","92","0","v"};
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 num [] ) { int n = len(num); int rightMin [ n ], right; rightMin [ n - 1 ] = - 1; right = n - 1; for ( int i = n - 2; i >= 1; i -- ) { if ( num [ i ] >= num [ right ] ) rightMin [ i ] = right; else { if ( num [ i ] == num [ i + 1 ] ) { rightMin [ i ] = right; } else { rightMin [ i ] = - 1; right = i; } } } int small = - 1; for ( int i = 1; i < n; i ++ ) if ( num [ i ] != '0' ) { if ( small == - 1 ) { if ( num [ i ] < num [ 0 ] ) small = i; } else if ( num [ i ] <= num [ small ] ) small = i; } if ( small != - 1 ) swap ( num [ 0 ], num [ small ] ); else { for ( int i = 1; i < n; i ++ ) { if ( rightMin [ i ] != - 1 && num [ i ] != num [ rightMin [ i ] ] ) { swap ( num [ i [MASK] num [ rightMin [ i ] ] ); break; } } } return num; } char f_filled [] ( char num [] ) {}in [ i ] != - 1 && num [ i ] != num [ rightMin [ i ] ] ) {
swap ( num [ i ], num [ rightMin [ i ] ] );
break;
}
}
}
return num;
}
char f_filled [] ( char num [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"ncYltuhSxEfG","26615541616459","0101","hK","422162103899","0010","zfcSh","92","0","v"};
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) 1",
"b) ],",
"c) return",
"d) );",
"e) <vector>"
] | 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 ) {
if ( a == 0 ) return b;
return f_gold ( b % a, a );
}
int f_filled ( int a, int b ) {}
;}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b ) {
if ( a == 0 ) return b;
return f_gold ( b % a, a );
}
int f_filled ( int a, int b ) {}
int main(void) {
int n_success = 0;
int param0[] = {46,26,40,58,25,2,8,21,82,17};
int param1[] = {89,82,12,4,44,87,65,87,10,61};
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 ) { if ( a == 0 ) return b; return f_gold ( b % a, a ); [MASK] int f_filled ( int a, int b ) {};}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b ) {
if ( a == 0 ) return b;
return f_gold ( b % a, a );
}
int f_filled ( int a, int b ) {}
int main(void) {
int n_success = 0;
int param0[] = {46,26,40,58,25,2,8,21,82,17};
int param1[] = {89,82,12,4,44,87,65,87,10,61};
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) ans",
"b) return",
"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 res = 0;
for ( int i = 0;
i < n;
i ++ ) if ( x == arr [ i ] ) res ++;
return res;
}
int f_filled ( int arr [ ], int n, int x ) {}
func);}
int f_gold ( int arr [ ], int n, int x ) {
int res = 0;
for ( int i = 0;
i < n;
i ++ ) if ( x == arr [ i ] ) res ++;
return res;
}
int f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {16,18,24,27,34,36,41,43,43,52,59,76,86,87,90,91,94,96,98,98};
int param0_1[] = {64,66,-36};
int param0_2[] = {0,0,0};
int param0_3[] = {9,85,34,43,70,96,44,7,27,33,34,5,91,84,76,45,20,37,15,37,20,24,13,49,74,13,50,81,81,66,23,36,91,80,61,15,96,70,90,25,16,62,75,63,6,65,38,12};
int param0_4[] = {-98,-98,-98,-34,-32,-26,-12,0,18,52,68,72};
int param0_5[] = {1,1,0,0,1,1,0,0,1,0,0,1,0,0,1,1};
int param0_6[] = {1,3,6,6,10,12,15,16,21,22,23,29,33,37,40,40,43,52,55,59,64,65,71,72,80,83,86,86,88,88};
int param0_7[] = {-14,-30,-38,-38,-8,40,-34,2,-84,68,-42,38,-14,0,-64,12,-2,-38,-8,-44,-88,-34,-80,-36,82,70,96,-32,16,-52,-12,-46,-28,-86,30,-14,50,-44,22,30,-4,78,52};
int param0_8[] = {1,1,1,1};
int param0_9[] = {11,50,1,93,12,7,55,35,36,62,61,71,16};
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,1,2,43,11,11,29,39,2,11};
int param2[] = {43,64,0,5,-98,1,40,26,3,8};
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> [MASK] <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 res = 0; for ( int i = 0; i < n; i ++ ) if ( x == arr [ i ] ) res ++; return res; } int f_filled ( int arr [ ], int n, int x ) {}func);}
int f_gold ( int arr [ ], int n, int x ) {
int res = 0;
for ( int i = 0;
i < n;
i ++ ) if ( x == arr [ i ] ) res ++;
return res;
}
int f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {16,18,24,27,34,36,41,43,43,52,59,76,86,87,90,91,94,96,98,98};
int param0_1[] = {64,66,-36};
int param0_2[] = {0,0,0};
int param0_3[] = {9,85,34,43,70,96,44,7,27,33,34,5,91,84,76,45,20,37,15,37,20,24,13,49,74,13,50,81,81,66,23,36,91,80,61,15,96,70,90,25,16,62,75,63,6,65,38,12};
int param0_4[] = {-98,-98,-98,-34,-32,-26,-12,0,18,52,68,72};
int param0_5[] = {1,1,0,0,1,1,0,0,1,0,0,1,0,0,1,1};
int param0_6[] = {1,3,6,6,10,12,15,16,21,22,23,29,33,37,40,40,43,52,55,59,64,65,71,72,80,83,86,86,88,88};
int param0_7[] = {-14,-30,-38,-38,-8,40,-34,2,-84,68,-42,38,-14,0,-64,12,-2,-38,-8,-44,-88,-34,-80,-36,82,70,96,-32,16,-52,-12,-46,-28,-86,30,-14,50,-44,22,30,-4,78,52};
int param0_8[] = {1,1,1,1};
int param0_9[] = {11,50,1,93,12,7,55,35,36,62,61,71,16};
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,1,2,43,11,11,29,39,2,11};
int param2[] = {43,64,0,5,-98,1,40,26,3,8};
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 | [
"a) (",
"b) 2",
"c) #include",
"d) =",
"e) 9;"
] | 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);}
float f_gold ( float r1, float r2, float r3 ) {
float pi = 3.14;
return 1.33 * pi * r1 * r2 * r3;
}
float f_filled ( float r1, float r2, float r3 ) {}
{qsort (arr, n, sizeof(int), cmpfunc);}
float f_gold ( float r1, float r2, float r3 ) {
float pi = 3.14;
return 1.33 * pi * r1 * r2 * r3;
}
float f_filled ( float r1, float r2, float r3 ) {}
int main(void) {
int n_success = 0;
float param0[] = {3287.4842316041018F,-3707.427510963942F,8980.643174783816F,-2698.0187368852694F,8627.156664162168F,-7316.329924623669F,7857.3846206400485F,-6502.657905007728F,4468.400513325576F,-7231.864791620428F};
float param1[] = {4503.332888443404F,-6671.335781753231F,3584.781688607942F,-1004.7289573934537F,9572.27618966978F,-6591.043206581106F,3671.761679299217F,-1412.2240121470609F,2272.1999139470304F,-8036.087711033032F};
float param2[] = {8590.24729914204F,-2780.4954870801926F,2818.469507143102F,-9602.530725071243F,4783.930377855004F,-9760.465488363216F,2534.5825334137794F,-6135.238350044512F,4753.075799180736F,-6456.263512521035F};
for(int i = 0; i < len(param0); ++i)
{
if(abs(1 - (0.0000001 + abs(f_gold(param0[i],param1[i],param2[i])) )/ (abs(f_filled(param0[i],param1[i],param2[i])) + 0.0000001)) < 0.001F)
{
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);} float f_gold ( float r1, float r2, [MASK] r3 ) { float pi = 3.14; return 1.33 * pi * r1 * r2 * r3; } float f_filled ( float r1, float r2, float r3 ) {}{qsort (arr, n, sizeof(int), cmpfunc);}
float f_gold ( float r1, float r2, float r3 ) {
float pi = 3.14;
return 1.33 * pi * r1 * r2 * r3;
}
float f_filled ( float r1, float r2, float r3 ) {}
int main(void) {
int n_success = 0;
float param0[] = {3287.4842316041018F,-3707.427510963942F,8980.643174783816F,-2698.0187368852694F,8627.156664162168F,-7316.329924623669F,7857.3846206400485F,-6502.657905007728F,4468.400513325576F,-7231.864791620428F};
float param1[] = {4503.332888443404F,-6671.335781753231F,3584.781688607942F,-1004.7289573934537F,9572.27618966978F,-6591.043206581106F,3671.761679299217F,-1412.2240121470609F,2272.1999139470304F,-8036.087711033032F};
float param2[] = {8590.24729914204F,-2780.4954870801926F,2818.469507143102F,-9602.530725071243F,4783.930377855004F,-9760.465488363216F,2534.5825334137794F,-6135.238350044512F,4753.075799180736F,-6456.263512521035F};
for(int i = 0; i < len(param0); ++i)
{
if(abs(1 - (0.0000001 + abs(f_gold(param0[i],param1[i],param2[i])) )/ (abs(f_filled(param0[i],param1[i],param2[i])) + 0.0000001)) < 0.001F)
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | float | [
"a) =",
"b) <vector>",
"c) float",
"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 n ) {
int sum = 0;
for ( int i = 0;
i < n;
i ++ ) sum += i * ( n - i );
return 2 * sum;
}
int f_filled ( int n ) {}
[ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int sum = 0;
for ( int i = 0;
i < n;
i ++ ) sum += i * ( n - i );
return 2 * sum;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {63,72,28,35,6,70,20,8,8,35};
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 sum = 0; for ( int i = 0; i < n; i ++ ) sum += i [MASK] ( n - i ); return 2 * sum; } int f_filled ( int n ) {}[ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int sum = 0;
for ( int i = 0;
i < n;
i ++ ) sum += i * ( n - i );
return 2 * sum;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {63,72,28,35,6,70,20,8,8,35};
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) if",
"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 k ) {
if ( n == 1 ) return 0;
sort ( arr, arr + n );
int ans = arr [ n - 1 ] - arr [ 0 ];
int small = arr [ 0 ] + k;
int big = arr [ n - 1 ] - k;
if ( small > big ) swap ( small, big );
for ( int i = 1;
i < n - 1;
i ++ ) {
int subtract = arr [ i ] - k;
int add = arr [ i ] + k;
if ( subtract >= small || add <= big ) continue;
if ( big - subtract <= add - small ) small = subtract;
else big = add;
}
return min ( ans, big - small );
}
int f_filled ( int arr [ ], int n, int k ) {}
all || add <= big ) continue;
if ( big - subtract <= add - small ) small = subtract;
else big = add;
}
return min ( ans, big - small );
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {31,33,40,43,44,51,52,56,60,64,66,79,91,93,99};
int param0_1[] = {-16,34,54,-86,-62};
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};
int param0_3[] = {27,84,57,45,70,41,67,3,5,67,16,74,99,90,48,90,7,86,59,88,45,11,21,91,17,67,59,60,36,9,5,55,68,58,91,51,44,92,77,38};
int param0_4[] = {-88,-84,-78,-72,-66,-66,-58,-56,-56,-56,-54,-50,-50,-38,-24,-18,-12,-10,-8,-4,0,6,8,10,14,40,44,50,58,64,64,68};
int param0_5[] = {1,1,0,0,1,1,0,1,0,0,0};
int param0_6[] = {6,11,13,14,22,25,26,28,30,31,37,37,55,57,61,62,64,67,69,70,71,73,73,75,80,81,82,88,90,98};
int param0_7[] = {-86,4,-90,66,-10,-36,-18,82,20,6,-78,98,-64,52,-22,20,44,-70,-32,88,-80,24,-38,-62,92};
int param0_8[] = {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[] = {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[] = {10,3,29,28,22,10,29,23,20,0};
int param2[] = {13,4,22,28,28,8,26,18,19,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 k ) { if ( n == 1 ) return 0; sort ( arr, arr + n ); int ans = arr [ n - 1 ] - arr [ 0 ]; int small = arr [ 0 ] + k; int big = arr [ n - 1 ] - k; if [MASK] small > big ) swap ( small, big ); for ( int i = 1; i < n - 1; i ++ ) { int subtract = arr [ i ] - k; int add = arr [ i ] + k; if ( subtract >= small || add <= big ) continue; if ( big - subtract <= add - small ) small = subtract; else big = add; } return min ( ans, big - small ); } int f_filled ( int arr [ ], int n, int k ) {}all || add <= big ) continue;
if ( big - subtract <= add - small ) small = subtract;
else big = add;
}
return min ( ans, big - small );
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {31,33,40,43,44,51,52,56,60,64,66,79,91,93,99};
int param0_1[] = {-16,34,54,-86,-62};
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};
int param0_3[] = {27,84,57,45,70,41,67,3,5,67,16,74,99,90,48,90,7,86,59,88,45,11,21,91,17,67,59,60,36,9,5,55,68,58,91,51,44,92,77,38};
int param0_4[] = {-88,-84,-78,-72,-66,-66,-58,-56,-56,-56,-54,-50,-50,-38,-24,-18,-12,-10,-8,-4,0,6,8,10,14,40,44,50,58,64,64,68};
int param0_5[] = {1,1,0,0,1,1,0,1,0,0,0};
int param0_6[] = {6,11,13,14,22,25,26,28,30,31,37,37,55,57,61,62,64,67,69,70,71,73,73,75,80,81,82,88,90,98};
int param0_7[] = {-86,4,-90,66,-10,-36,-18,82,20,6,-78,98,-64,52,-22,20,44,-70,-32,88,-80,24,-38,-62,92};
int param0_8[] = {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[] = {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[] = {10,3,29,28,22,10,29,23,20,0};
int param2[] = {13,4,22,28,28,8,26,18,19,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) (",
"b) int",
"c) a",
"d) {}",
"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 arr [ ], int n, int x ) {
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == x ) return i;
}
return - 1;
}
int f_filled ( int arr [ ], int n, int x ) {}
cmpfunc);}
int f_gold ( int arr [ ], int n, int x ) {
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == x ) return i;
}
return - 1;
}
int f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,15,15,15,16,17,23,23,33,33,40,43,55,56,63,66,69,76,79,88,99};
int param0_1[] = {78,-64,-20,12,96,54,16,50,-20,96,-22,-84,54,-66,-16,-78,-78,90,-46,-70,-72,12,96,-86,42,-80,8,-2,70,4,70};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {73,60,4,59,75,39,39,30,66,11,90,80,46,59,52,14,63,70,75,73,65,88,45,64,66,91,67,25,60,74,33,23,94,76,60,78,72};
int param0_4[] = {-92,-88,-68,-64,-62,-56,-50,-48,-48,-38,-18,-16,-14,-8,-8,2,4,10,10,10,36,38,46,50,52,62,72,74,80,84,86,90,92,94,96};
int param0_5[] = {1,0,0,1,1,0,0,0,1,1,1,0,0,1,0,1,1,0,1,0,1,0,1,0,1,1,0,0,0,0,1,0,0,1,1,0,1,0,0};
int param0_6[] = {7,8,8,10,13,18,18,19,20,25,32,33,34,38,44,44,46,46,46,47,48,50,53,56,56,57,57,57,57,59,60,61,63,63,64,70,71,74,74,81,82,83,84,90,92,93};
int param0_7[] = {-82,74,-94,68,-10,-8,-46,-4,50,-60,-70,-74,-18,50,62,-76,-50,-58,-36,-16,-36,78,12,56,-14,-48,40,22,0,16,72,-78,46,8,-50,-78,28,20,-56};
int param0_8[] = {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[] = {88,89,66,28,75,81,29,26,21,39,58,94,48,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[] = {20,17,12,20,33,33,41,26,16,9};
int param2[] = {15,29,17,28,20,26,44,31,18,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, [MASK] cmpfunc);} int f_gold ( int arr [ ], int n, int x ) { for ( int i = 0; i < n; i ++ ) { if ( arr [ i ] == x ) return i; } return - 1; } int f_filled ( int arr [ ], int n, int x ) {}cmpfunc);}
int f_gold ( int arr [ ], int n, int x ) {
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == x ) return i;
}
return - 1;
}
int f_filled ( int arr [ ], int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,15,15,15,16,17,23,23,33,33,40,43,55,56,63,66,69,76,79,88,99};
int param0_1[] = {78,-64,-20,12,96,54,16,50,-20,96,-22,-84,54,-66,-16,-78,-78,90,-46,-70,-72,12,96,-86,42,-80,8,-2,70,4,70};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {73,60,4,59,75,39,39,30,66,11,90,80,46,59,52,14,63,70,75,73,65,88,45,64,66,91,67,25,60,74,33,23,94,76,60,78,72};
int param0_4[] = {-92,-88,-68,-64,-62,-56,-50,-48,-48,-38,-18,-16,-14,-8,-8,2,4,10,10,10,36,38,46,50,52,62,72,74,80,84,86,90,92,94,96};
int param0_5[] = {1,0,0,1,1,0,0,0,1,1,1,0,0,1,0,1,1,0,1,0,1,0,1,0,1,1,0,0,0,0,1,0,0,1,1,0,1,0,0};
int param0_6[] = {7,8,8,10,13,18,18,19,20,25,32,33,34,38,44,44,46,46,46,47,48,50,53,56,56,57,57,57,57,59,60,61,63,63,64,70,71,74,74,81,82,83,84,90,92,93};
int param0_7[] = {-82,74,-94,68,-10,-8,-46,-4,50,-60,-70,-74,-18,50,62,-76,-50,-58,-36,-16,-36,78,12,56,-14,-48,40,22,0,16,72,-78,46,8,-50,-78,28,20,-56};
int param0_8[] = {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[] = {88,89,66,28,75,81,29,26,21,39,58,94,48,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[] = {20,17,12,20,33,33,41,26,16,9};
int param2[] = {15,29,17,28,20,26,44,31,18,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;
} | sizeof(int), | [
"a) 2;",
"b) ]",
"c) fract_bit",
"d) sizeof(int),",
"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 ( char str [ ], int l, int h ) {
if ( l > h ) return INT_MAX;
if ( l == h ) return 0;
if ( l == h - 1 ) return ( str [ l ] == str [ h ] ) ? 0 : 1;
return ( str [ l ] == str [ h ] ) ? f_gold ( str, l + 1, h - 1 ) : ( min ( f_gold ( str, l, h - 1 ), f_gold ( str, l + 1, h ) ) + 1 );
}
int f_filled ( char str [ ], int l, int h ) {}
? 0 : 1;
return ( str [ l ] == str [ h ] ) ? f_gold ( str, l + 1, h - 1 ) : ( min ( f_gold ( str, l, h - 1 ), f_gold ( str, l + 1, h ) ) + 1 );
}
int f_filled ( char str [ ], int l, int h ) {}
int main(void) {
int n_success = 0;
char param0_0[] = {'};
char *param0[1] = {param0_0};
int param1[] = {11,19,0,24,33,13,16,31,37,26};
int param2[] = {11,22,0,27,34,8,14,25,35,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);} int f_gold ( char str [ ], int l, int h ) { if ( l > h ) return INT_MAX; if ( l == h ) return 0; if ( l == h - 1 ) return ( str [ l ] == str [ h ] ) ? 0 : 1; return ( str [ l ] == str [ h ] ) ? f_gold ( str, l + 1, h - 1 ) : ( min ( f_gold ( str, l, h - 1 ), f_gold ( str, [MASK] + 1, h ) ) + 1 ); } int f_filled ( char str [ ], int l, int h ) {} ? 0 : 1;
return ( str [ l ] == str [ h ] ) ? f_gold ( str, l + 1, h - 1 ) : ( min ( f_gold ( str, l, h - 1 ), f_gold ( str, l + 1, h ) ) + 1 );
}
int f_filled ( char str [ ], int l, int h ) {}
int main(void) {
int n_success = 0;
char param0_0[] = {'};
char *param0[1] = {param0_0};
int param1[] = {11,19,0,24,33,13,16,31,37,26};
int param2[] = {11,22,0,27,34,8,14,25,35,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;
} | l | [
"a) l",
"b) ]",
"c) (",
"d) return",
"e) for"
] | 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);}
unsigned int f_gold ( unsigned int n ) {
if ( n == 0 ) return 1;
return n * f_gold ( n - 1 );
}
unsigned int f_filled ( unsigned int n ) {}
], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
unsigned int f_gold ( unsigned int n ) {
if ( n == 0 ) return 1;
return n * f_gold ( n - 1 );
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {84,41,5,38,79,80,64,62,24,12};
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, [MASK] 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 ) { if ( n == 0 ) return 1; return n * f_gold ( n - 1 ); } unsigned int f_filled ( unsigned int n ) {} ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
unsigned int f_gold ( unsigned int n ) {
if ( n == 0 ) return 1;
return n * f_gold ( n - 1 );
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {84,41,5,38,79,80,64,62,24,12};
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) <",
"b) if",
"c) d",
"d) int",
"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);}
bool f_gold ( char s [] ) {
int n = strlen(s);
for ( int i = 1;
i < n;
i ++ ) if ( s [ i ] != s [ 0 ] ) return false;
return true;
}
bool f_filled ( char s [] ) {}
eof(int), cmpfunc);}
bool f_gold ( char s [] ) {
int n = strlen(s);
for ( int i = 1;
i < n;
i ++ ) if ( s [ i ] != s [ 0 ] ) return false;
return true;
}
bool f_filled ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"","ggg","11","KoYIHns","232","10111000011101","DDDD","11","11111","ewJvixQzu"};
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 s [] ) { int n = strlen(s); for ( int i = 1; i < n; i ++ ) if ( s [ i ] != s [ 0 ] ) return false; return true; } bool [MASK] ( char s [] ) {}eof(int), cmpfunc);}
bool f_gold ( char s [] ) {
int n = strlen(s);
for ( int i = 1;
i < n;
i ++ ) if ( s [ i ] != s [ 0 ] ) return false;
return true;
}
bool f_filled ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"","ggg","11","KoYIHns","232","10111000011101","DDDD","11","11111","ewJvixQzu"};
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;
} | f_filled | [
"a) f_filled",
"b) =",
"c) i",
"d) [",
"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 arr1 [ ], int arr2 [ ], int n1, int n2 ) {
sort ( arr1, arr1 + n1 );
sort ( arr2, arr2 + n2 );
return arr1 [ n1 - 1 ] * arr2 [ 0 ];
}
int f_filled ( int arr1 [ ], int arr2 [ ], int n1, int n2 ) {}
], int arr2 [ ], int n1, int n2 ) {
sort ( arr1, arr1 + n1 );
sort ( arr2, arr2 + n2 );
return arr1 [ n1 - 1 ] * arr2 [ 0 ];
}
int f_filled ( int arr1 [ ], int arr2 [ ], int n1, int n2 ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,11,12,12,14,14,15,33,51,51,61,63,68,69,75,83,84,97};
int param0_1[] = {88,-10,-18,74,56,-36,-86,72,76,26,-36,10,-6,-80,-34,14,-82,74,48,-76,-78,-50,-62,-86,96,22,42,-28,18,6,58,-72,54};
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,1,1,1,1};
int param0_3[] = {84,2,52,25,38,63,10,44,36,12,67,25,79,36,12,14,14,18,32,8,94,34,9,72,27,44,75,80,28,57,34,67,26,21,53,92,31,87,62};
int param0_4[] = {-64,-60,-36,-36,-34,-32,-18,-16,-2,6,22,36,42,46,52,54,70,94};
int param0_5[] = {0,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,0,1,1,1,0,0,1,0,0,0,0,1,1,0,1,1,0,1,0,1,1,0,0,0,0,0,1,0,1,1,0,1,0};
int param0_6[] = {24,36,73};
int param0_7[] = {86,-46,76,66,38,24,-10,-10,-88,-22,54,12,42,20,-6,-44,-26,78,-46,-88,-6,-24,72,-38,26,84,-70,90,56,-4,94,-72,-44,-40,-8,18,4,-72,72,-72,-38};
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};
int param0_9[] = {41,47,59,85,10,38,4,63,74,71,76,32,54,40,20,38,17,76,87,49,53,73,92,90,36,76,1,65,62,10,93,65};
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,4,5,12,16,27,28,41,44,60,73,76,77,90,91,92,96,96};
int param1_1[] = {24,-26,38,28,94,64,-36,42,62,-50,-12,-18,-72,-76,26,-4,44,-98,32,-48,54,-66,-84,16,-12,-30,-58,42,-88,-40,66,-66,30};
int param1_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,1,1,1,1};
int param1_3[] = {92,20,7,22,79,50,27,19,2,58,93,19,60,45,16,50,87,31,45,8,89,39,61,76,48,92,22,18,19,35,54,32,81,57,22,29,63,83,20};
int param1_4[] = {-96,-92,-64,-44,-22,-22,-22,-20,6,8,14,16,24,40,46,54,76,78};
int param1_5[] = {0,1,1,1,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,0,0,1,0,0,0,1,1,0,1,1,0,1,0,0,1,1,1,0,1,0,1,0,0,1,1,1,1,0,1};
int param1_6[] = {5,41,60};
int param1_7[] = {-30,-38,58,-6,-2,-18,34,24,-52,56,-80,-82,20,64,54,-96,70,-78,78,54,6,-4,34,0,90,-74,-50,-40,16,-48,-4,78,80,-98,-12,-64,94,-42,-22,-34,96};
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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {62,30,71,1,83,88,62,50,88,80,22,98,62,43,84,21,23,89,78,5,36,21,17,30,54,88,66,48,83,12,4,50};
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,20,40,32,11,37,2,20,38,26};
int param3[] = {15,27,39,19,10,44,2,28,35,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: 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);} int f_gold ( int arr1 [ ], int arr2 [ ], int n1, int n2 ) { sort ( arr1, arr1 + n1 ); sort ( arr2, arr2 + n2 ); return arr1 [ n1 - 1 ] * arr2 [ 0 ]; } int f_filled ( int arr1 [ ], int arr2 [ ], int n1, int n2 ) {}], int arr2 [ ], int n1, int n2 ) {
sort ( arr1, arr1 + n1 );
sort ( arr2, arr2 + n2 );
return arr1 [ n1 - 1 ] * arr2 [ 0 ];
}
int f_filled ( int arr1 [ ], int arr2 [ ], int n1, int n2 ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,11,12,12,14,14,15,33,51,51,61,63,68,69,75,83,84,97};
int param0_1[] = {88,-10,-18,74,56,-36,-86,72,76,26,-36,10,-6,-80,-34,14,-82,74,48,-76,-78,-50,-62,-86,96,22,42,-28,18,6,58,-72,54};
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,1,1,1,1};
int param0_3[] = {84,2,52,25,38,63,10,44,36,12,67,25,79,36,12,14,14,18,32,8,94,34,9,72,27,44,75,80,28,57,34,67,26,21,53,92,31,87,62};
int param0_4[] = {-64,-60,-36,-36,-34,-32,-18,-16,-2,6,22,36,42,46,52,54,70,94};
int param0_5[] = {0,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,0,1,1,1,0,0,1,0,0,0,0,1,1,0,1,1,0,1,0,1,1,0,0,0,0,0,1,0,1,1,0,1,0};
int param0_6[] = {24,36,73};
int param0_7[] = {86,-46,76,66,38,24,-10,-10,-88,-22,54,12,42,20,-6,-44,-26,78,-46,-88,-6,-24,72,-38,26,84,-70,90,56,-4,94,-72,-44,-40,-8,18,4,-72,72,-72,-38};
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};
int param0_9[] = {41,47,59,85,10,38,4,63,74,71,76,32,54,40,20,38,17,76,87,49,53,73,92,90,36,76,1,65,62,10,93,65};
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,4,5,12,16,27,28,41,44,60,73,76,77,90,91,92,96,96};
int param1_1[] = {24,-26,38,28,94,64,-36,42,62,-50,-12,-18,-72,-76,26,-4,44,-98,32,-48,54,-66,-84,16,-12,-30,-58,42,-88,-40,66,-66,30};
int param1_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,1,1,1,1};
int param1_3[] = {92,20,7,22,79,50,27,19,2,58,93,19,60,45,16,50,87,31,45,8,89,39,61,76,48,92,22,18,19,35,54,32,81,57,22,29,63,83,20};
int param1_4[] = {-96,-92,-64,-44,-22,-22,-22,-20,6,8,14,16,24,40,46,54,76,78};
int param1_5[] = {0,1,1,1,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,0,0,1,0,0,0,1,1,0,1,1,0,1,0,0,1,1,1,0,1,0,1,0,0,1,1,1,1,0,1};
int param1_6[] = {5,41,60};
int param1_7[] = {-30,-38,58,-6,-2,-18,34,24,-52,56,-80,-82,20,64,54,-96,70,-78,78,54,6,-4,34,0,90,-74,-50,-40,16,-48,-4,78,80,-98,-12,-64,94,-42,-22,-34,96};
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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {62,30,71,1,83,88,62,50,88,80,22,98,62,43,84,21,23,89,78,5,36,21,17,30,54,88,66,48,83,12,4,50};
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,20,40,32,11,37,2,20,38,26};
int param3[] = {15,27,39,19,10,44,2,28,35,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) ]",
"b) #include",
"c) y;",
"d) x:",
"e) 26"
] | 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 s ) {
int sum = 0;
for ( int n = 1;
sum < s;
n ++ ) {
sum += n * n;
if ( sum == s ) return n;
}
return - 1;
}
int f_filled ( int s ) {}
zeof(int), cmpfunc);}
int f_gold ( int s ) {
int sum = 0;
for ( int n = 1;
sum < s;
n ++ ) {
sum += n * n;
if ( sum == s ) return n;
}
return - 1;
}
int f_filled ( int s ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,5,14,140,204,3,506,42,4,87};
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 s ) { int sum = 0; for ( int n = 1; sum < s; n ++ ) { sum += n * n; if ( sum == s ) return n; } return - 1; } int f_filled ( int s ) {}zeof(int), cmpfunc);}
int f_gold ( int s ) {
int sum = 0;
for ( int n = 1;
sum < s;
n ++ ) {
sum += n * n;
if ( sum == s ) return n;
}
return - 1;
}
int f_filled ( int s ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,5,14,140,204,3,506,42,4,87};
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) x:",
"b) :",
"c) <=",
"d) #include",
"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 [] ) {
int n = strlen(str);
int count = 0;
char res = str [ 0 ];
int cur_count = 1;
for ( int i = 0;
i < n;
i ++ ) {
if ( i < n - 1 && str [ i ] == str [ i + 1 ] ) cur_count ++;
else {
if ( cur_count > count ) {
count = cur_count;
res = str [ i ];
}
cur_count = 1;
}
}
return res;
}
char f_filled ( char str [] ) {}
r_count ++;
else {
if ( cur_count > count ) {
count = cur_count;
res = str [ i ];
}
cur_count = 1;
}
}
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) { [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);} char f_gold ( char str [] ) { int n = strlen(str); int count = 0; char res = str [ 0 ]; int cur_count = 1; for ( int i = 0; i < n; i ++ ) { if ( i < n - 1 && str [ i ] == str [ i + 1 ] ) cur_count ++; else { if ( cur_count > count ) { count = cur_count; res = str [ i ]; } cur_count = 1; } } return res; } char f_filled ( char str [] ) {}r_count ++;
else {
if ( cur_count > count ) {
count = cur_count;
res = str [ i ];
}
cur_count = 1;
}
}
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;
} | return | [
"a) Vector",
"b) return",
"c) (",
"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 arr1 [ ], int arr2 [ ], int n ) {
int index = n;
int left = 0, right = n - 1;
while ( left <= right ) {
int mid = ( left + right ) / 2;
if ( arr2 [ mid ] == arr1 [ mid ] ) left = mid + 1;
else {
index = mid;
right = mid - 1;
}
}
return index;
}
int f_filled ( int arr1 [ ], int arr2 [ ], int n ) {}
/ 2;
if ( arr2 [ mid ] == arr1 [ mid ] ) left = mid + 1;
else {
index = mid;
right = mid - 1;
}
}
return index;
}
int f_filled ( int arr1 [ ], int arr2 [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,18,19,25,26,27,31,39,44,46,59,60,66,72,78,83,84,92,94};
int param0_1[] = {-14,-56,92,-90,96,-84,64,-38,-20,84,56,92,18,-78,98,-96,-60,88,-52,-28,30,-90,14,76,56,20,-18,-94,-82,-2,96,-60,-64,-90,42,6,20,-38,82,-86,-4,82,54,-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[] = {13,64,73,50,73,19,92,10,64,79,58,41,97,53,53,10,96,45,47,38,99};
int param0_4[] = {-96,-94,-90,-90,-78,-70,-64,-64,-58,-58,-52,-40,-36,-34,-34,-30,-26,-2,0,2,14,18,24,28,28,30,34,40,42,48,66,72,86,90,92,98};
int param0_5[] = {1,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,1,0};
int param0_6[] = {10,51,74,74,75,80,90};
int param0_7[] = {-44,48,20,-38,-48,-26,56,-62,-94,-18,30,66,-16,80,96,-40,-80,32,88,-56,-76,16,72,-94,4,-34,-92,70,-90,-54,64,-90};
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};
int param0_9[] = {19,53,13,91,52,62,39,84,68,45,32,40,13,68,79,76,11,42,76,30,81,3,30,15,85,76,1};
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[] = {2,5,12,13,17,20,22,46,51,63,64,66,66,76,87,87,90,91,96};
int param1_1[] = {54,44,-50,26,4,-26,-76,98,-14,36,82,0,-60,18,52,82,-12,-8,-26,-58,22,-70,24,48,56,-46,92,98,-50,-72,-66,8,40,12,-80,-86,90,-30,76,-92,80,-62,0,-48};
int param1_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 param1_3[] = {24,42,54,13,88,63,50,73,64,66,86,84,53,4,44,58,44,42,36,94,34};
int param1_4[] = {-94,-92,-90,-88,-86,-82,-82,-80,-76,-74,-64,-60,-58,-46,-44,-36,-30,-30,-30,-18,-16,-8,-6,12,14,20,26,38,40,42,42,68,78,82,88,98};
int param1_5[] = {0,0,1,1,0,0,1,0,1,1,0,1,0,1,1,1,1,1,1,1,0};
int param1_6[] = {12,20,36,38,61,64,93};
int param1_7[] = {-76,92,-66,20,86,40,64,16,54,-6,54,-88,-24,38,86,2,30,70,98,-46,28,34,40,-88,-96,92,22,14,-36,-96,-48,-72};
int param1_8[] = {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 param1_9[] = {33,65,36,82,30,95,42,33,9,21,25,90,54,59,21,45,3,93,67,50,97,72,77,54,75,8,6};
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[] = {11,26,31,13,29,19,5,28,14,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> 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 arr1 [ ], int arr2 [ ], int n ) { int index = n; int left = 0, right = n - 1; while ( left <= right ) { int mid = ( left + right ) / 2; if ( arr2 [ mid ] == arr1 [ mid ] ) left = mid + 1; else { index = mid; right = mid - 1; } } return index; } int f_filled ( int arr1 [ ], int arr2 [ ], int n ) {}/ 2;
if ( arr2 [ mid ] == arr1 [ mid ] ) left = mid + 1;
else {
index = mid;
right = mid - 1;
}
}
return index;
}
int f_filled ( int arr1 [ ], int arr2 [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,18,19,25,26,27,31,39,44,46,59,60,66,72,78,83,84,92,94};
int param0_1[] = {-14,-56,92,-90,96,-84,64,-38,-20,84,56,92,18,-78,98,-96,-60,88,-52,-28,30,-90,14,76,56,20,-18,-94,-82,-2,96,-60,-64,-90,42,6,20,-38,82,-86,-4,82,54,-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[] = {13,64,73,50,73,19,92,10,64,79,58,41,97,53,53,10,96,45,47,38,99};
int param0_4[] = {-96,-94,-90,-90,-78,-70,-64,-64,-58,-58,-52,-40,-36,-34,-34,-30,-26,-2,0,2,14,18,24,28,28,30,34,40,42,48,66,72,86,90,92,98};
int param0_5[] = {1,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,1,0};
int param0_6[] = {10,51,74,74,75,80,90};
int param0_7[] = {-44,48,20,-38,-48,-26,56,-62,-94,-18,30,66,-16,80,96,-40,-80,32,88,-56,-76,16,72,-94,4,-34,-92,70,-90,-54,64,-90};
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};
int param0_9[] = {19,53,13,91,52,62,39,84,68,45,32,40,13,68,79,76,11,42,76,30,81,3,30,15,85,76,1};
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[] = {2,5,12,13,17,20,22,46,51,63,64,66,66,76,87,87,90,91,96};
int param1_1[] = {54,44,-50,26,4,-26,-76,98,-14,36,82,0,-60,18,52,82,-12,-8,-26,-58,22,-70,24,48,56,-46,92,98,-50,-72,-66,8,40,12,-80,-86,90,-30,76,-92,80,-62,0,-48};
int param1_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 param1_3[] = {24,42,54,13,88,63,50,73,64,66,86,84,53,4,44,58,44,42,36,94,34};
int param1_4[] = {-94,-92,-90,-88,-86,-82,-82,-80,-76,-74,-64,-60,-58,-46,-44,-36,-30,-30,-30,-18,-16,-8,-6,12,14,20,26,38,40,42,42,68,78,82,88,98};
int param1_5[] = {0,0,1,1,0,0,1,0,1,1,0,1,0,1,1,1,1,1,1,1,0};
int param1_6[] = {12,20,36,38,61,64,93};
int param1_7[] = {-76,92,-66,20,86,40,64,16,54,-6,54,-88,-24,38,86,2,30,70,98,-46,28,34,40,-88,-96,92,22,14,-36,-96,-48,-72};
int param1_8[] = {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 param1_9[] = {33,65,36,82,30,95,42,33,9,21,25,90,54,59,21,45,3,93,67,50,97,72,77,54,75,8,6};
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[] = {11,26,31,13,29,19,5,28,14,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;
} | y) | [
"a) 1",
"b) javafx.util.Pair;",
"c) s",
"d) y)",
"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 k ) {
int maxSum = 0;
sort ( arr, arr + N );
for ( int i = N - 1;
i > 0;
-- i ) {
if ( arr [ i ] - arr [ i - 1 ] < k ) {
maxSum += arr [ i ];
maxSum += arr [ i - 1 ];
-- i;
}
}
return maxSum;
}
int f_filled ( int arr [ ], int N, int k ) {}
- i ) {
if ( arr [ i ] - arr [ i - 1 ] < k ) {
maxSum += arr [ i ];
maxSum += arr [ i - 1 ];
-- i;
}
}
return maxSum;
}
int f_filled ( int arr [ ], int N, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,10,11,11,12,14,15,17,27,27,28,36,36,44,47,47,54,55,62,64,68,69,70,70,75,76,78,85,85,91,95,97};
int param0_1[] = {-36,78,10,30,-12,-70,-98,-14,-44,-66,-40,-8,78,2,-70,40,92,58,30,10,-84,-62,-86,-50,82,36,-92,-30,-2,-34,88,2,-4,-72};
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,1,1};
int param0_3[] = {77,78,58};
int param0_4[] = {-88,-88,-88,-82,-58,-54,-48,-46,-46,-44,-20,-2,10,28,28,28,42,42,44,50,50,54,56,58,62,68,70,72,74,76,78,88,90,92};
int param0_5[] = {0,1,0,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,1,1,1,0,0,0,0,1,0,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1};
int param0_6[] = {5,7,10,11,15,17,20,20,29,29,32,37,38,39,40,41,45,51,60,64,64,68,68,70,71,71,71,75,76,82,84,87,88,88,95,98};
int param0_7[] = {-46,-32,76,-28,44,-14,94,-4,60,-88,-52,32,-66,28,94,76,86,-4,74,52,64,-36,-98,-40,70,18,-22,-20,-16,-74,12,60,94,98,-28,-24,4,-34,-60,56};
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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {79,13,25,22,61,1,2,73,66,94,47,9,1,99,25,39,95,46,95,20,63,15,14,36,9,91,14};
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[] = {26,26,47,1,21,41,30,33,28,19};
int param2[] = {18,25,26,1,24,40,21,23,41,23};
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 maxSum = 0; sort ( arr, arr + N ); for ( int i = N - 1; i > 0; -- i ) { if ( arr [ i ] - arr [ i - 1 ] < k ) { maxSum += arr [ i ]; maxSum [MASK] arr [ i - 1 ]; -- i; } } return maxSum; } int f_filled ( int arr [ ], int N, int k ) {}- i ) {
if ( arr [ i ] - arr [ i - 1 ] < k ) {
maxSum += arr [ i ];
maxSum += arr [ i - 1 ];
-- i;
}
}
return maxSum;
}
int f_filled ( int arr [ ], int N, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,10,11,11,12,14,15,17,27,27,28,36,36,44,47,47,54,55,62,64,68,69,70,70,75,76,78,85,85,91,95,97};
int param0_1[] = {-36,78,10,30,-12,-70,-98,-14,-44,-66,-40,-8,78,2,-70,40,92,58,30,10,-84,-62,-86,-50,82,36,-92,-30,-2,-34,88,2,-4,-72};
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,1,1};
int param0_3[] = {77,78,58};
int param0_4[] = {-88,-88,-88,-82,-58,-54,-48,-46,-46,-44,-20,-2,10,28,28,28,42,42,44,50,50,54,56,58,62,68,70,72,74,76,78,88,90,92};
int param0_5[] = {0,1,0,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,1,1,1,0,0,0,0,1,0,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1};
int param0_6[] = {5,7,10,11,15,17,20,20,29,29,32,37,38,39,40,41,45,51,60,64,64,68,68,70,71,71,71,75,76,82,84,87,88,88,95,98};
int param0_7[] = {-46,-32,76,-28,44,-14,94,-4,60,-88,-52,32,-66,28,94,76,86,-4,74,52,64,-36,-98,-40,70,18,-22,-20,-16,-74,12,60,94,98,-28,-24,4,-34,-60,56};
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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {79,13,25,22,61,1,2,73,66,94,47,9,1,99,25,39,95,46,95,20,63,15,14,36,9,91,14};
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[] = {26,26,47,1,21,41,30,33,28,19};
int param2[] = {18,25,26,1,24,40,21,23,41,23};
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) not",
"b) +=",
"c) (",
"d) cmpfunc);}",
"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, int K ) {
int ans = 0;
int y = N / K;
int x = N % K;
ans = ( K * ( K - 1 ) / 2 ) * y + ( x * ( x + 1 ) ) / 2;
return ans;
}
int f_filled ( int N, int K ) {}
func);}
int f_gold ( int N, int K ) {
int ans = 0;
int y = N / K;
int x = N % K;
ans = ( K * ( K - 1 ) / 2 ) * y + ( x * ( x + 1 ) ) / 2;
return ans;
}
int f_filled ( int N, int K ) {}
int main(void) {
int n_success = 0;
int param0[] = {40,46,97,63,92,60,67,61,74,67};
int param1[] = {90,64,20,1,52,35,40,62,61,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 [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 ( int N, int K ) { int ans = 0; int y = N / K; int x = N % K; ans = ( K * ( K - 1 ) / 2 ) * y + ( x * ( x + 1 ) ) / 2; return ans; } int f_filled ( int N, int K ) {}func);}
int f_gold ( int N, int K ) {
int ans = 0;
int y = N / K;
int x = N % K;
ans = ( K * ( K - 1 ) / 2 ) * y + ( x * ( x + 1 ) ) / 2;
return ans;
}
int f_filled ( int N, int K ) {}
int main(void) {
int n_success = 0;
int param0[] = {40,46,97,63,92,60,67,61,74,67};
int param1[] = {90,64,20,1,52,35,40,62,61,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;
} | void | [
"a) void",
"b) ;",
"c) (",
"d) namespace",
"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 n ) {
return ( 1 << ( n - 1 ) );
}
int f_filled ( int n ) {}
((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( 1 << ( n - 1 ) );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {56,28,4,24,72,30,48,32,13,19};
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: [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 ( int n ) { return ( 1 << ( n - 1 ) ); } int f_filled ( int n ) {} ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
return ( 1 << ( n - 1 ) );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {56,28,4,24,72,30,48,32,13,19};
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;
} | y; | [
"a) [",
"b) )",
"c) java.lang.*;",
"d) <=",
"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);}
int f_gold ( int x ) {
return ( 3 * x * ( x + 1 ) ) / 2;
}
int f_filled ( int x ) {}
(sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int x ) {
return ( 3 * x * ( x + 1 ) ) / 2;
}
int f_filled ( int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {6,25,15,30,17,80,27,13,12,67};
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] 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 ( 3 * x * ( x + 1 ) ) / 2; } int f_filled ( int x ) {} (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int x ) {
return ( 3 * x * ( x + 1 ) ) / 2;
}
int f_filled ( int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {6,25,15,30,17,80,27,13,12,67};
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) .",
"b) int",
"c) :",
"d) javafx.util.Pair;",
"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 arr1 [ ], int arr2 [ ], int m, int n, int x ) {
int count = 0;
unordered_set < int > us;
for ( int i = 0;
i < m;
i ++ ) us . insert ( arr1 [ i ] );
for ( int j = 0;
j < n;
j ++ ) if ( us . find ( x - arr2 [ j ] ) != us . end ( ) ) count ++;
return count;
}
int f_filled ( int arr1 [ ], int arr2 [ ], int m, int n, int x ) {}
1 [ i ] );
for ( int j = 0;
j < n;
j ++ ) if ( us . find ( x - arr2 [ j ] ) != us . end ( ) ) count ++;
return count;
}
int f_filled ( int arr1 [ ], int arr2 [ ], int m, int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,5,5,9,11,12,14,16,18,35,36,39,44,50,52,52,59,69,81,82,84,85,87,87,87,88,88,89,90,90,92,97};
int param0_1[] = {52,28,-38,78,-86,78,-48,-70,-80,28,-8,60,-28,90,6,76,32,-54,30,30,-32,-24,-36,62,36,-66,56,92,-20,90,32};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_3[] = {91,95,13,13,76,18,36,86,26,13,17,68,58,42,38,9,42,90,14,74,38,64,15};
int param0_4[] = {-96,-94,-94,-92,-74,-70,-66,-54,-48,-20,-18,-10,-6,-2,2,18,36,48,52,58,68,74,88,90,94};
int param0_5[] = {1,1,1,0,0,0,1,1,0,0,1,0,1,0,1,1,1,0,1,0,1,0,0,1,1,1,1,0,1,1,0};
int param0_6[] = {7,18,19,20,24,25,25,27,30,35,39,42,58,59,63,64,64,66,66,68,69,77,86,93};
int param0_7[] = {86,44,10,80,12,52,-92,2,42,-32,-14,2,-42,40,96,22,58,-90,-20,22,96,10,-92,-28,-28,80,36,72,-2,32,-46,62,-58,20,22,32,-98,-2,-42,-90,10,70,54,-32};
int param0_8[] = {0,0,1,1,1,1};
int param0_9[] = {43,2,4,99,45,80,27,8,64,77,57,55,71,67,51,42,58,70,5,62,55,20,61,47,66,80,70,24,56,22,58,63,61,41,20,97,47};
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[] = {5,5,8,20,20,24,25,29,34,37,43,45,48,49,59,60,68,70,70,72,72,75,76,77,79,81,84,85,86,88,95,96,96};
int param1_1[] = {-88,-32,30,32,-46,62,-92,-90,-18,-18,10,16,60,-40,32,-88,60,-82,76,50,86,-82,-48,-68,-42,34,4,0,98,92,-78};
int param1_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param1_3[] = {16,96,8,35,12,27,81,21,32,82,95,81,53,76,72,16,9,16,61,1,36,71,28};
int param1_4[] = {-92,-72,-72,-64,-58,-52,-30,-28,-24,-24,-16,-10,-2,4,12,22,30,38,44,62,64,68,86,88,90};
int param1_5[] = {1,0,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,1,0,0,1,0,0,0,0,0,1,1,1,0,0};
int param1_6[] = {2,2,18,20,22,22,31,35,36,40,41,41,41,42,42,43,45,61,79,83,87,91,95,96};
int param1_7[] = {-4,-76,-98,14,30,-10,-10,62,88,-94,-74,-82,84,44,58,8,-42,-66,-18,68,-78,42,-32,38,-98,38,-78,42,86,-38,-6,-72,-44,8,-6,-48,-62,82,94,-92,-56,28,-54,34};
int param1_8[] = {0,0,1,1,1,1};
int param1_9[] = {11,66,41,17,93,25,24,17,12,33,62,86,48,68,36,36,39,82,7,66,5,48,27,9,56,6,61,91,98,74,61,63,98,96,57,63,85};
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[] = {17,30,13,11,19,18,22,26,5,24};
int param3[] = {29,27,11,12,14,19,18,36,3,29};
int param4[] = {32,17,8,15,21,29,18,31,5,21};
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 arr1 [ ], int arr2 [ ], int m, int n, int x ) { int count = 0; unordered_set < int > us; for ( int i = 0; i < m; i ++ ) us . insert ( arr1 [ i ] ); for ( int j = 0; j < n; j ++ ) if ( us . find ( x - arr2 [ j ] ) != us [MASK] end ( ) ) count ++; return count; } int f_filled ( int arr1 [ ], int arr2 [ ], int m, int n, int x ) {}1 [ i ] );
for ( int j = 0;
j < n;
j ++ ) if ( us . find ( x - arr2 [ j ] ) != us . end ( ) ) count ++;
return count;
}
int f_filled ( int arr1 [ ], int arr2 [ ], int m, int n, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,5,5,9,11,12,14,16,18,35,36,39,44,50,52,52,59,69,81,82,84,85,87,87,87,88,88,89,90,90,92,97};
int param0_1[] = {52,28,-38,78,-86,78,-48,-70,-80,28,-8,60,-28,90,6,76,32,-54,30,30,-32,-24,-36,62,36,-66,56,92,-20,90,32};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_3[] = {91,95,13,13,76,18,36,86,26,13,17,68,58,42,38,9,42,90,14,74,38,64,15};
int param0_4[] = {-96,-94,-94,-92,-74,-70,-66,-54,-48,-20,-18,-10,-6,-2,2,18,36,48,52,58,68,74,88,90,94};
int param0_5[] = {1,1,1,0,0,0,1,1,0,0,1,0,1,0,1,1,1,0,1,0,1,0,0,1,1,1,1,0,1,1,0};
int param0_6[] = {7,18,19,20,24,25,25,27,30,35,39,42,58,59,63,64,64,66,66,68,69,77,86,93};
int param0_7[] = {86,44,10,80,12,52,-92,2,42,-32,-14,2,-42,40,96,22,58,-90,-20,22,96,10,-92,-28,-28,80,36,72,-2,32,-46,62,-58,20,22,32,-98,-2,-42,-90,10,70,54,-32};
int param0_8[] = {0,0,1,1,1,1};
int param0_9[] = {43,2,4,99,45,80,27,8,64,77,57,55,71,67,51,42,58,70,5,62,55,20,61,47,66,80,70,24,56,22,58,63,61,41,20,97,47};
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[] = {5,5,8,20,20,24,25,29,34,37,43,45,48,49,59,60,68,70,70,72,72,75,76,77,79,81,84,85,86,88,95,96,96};
int param1_1[] = {-88,-32,30,32,-46,62,-92,-90,-18,-18,10,16,60,-40,32,-88,60,-82,76,50,86,-82,-48,-68,-42,34,4,0,98,92,-78};
int param1_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param1_3[] = {16,96,8,35,12,27,81,21,32,82,95,81,53,76,72,16,9,16,61,1,36,71,28};
int param1_4[] = {-92,-72,-72,-64,-58,-52,-30,-28,-24,-24,-16,-10,-2,4,12,22,30,38,44,62,64,68,86,88,90};
int param1_5[] = {1,0,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,1,0,0,1,0,0,0,0,0,1,1,1,0,0};
int param1_6[] = {2,2,18,20,22,22,31,35,36,40,41,41,41,42,42,43,45,61,79,83,87,91,95,96};
int param1_7[] = {-4,-76,-98,14,30,-10,-10,62,88,-94,-74,-82,84,44,58,8,-42,-66,-18,68,-78,42,-32,38,-98,38,-78,42,86,-38,-6,-72,-44,8,-6,-48,-62,82,94,-92,-56,28,-54,34};
int param1_8[] = {0,0,1,1,1,1};
int param1_9[] = {11,66,41,17,93,25,24,17,12,33,62,86,48,68,36,36,39,82,7,66,5,48,27,9,56,6,61,91,98,74,61,63,98,96,57,63,85};
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[] = {17,30,13,11,19,18,22,26,5,24};
int param3[] = {29,27,11,12,14,19,18,36,3,29};
int param4[] = {32,17,8,15,21,29,18,31,5,21};
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) ;",
"d) 0",
"e) b;"
] | 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 str1 [], char str2 [] ) {
if ( strlen(str1) > strlen(str2) ) swap ( str1, str2 );
char str [] = "";
int n1 = strlen(str1), n2 = strlen(str2);
reverse ( str1 . begin ( ), str1 . end ( ) );
reverse ( str2 . begin ( ), str2 . end ( ) );
int carry = 0;
for ( int i = 0;
i < n1;
i ++ ) {
int sum = ( ( str1 [ i ] - '0' ) + ( str2 [ i ] - '0' ) + carry );
str . push_back ( sum % 10 + '0' );
carry = sum / 10;
}
for ( int i = n1;
i < n2;
i ++ ) {
int sum = ( ( str2 [ i ] - '0' ) + carry );
str . push_back ( sum % 10 + '0' );
carry = sum / 10;
}
if ( carry ) str . push_back ( carry + '0' );
reverse ( str . begin ( ), str . end ( ) );
return str;
}
char f_filled [] ( char str1 [], char str2 [] ) {}
+ '0' );
carry = sum / 10;
}
if ( carry ) str . push_back ( carry + '0' );
reverse ( str . begin ( ), str . end ( ) );
return str;
}
char f_filled [] ( char str1 [], char str2 [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"VkfzrPG","0526110506447","011010010","sPAwZACc ","3","0101","VTtNu","2317170","111111000010","Ktt"};
char param1[][100] = {"rKZ","903","110100000","liYMsojPiinOV","611","01110101011","Wsmc","898421173423","01100001110111","CTbbVX wGBkE"};
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);} char f_gold [] ( char str1 [], char str2 [] ) { if ( strlen(str1) > strlen(str2) ) swap ( str1, str2 ); char str [] = ""; int [MASK] = strlen(str1), n2 = strlen(str2); reverse ( str1 . begin ( ), str1 . end ( ) ); reverse ( str2 . begin ( ), str2 . end ( ) ); int carry = 0; for ( int i = 0; i < n1; i ++ ) { int sum = ( ( str1 [ i ] - '0' ) + ( str2 [ i ] - '0' ) + carry ); str . push_back ( sum % 10 + '0' ); carry = sum / 10; } for ( int i = n1; i < n2; i ++ ) { int sum = ( ( str2 [ i ] - '0' ) + carry ); str . push_back ( sum % 10 + '0' ); carry = sum / 10; } if ( carry ) str . push_back ( carry + '0' ); reverse ( str . begin ( ), str . end ( ) ); return str; } char f_filled [] ( char str1 [], char str2 [] ) {}+ '0' );
carry = sum / 10;
}
if ( carry ) str . push_back ( carry + '0' );
reverse ( str . begin ( ), str . end ( ) );
return str;
}
char f_filled [] ( char str1 [], char str2 [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"VkfzrPG","0526110506447","011010010","sPAwZACc ","3","0101","VTtNu","2317170","111111000010","Ktt"};
char param1[][100] = {"rKZ","903","110100000","liYMsojPiinOV","611","01110101011","Wsmc","898421173423","01100001110111","CTbbVX wGBkE"};
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;
} | n1 | [
"a) math.factorial",
"b) i",
"c) (",
"d) arr",
"e) n1"
] | 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 lioes [ n ];
int maxLen = 0;
for ( int i = 0;
i < n;
i ++ ) lioes [ i ] = 1;
for ( int i = 1;
i < n;
i ++ ) for ( int j = 0;
j < i;
j ++ ) if ( arr [ i ] > arr [ j ] && ( arr [ i ] + arr [ j ] ) % 2 != 0 && lioes [ i ] < lioes [ j ] + 1 ) lioes [ i ] = lioes [ j ] + 1;
for ( int i = 0;
i < n;
i ++ ) if ( maxLen < lioes [ i ] ) maxLen = lioes [ i ];
return maxLen;
}
int f_filled ( int arr [ ], int n ) {}
< lioes [ j ] + 1 ) lioes [ i ] = lioes [ j ] + 1;
for ( int i = 0;
i < n;
i ++ ) if ( maxLen < lioes [ i ] ) maxLen = lioes [ i ];
return maxLen;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,8,9,16,16,27,32,33,35,35,39,39,41,42,44,47,48,50,56,59,66,69,70,73,74,76,78,87,87,89,94,96,96,98,98};
int param0_1[] = {40,76,-54,-92,-28,-96,8,60,28,-38,-62,-40,-16,16,52,28,70,-56,-50,46,68,-16,-56,46,42,70,52,-34,86,-32,-50,64,36,54,20,82,84};
int param0_2[] = {0,0,0,0,1,1,1};
int param0_3[] = {15,19,87,44,15,48,21,85,90,30,88,95,48,92,29,52,46,46,7,23,96,97,43};
int param0_4[] = {-98,-96,-94,-94,-94,-80,-80,-78,-64,-62,-62,-46,-42,-38,-36,-36,-34,-32,-20,-18,-16,-12,-8,-4,-4,-2,-2,2,6,12,34,40,42,44,46,46,50,54,58,58,70,72,72,76,78,86};
int param0_5[] = {0,0,1,1,0,1,0,1,0,1,1,0,1,0,0,1,0,1,0,1,0,0,0,1,0,0,1};
int param0_6[] = {6,7,19,36,44,63,68,72,83};
int param0_7[] = {-64,12,56,50,94,6,0,70,-70,46,-84,-64,4,76,28,94,-8,24,76,64,-62,-34};
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,1,1,1,1};
int param0_9[] = {71,57,20,8,90,69,15,62,45,14,65,20,48,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[] = {32,25,4,19,33,13,8,15,21,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);} int f_gold ( int arr [ ], int n ) { int lioes [ n ]; int maxLen = 0; for ( int i = 0; i < n; i ++ ) lioes [ i ] = 1; for ( int i = 1; i < n; i ++ ) for ( int j = 0; j < i; j ++ ) if ( arr [ i ] > arr [ j ] && ( arr [ i ] + arr [ j ] ) % 2 != 0 && lioes [ i ] < lioes [ j ] + 1 ) lioes [ i [MASK] = lioes [ j ] + 1; for ( int i = 0; i < n; i ++ ) if ( maxLen < lioes [ i ] ) maxLen = lioes [ i ]; return maxLen; } int f_filled ( int arr [ ], int n ) {}< lioes [ j ] + 1 ) lioes [ i ] = lioes [ j ] + 1;
for ( int i = 0;
i < n;
i ++ ) if ( maxLen < lioes [ i ] ) maxLen = lioes [ i ];
return maxLen;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,8,9,16,16,27,32,33,35,35,39,39,41,42,44,47,48,50,56,59,66,69,70,73,74,76,78,87,87,89,94,96,96,98,98};
int param0_1[] = {40,76,-54,-92,-28,-96,8,60,28,-38,-62,-40,-16,16,52,28,70,-56,-50,46,68,-16,-56,46,42,70,52,-34,86,-32,-50,64,36,54,20,82,84};
int param0_2[] = {0,0,0,0,1,1,1};
int param0_3[] = {15,19,87,44,15,48,21,85,90,30,88,95,48,92,29,52,46,46,7,23,96,97,43};
int param0_4[] = {-98,-96,-94,-94,-94,-80,-80,-78,-64,-62,-62,-46,-42,-38,-36,-36,-34,-32,-20,-18,-16,-12,-8,-4,-4,-2,-2,2,6,12,34,40,42,44,46,46,50,54,58,58,70,72,72,76,78,86};
int param0_5[] = {0,0,1,1,0,1,0,1,0,1,1,0,1,0,0,1,0,1,0,1,0,0,0,1,0,0,1};
int param0_6[] = {6,7,19,36,44,63,68,72,83};
int param0_7[] = {-64,12,56,50,94,6,0,70,-70,46,-84,-64,4,76,28,94,-8,24,76,64,-62,-34};
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,1,1,1,1};
int param0_9[] = {71,57,20,8,90,69,15,62,45,14,65,20,48,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[] = {32,25,4,19,33,13,8,15,21,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) return",
"b) (x1",
"c) length",
"d) i",
"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 arr [ ], int l, int r, int x ) {
if ( r >= l ) {
int mid = l + ( r - l ) / 2;
if ( arr [ mid ] == x ) return mid;
if ( mid > l && arr [ mid - 1 ] == x ) return ( mid - 1 );
if ( mid < r && arr [ mid + 1 ] == x ) return ( mid + 1 );
if ( arr [ mid ] > x ) return f_gold ( arr, l, mid - 2, x );
return f_gold ( arr, mid + 2, r, x );
}
return - 1;
}
int f_filled ( int arr [ ], int l, int r, int x ) {}
rn ( mid + 1 );
if ( arr [ mid ] > x ) return f_gold ( arr, l, mid - 2, x );
return f_gold ( arr, mid + 2, r, x );
}
return - 1;
}
int f_filled ( int arr [ ], int l, int r, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {75,91,93};
int param0_1[] = {-92,-96,-68,-40,70};
int param0_2[] = {-92,-86,-68,-40,70};
int param0_3[] = {-3,-1,0,30,10,45,70,60};
int param0_4[] = {-3,-1,0,10,5,45,60,50};
int param0_5[] = {-3,-1,0,10,30,45,60,70};
int param0_6[] = {0,0,1};
int param0_7[] = {1,1,1};
int param0_8[] = {30,2,30,45};
int *param0[9] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8};
int param1[] = {0,0,0,0,0,0,0,0,0,0};
int param2[] = {15,15,4,4,7,7,7,2,2,3};
int param3[] = {71,71,-96,20,0,12,18,20,17,28};
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 l, [MASK] r, int x ) { if ( r >= l ) { int mid = l + ( r - l ) / 2; if ( arr [ mid ] == x ) return mid; if ( mid > l && arr [ mid - 1 ] == x ) return ( mid - 1 ); if ( mid < r && arr [ mid + 1 ] == x ) return ( mid + 1 ); if ( arr [ mid ] > x ) return f_gold ( arr, l, mid - 2, x ); return f_gold ( arr, mid + 2, r, x ); } return - 1; } int f_filled ( int arr [ ], int l, int r, int x ) {}rn ( mid + 1 );
if ( arr [ mid ] > x ) return f_gold ( arr, l, mid - 2, x );
return f_gold ( arr, mid + 2, r, x );
}
return - 1;
}
int f_filled ( int arr [ ], int l, int r, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {75,91,93};
int param0_1[] = {-92,-96,-68,-40,70};
int param0_2[] = {-92,-86,-68,-40,70};
int param0_3[] = {-3,-1,0,30,10,45,70,60};
int param0_4[] = {-3,-1,0,10,5,45,60,50};
int param0_5[] = {-3,-1,0,10,30,45,60,70};
int param0_6[] = {0,0,1};
int param0_7[] = {1,1,1};
int param0_8[] = {30,2,30,45};
int *param0[9] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8};
int param1[] = {0,0,0,0,0,0,0,0,0,0};
int param2[] = {15,15,4,4,7,7,7,2,2,3};
int param3[] = {71,71,-96,20,0,12,18,20,17,28};
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;
} | int | [
"a) W",
"b) int",
"c) if",
"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 s ) {
int maxvalue = 0;
for ( int i = 1;
i <= s - 2;
i ++ ) {
for ( int j = 1;
j <= s - 1;
j ++ ) {
int k = s - i - j;
maxvalue = max ( maxvalue, i * j * k );
}
}
return maxvalue;
}
int f_filled ( int s ) {}
s - 2;
i ++ ) {
for ( int j = 1;
j <= s - 1;
j ++ ) {
int k = s - i - j;
maxvalue = max ( maxvalue, i * j * k );
}
}
return maxvalue;
}
int f_filled ( int s ) {}
int main(void) {
int n_success = 0;
int param0[] = {67,48,59,22,14,66,1,75,58,78};
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 );} [MASK] 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 s ) { int maxvalue = 0; for ( int i = 1; i <= s - 2; i ++ ) { for ( int j = 1; j <= s - 1; j ++ ) { int k = s - i - j; maxvalue = max ( maxvalue, i * j * k ); } } return maxvalue; } int f_filled ( int s ) {}s - 2;
i ++ ) {
for ( int j = 1;
j <= s - 1;
j ++ ) {
int k = s - i - j;
maxvalue = max ( maxvalue, i * j * k );
}
}
return maxvalue;
}
int f_filled ( int s ) {}
int main(void) {
int n_success = 0;
int param0[] = {67,48,59,22,14,66,1,75,58,78};
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) )",
"b) #include",
"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);}
bool f_gold ( char str [ ], int k ) {
int n = strlen ( str );
int c = 0;
for ( int i = 0;
i < k;
i ++ ) if ( str [ n - i - 1 ] == '0' ) c ++;
return ( c == k );
}
bool f_filled ( char str [ ], int k ) {}
tr [ ], int k ) {
int n = strlen ( str );
int c = 0;
for ( int i = 0;
i < k;
i ++ ) if ( str [ n - i - 1 ] == '0' ) c ++;
return ( c == k );
}
bool f_filled ( char str [ ], int k ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"111010100","111010100","111010100","111010000","111010000","10110001","tPPdXrYQSI","58211787","011","IkSMGqgzOrteVO"};
int param1[] = {2,2,4,3,4,1,61,73,88,23};
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 [MASK] arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( char str [ ], int k ) { int n = strlen ( str ); int c = 0; for ( int i = 0; i < k; i ++ ) if ( str [ n - i - 1 ] == '0' ) c ++; return ( c == k ); } bool f_filled ( char str [ ], int k ) {}tr [ ], int k ) {
int n = strlen ( str );
int c = 0;
for ( int i = 0;
i < k;
i ++ ) if ( str [ n - i - 1 ] == '0' ) c ++;
return ( c == k );
}
bool f_filled ( char str [ ], int k ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"111010100","111010100","111010100","111010000","111010000","10110001","tPPdXrYQSI","58211787","011","IkSMGqgzOrteVO"};
int param1[] = {2,2,4,3,4,1,61,73,88,23};
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;
} | (int | [
"a) int",
"b) ]",
"c) i",
"d) (int",
"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);}
char f_gold [] ( char s [] ) {
if ( s == "" ) return "a";
int i = strlen(s) - 1;
while ( s [ i ] == 'z' && i >= 0 ) i --;
if ( i == - 1 ) s = s + 'a';
else s [ i ] ++;
return s;
}
char f_filled [] ( char s [] ) {}
if ( s == "" ) return "a";
int i = strlen(s) - 1;
while ( s [ i ] == 'z' && i >= 0 ) i --;
if ( i == - 1 ) s = s + 'a';
else s [ i ] ++;
return s;
}
char f_filled [] ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"amKIRzPiqLTIy","68","100","f","802205375","0111","GRjRYIvYwgua","8139910006809","100101","rw"};
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 [] ) { if ( s == "" ) return "a"; int i = strlen(s) - 1; while ( s [ i ] == 'z' && i >= 0 ) i --; if ( i == - 1 ) s = s + 'a'; else [MASK] [ i ] ++; return s; } char f_filled [] ( char s [] ) {}
if ( s == "" ) return "a";
int i = strlen(s) - 1;
while ( s [ i ] == 'z' && i >= 0 ) i --;
if ( i == - 1 ) s = s + 'a';
else s [ i ] ++;
return s;
}
char f_filled [] ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"amKIRzPiqLTIy","68","100","f","802205375","0111","GRjRYIvYwgua","8139910006809","100101","rw"};
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;
} | s | [
"a) #include",
"b) import",
"c) (",
"d) s",
"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);}
bool f_gold ( string & str ) {
vector < bool > mark ( 26, false );
int index;
for ( int i = 0;
i < strlen(str);
i ++ ) {
if ( 'A' <= str [ i ] && str [ i ] <= 'Z' ) index = str [ i ] - 'A';
else if ( 'a' <= str [ i ] && str [ i ] <= 'z' ) index = str [ i ] - 'a';
mark [ index ] = true;
}
for ( int i = 0;
i <= 25;
i ++ ) if ( mark [ i ] == false ) return ( false );
return ( true );
}
bool f_filled ( string & str ) {}
index = str [ i ] - 'a';
mark [ index ] = true;
}
for ( int i = 0;
i <= 25;
i ++ ) if ( mark [ i ] == false ) return ( false );
return ( true );
}
bool f_filled ( string & str ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {
"The quick brown fox jumps over the lazy dog ",
"The quick brown fox jumps over the dog",
"abcdefghijklmnopqrstuvwxyz",
"AbcdefghijKlmnopqrstUVwxyz",
"The quicK broWn fOX jumps over the laZYy dog ",
"AbcdefghijKlmnopqrstVwxyz",
"U",
"397548458372",
"11",
"iwCiUFU r"};
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 & str ) { vector < bool > mark ( 26, false ); int index; for ( int i = 0; i < strlen(str); i ++ ) { if ( 'A' <= str [ i ] && str [ i ] <= 'Z' [MASK] index = str [ i ] - 'A'; else if ( 'a' <= str [ i ] && str [ i ] <= 'z' ) index = str [ i ] - 'a'; mark [ index ] = true; } for ( int i = 0; i <= 25; i ++ ) if ( mark [ i ] == false ) return ( false ); return ( true ); } bool f_filled ( string & str ) {} index = str [ i ] - 'a';
mark [ index ] = true;
}
for ( int i = 0;
i <= 25;
i ++ ) if ( mark [ i ] == false ) return ( false );
return ( true );
}
bool f_filled ( string & str ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {
"The quick brown fox jumps over the lazy dog ",
"The quick brown fox jumps over the dog",
"abcdefghijklmnopqrstuvwxyz",
"AbcdefghijKlmnopqrstUVwxyz",
"The quicK broWn fOX jumps over the laZYy dog ",
"AbcdefghijKlmnopqrstVwxyz",
"U",
"397548458372",
"11",
"iwCiUFU r"};
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 n ) {
int count = 0;
for ( int curr = 19;
;
curr += 9 ) {
int sum = 0;
for ( int x = curr;
x > 0;
x = x / 10 ) sum = sum + x % 10;
if ( sum == 10 ) count ++;
if ( count == n ) return curr;
}
return - 1;
}
int f_filled ( int n ) {}
nt sum = 0;
for ( int x = curr;
x > 0;
x = x / 10 ) sum = sum + x % 10;
if ( sum == 10 ) count ++;
if ( count == n ) return curr;
}
return - 1;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {93,10,55,94,2,5,37,4,11,46};
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 [MASK] void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { int count = 0; for ( int curr = 19; ; curr += 9 ) { int sum = 0; for ( int x = curr; x > 0; x = x / 10 ) sum = sum + x % 10; if ( sum == 10 ) count ++; if ( count == n ) return curr; } return - 1; } int f_filled ( int n ) {}nt sum = 0;
for ( int x = curr;
x > 0;
x = x / 10 ) sum = sum + x % 10;
if ( sum == 10 ) count ++;
if ( count == n ) return curr;
}
return - 1;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {93,10,55,94,2,5,37,4,11,46};
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;
} | (arr)[0]));} | [
"a) (",
"b) <stdbool.h>",
"c) (arr)[0]));}",
"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 n ) {
if ( n < 0 ) return 0;
if ( n <= 1 ) return 1;
double digits = 0;
for ( int i = 2;
i <= n;
i ++ ) digits += log10 ( i );
return floor ( digits ) + 1;
}
int f_filled ( int n ) {}
) {
if ( n < 0 ) return 0;
if ( n <= 1 ) return 1;
double digits = 0;
for ( int i = 2;
i <= n;
i ++ ) digits += log10 ( i );
return floor ( digits ) + 1;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {66,7,55,37,76,16,17,95,71,90};
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, [MASK] 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 ) return 0; if ( n <= 1 ) return 1; double digits = 0; for ( int i = 2; i <= n; i ++ ) digits += log10 ( i ); return floor ( digits ) + 1; } int f_filled ( int n ) {}) {
if ( n < 0 ) return 0;
if ( n <= 1 ) return 1;
double digits = 0;
for ( int i = 2;
i <= n;
i ++ ) digits += log10 ( i );
return floor ( digits ) + 1;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {66,7,55,37,76,16,17,95,71,90};
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) );}",
"b) a",
"c) ]",
"d) i",
"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);}
bool f_gold ( char str1 [], char str2 [] ) {
if ( strlen(str1) != strlen(str2) ) return false;
char clock_rot [] = "";
char anticlock_rot [] = "";
int len = strlen(str2);
anticlock_rot = anticlock_rot + str2 . substr ( len - 2, 2 ) + str2 . substr ( 0, len - 2 );
clock_rot = clock_rot + str2 . substr ( 2 ) + str2 . substr ( 0, 2 );
return ( str1 . compare ( clock_rot ) == 0 || str1 . compare ( anticlock_rot ) == 0 );
}
bool f_filled ( char str1 [], char str2 [] ) {}
lock_rot + str2 . substr ( 2 ) + str2 . substr ( 0, 2 );
return ( str1 . compare ( clock_rot ) == 0 || str1 . compare ( anticlock_rot ) == 0 );
}
bool f_filled ( char str1 [], char str2 [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"amazon","onamaz","amazon","ab","737009","000110","l","4420318628","11011111000000"," pvFHANc"};
char param1[][100] = {"azonam","amazon","azoman","ab","239119","01111","YVo hqvnGxow","52856","10","xBIDFbiGb"};
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] 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 [] ) { if ( strlen(str1) != strlen(str2) ) return false; char clock_rot [] = ""; char anticlock_rot [] = ""; int len = strlen(str2); anticlock_rot = anticlock_rot + str2 . substr ( len - 2, 2 ) + str2 . substr ( 0, len - 2 ); clock_rot = clock_rot + str2 . substr ( 2 ) + str2 . substr ( 0, 2 ); return ( str1 . compare ( clock_rot ) == 0 || str1 . compare ( anticlock_rot ) == 0 ); } bool f_filled ( char str1 [], char str2 [] ) {}lock_rot + str2 . substr ( 2 ) + str2 . substr ( 0, 2 );
return ( str1 . compare ( clock_rot ) == 0 || str1 . compare ( anticlock_rot ) == 0 );
}
bool f_filled ( char str1 [], char str2 [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"amazon","onamaz","amazon","ab","737009","000110","l","4420318628","11011111000000"," pvFHANc"};
char param1[][100] = {"azonam","amazon","azoman","ab","239119","01111","YVo hqvnGxow","52856","10","xBIDFbiGb"};
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) int",
"b) :",
"c) return",
"d) f_gold",
"e) s"
] | 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);}
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[] = {74,70,85,78,71,32,97,90,64,48};
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);} unsigned int f_gold ( unsigned int n ) { unsigned count = 0; if ( n && ! ( n & ( n - 1 ) ) ) return n; [MASK] ( 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[] = {74,70,85,78,71,32,97,90,64,48};
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;
} | while | [
"a) (rowSum[i]",
"b) import",
"c) <",
"d) while",
"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);}
void f_gold ( int arr [ ], int n ) {
int max_idx = n - 1, min_idx = 0;
int max_elem = arr [ n - 1 ] + 1;
for ( int i = 0;
i < n;
i ++ ) {
if ( i % 2 == 0 ) {
arr [ i ] += ( arr [ max_idx ] % max_elem ) * max_elem;
max_idx --;
}
else {
arr [ i ] += ( arr [ min_idx ] % max_elem ) * max_elem;
min_idx ++;
}
}
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = arr [ i ] / max_elem;
}
void f_filled ( int arr [ ], int n ) {}
rr [ i ] += ( arr [ min_idx ] % max_elem ) * max_elem;
min_idx ++;
}
}
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = arr [ i ] / max_elem;
}
void f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,2,3,9,10,14,22,26,28,29,29,30,32,32,32,34,37,39,40,42,42,42,43,45,47,49,52,53,54,56,58,59,68,71,73,76,81,81,83,84,91,94};
int param0_1[] = {50,46,6,-57,67,34,-52,26,-93,97,-84,29,15,-63,65,25,-19,92,-38,-28,89,25,61,-34,-70,-80,88,-18,7,52,32,-63,32,-23,-11,46,-12,94,76,-67,-42};
int param0_2[] = {0,0,0,0,0,0,1,1,1};
int param0_3[] = {15,99,57,69,22,64,41,87,71,56,23,25,91,6,34,63,9,60,49,97,51,60,70,37,31,98,41,62,93,58,14,36,36,79,8,26,36,48,85,28,68,62,80,86,76,80,51};
int param0_4[] = {-99,-99,-90,-90,-85,-85,-79,-77,-72,-71,-67,-66,-61,-39,-39,-35,-35,-23,-20,-18,-16,-13,-2,1,5,6,10,24,27,32,33,38,48,67,70,76,82,88};
int param0_5[] = {0,0,0,1,0,1,0,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,1,1,0,0,0,1,0};
int param0_6[] = {2,22,32,34,43,66,70,74,94,94};
int param0_7[] = {-99,-28,76,-50,41,-85,-47,72,-92,-26,-54,-31,14,47,66,23};
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};
int param0_9[] = {19,31,26,42,41,23,47,13,89,66,66,16,73,28,77,35,41,77,31,85,32,54,98,72,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[] = {29,38,4,30,34,33,6,10,42,20};
int filled_function_param0_0[] = {1,1,2,3,9,10,14,22,26,28,29,29,30,32,32,32,34,37,39,40,42,42,42,43,45,47,49,52,53,54,56,58,59,68,71,73,76,81,81,83,84,91,94};
int filled_function_param0_1[] = {50,46,6,-57,67,34,-52,26,-93,97,-84,29,15,-63,65,25,-19,92,-38,-28,89,25,61,-34,-70,-80,88,-18,7,52,32,-63,32,-23,-11,46,-12,94,76,-67,-42};
int filled_function_param0_2[] = {0,0,0,0,0,0,1,1,1};
int filled_function_param0_3[] = {15,99,57,69,22,64,41,87,71,56,23,25,91,6,34,63,9,60,49,97,51,60,70,37,31,98,41,62,93,58,14,36,36,79,8,26,36,48,85,28,68,62,80,86,76,80,51};
int filled_function_param0_4[] = {-99,-99,-90,-90,-85,-85,-79,-77,-72,-71,-67,-66,-61,-39,-39,-35,-35,-23,-20,-18,-16,-13,-2,1,5,6,10,24,27,32,33,38,48,67,70,76,82,88};
int filled_function_param0_5[] = {0,0,0,1,0,1,0,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,1,1,0,0,0,1,0};
int filled_function_param0_6[] = {2,22,32,34,43,66,70,74,94,94};
int filled_function_param0_7[] = {-99,-28,76,-50,41,-85,-47,72,-92,-26,-54,-31,14,47,66,23};
int filled_function_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};
int filled_function_param0_9[] = {19,31,26,42,41,23,47,13,89,66,66,16,73,28,77,35,41,77,31,85,32,54,98,72,59};
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[] = {29,38,4,30,34,33,6,10,42,20};
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: 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] int n) {qsort (arr, n, sizeof(int), cmpfunc);} void f_gold ( int arr [ ], int n ) { int max_idx = n - 1, min_idx = 0; int max_elem = arr [ n - 1 ] + 1; for ( int i = 0; i < n; i ++ ) { if ( i % 2 == 0 ) { arr [ i ] += ( arr [ max_idx ] % max_elem ) * max_elem; max_idx --; } else { arr [ i ] += ( arr [ min_idx ] % max_elem ) * max_elem; min_idx ++; } } for ( int i = 0; i < n; i ++ ) arr [ i ] = arr [ i ] / max_elem; } void f_filled ( int arr [ ], int n ) {}rr [ i ] += ( arr [ min_idx ] % max_elem ) * max_elem;
min_idx ++;
}
}
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = arr [ i ] / max_elem;
}
void f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,2,3,9,10,14,22,26,28,29,29,30,32,32,32,34,37,39,40,42,42,42,43,45,47,49,52,53,54,56,58,59,68,71,73,76,81,81,83,84,91,94};
int param0_1[] = {50,46,6,-57,67,34,-52,26,-93,97,-84,29,15,-63,65,25,-19,92,-38,-28,89,25,61,-34,-70,-80,88,-18,7,52,32,-63,32,-23,-11,46,-12,94,76,-67,-42};
int param0_2[] = {0,0,0,0,0,0,1,1,1};
int param0_3[] = {15,99,57,69,22,64,41,87,71,56,23,25,91,6,34,63,9,60,49,97,51,60,70,37,31,98,41,62,93,58,14,36,36,79,8,26,36,48,85,28,68,62,80,86,76,80,51};
int param0_4[] = {-99,-99,-90,-90,-85,-85,-79,-77,-72,-71,-67,-66,-61,-39,-39,-35,-35,-23,-20,-18,-16,-13,-2,1,5,6,10,24,27,32,33,38,48,67,70,76,82,88};
int param0_5[] = {0,0,0,1,0,1,0,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,1,1,0,0,0,1,0};
int param0_6[] = {2,22,32,34,43,66,70,74,94,94};
int param0_7[] = {-99,-28,76,-50,41,-85,-47,72,-92,-26,-54,-31,14,47,66,23};
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};
int param0_9[] = {19,31,26,42,41,23,47,13,89,66,66,16,73,28,77,35,41,77,31,85,32,54,98,72,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[] = {29,38,4,30,34,33,6,10,42,20};
int filled_function_param0_0[] = {1,1,2,3,9,10,14,22,26,28,29,29,30,32,32,32,34,37,39,40,42,42,42,43,45,47,49,52,53,54,56,58,59,68,71,73,76,81,81,83,84,91,94};
int filled_function_param0_1[] = {50,46,6,-57,67,34,-52,26,-93,97,-84,29,15,-63,65,25,-19,92,-38,-28,89,25,61,-34,-70,-80,88,-18,7,52,32,-63,32,-23,-11,46,-12,94,76,-67,-42};
int filled_function_param0_2[] = {0,0,0,0,0,0,1,1,1};
int filled_function_param0_3[] = {15,99,57,69,22,64,41,87,71,56,23,25,91,6,34,63,9,60,49,97,51,60,70,37,31,98,41,62,93,58,14,36,36,79,8,26,36,48,85,28,68,62,80,86,76,80,51};
int filled_function_param0_4[] = {-99,-99,-90,-90,-85,-85,-79,-77,-72,-71,-67,-66,-61,-39,-39,-35,-35,-23,-20,-18,-16,-13,-2,1,5,6,10,24,27,32,33,38,48,67,70,76,82,88};
int filled_function_param0_5[] = {0,0,0,1,0,1,0,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,1,1,0,0,0,1,0};
int filled_function_param0_6[] = {2,22,32,34,43,66,70,74,94,94};
int filled_function_param0_7[] = {-99,-28,76,-50,41,-85,-47,72,-92,-26,-54,-31,14,47,66,23};
int filled_function_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};
int filled_function_param0_9[] = {19,31,26,42,41,23,47,13,89,66,66,16,73,28,77,35,41,77,31,85,32,54,98,72,59};
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[] = {29,38,4,30,34,33,6,10,42,20};
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;
} | ], | [
"a) f_gold",
"b) [",
"c) ],",
"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 ( char num [] ) {
int n = strlen(num);
if ( n == 0 && num [ 0 ] == '0' ) return true;
if ( n % 3 == 1 ) num = "00" + num;
if ( n % 3 == 2 ) num = "0" + num;
int gSum = 0;
for ( int i = 0;
i < n;
i ++ ) {
int group = 0;
group += ( num [ i ++ ] - '0' ) * 100;
group += ( num [ i ++ ] - '0' ) * 10;
group += num [ i ] - '0';
gSum += group;
}
if ( gSum > 1000 ) {
num = to_string ( gSum );
n = strlen(num);
gSum = f_gold ( num );
}
return ( gSum == 999 );
}
bool f_filled ( char num [] ) {}
- '0';
gSum += group;
}
if ( gSum > 1000 ) {
num = to_string ( gSum );
n = strlen(num);
gSum = f_gold ( num );
}
return ( gSum == 999 );
}
bool f_filled ( char num [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"235764","321308924","101111","1998","339589","0000101","264735","19570453184","000","SsHh"};
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);} bool f_gold ( char num [] ) { int n = strlen(num); if ( n == 0 && num [ 0 ] == '0' ) return true; if ( n % 3 == 1 ) num = "00" + num; if ( n % 3 == 2 ) num = "0" + num; int gSum = 0; for ( int i = 0; i < n; i ++ ) { int group = 0; group += ( num [ i ++ ] - '0' ) * 100; group += ( num [ i ++ ] - '0' ) * 10; group += num [ i ] - '0'; gSum += group; } if ( gSum > 1000 ) { num = to_string ( gSum ); n = strlen(num); gSum = f_gold ( num ); } return ( gSum == 999 ); } bool f_filled ( char num [] ) {}- '0';
gSum += group;
}
if ( gSum > 1000 ) {
num = to_string ( gSum );
n = strlen(num);
gSum = f_gold ( num );
}
return ( gSum == 999 );
}
bool f_filled ( char num [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"235764","321308924","101111","1998","339589","0000101","264735","19570453184","000","SsHh"};
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) sum",
"b) <bits/stdc++.h>",
"c) min(int",
"d) +=",
"e) 2"
] | 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 l, int h, int key ) {
if ( l > h ) return - 1;
int mid = ( l + h ) / 2;
if ( arr [ mid ] == key ) return mid;
if ( arr [ l ] <= arr [ mid ] ) {
if ( key >= arr [ l ] && key <= arr [ mid ] ) return f_gold ( arr, l, mid - 1, key );
return f_gold ( arr, mid + 1, h, key );
}
if ( key >= arr [ mid ] && key <= arr [ h ] ) return f_gold ( arr, mid + 1, h, key );
return f_gold ( arr, l, mid - 1, key );
}
int f_filled ( int arr [ ], int l, int h, int key ) {}
y );
}
if ( key >= arr [ mid ] && key <= arr [ h ] ) return f_gold ( arr, mid + 1, h, key );
return f_gold ( arr, l, mid - 1, key );
}
int f_filled ( int arr [ ], int l, int h, int key ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {20};
int param0_1[] = {40,50,55,67,70,4,5,6,7};
int param0_2[] = {14,41,38,67,99,11,96,52,4,29,22,57,3,45,14,76,70,38,93,5,74,50,18,17,20,34,51,69,86,73};
int param0_3[] = {-90,-88,-88,-82,-62,-44,-38,-38,-36,-34,-34,-32,-30,-28,-28,-26,-24,-20,-16,-16,-16,-6,-6,2,6,8,10,14,18,18,46,50,50,54,56,58,58,60,62,70,70,74,82,84,88,94,96};
int param0_4[] = {1,1,1,1,0,0,1,1,1,1,1,1,1,0};
int param0_5[] = {4,7,9,10,10,11,14,16,17,21,25,27,31,34,34,34,38,41,42,42,52,56,56,58,60,66,67,68,68,70,72,74,76,82,88,88,88,89,91,93,94,95,95};
int param0_6[] = {92,60,-60,64,18,70,56,34,58,14,28,-72,-22,-74,-46,-28,64,88,18,-50,-14,-20,64,6,-4,-98,60,98,84,-58,-98,66,80,68,-42,-58,82,90,-72,34,34,80,88,-64,66,-20,-26};
int param0_7[] = {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};
int param0_8[] = {33,18,98,47,76,58,29,68,62,78,12,95,20,88,39,12,43,45,5,45,96,64,38,28,70,25,65,79,39};
int *param0[9] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8};
int param1[] = {0,0,0,0,0,0,0,0,0,0};
int param2[] = {8,4,9,16,24,10,23,25,40,16};
int param3[] = {3,40,67,15,24,10,39,25,29,28};
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 l, int h, int key ) { if ( l > h ) return - 1; int mid = ( l + h ) / 2; if ( arr [ mid ] == key ) return mid; if ( arr [ l ] <= arr [ mid ] ) { if ( key >= arr [ l ] && key <= arr [ mid ] ) return f_gold ( arr, l, mid - 1, key ); return f_gold ( arr, mid + 1, h, key ); } if ( key >= arr [ mid ] && key <= arr [ h ] ) return f_gold ( arr, mid + 1, h, key ); return f_gold ( arr, l, mid - 1, key ); } int f_filled ( int arr [ ], int l, int h, int key ) {}y );
}
if ( key >= arr [ mid ] && key <= arr [ h ] ) return f_gold ( arr, mid + 1, h, key );
return f_gold ( arr, l, mid - 1, key );
}
int f_filled ( int arr [ ], int l, int h, int key ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {20};
int param0_1[] = {40,50,55,67,70,4,5,6,7};
int param0_2[] = {14,41,38,67,99,11,96,52,4,29,22,57,3,45,14,76,70,38,93,5,74,50,18,17,20,34,51,69,86,73};
int param0_3[] = {-90,-88,-88,-82,-62,-44,-38,-38,-36,-34,-34,-32,-30,-28,-28,-26,-24,-20,-16,-16,-16,-6,-6,2,6,8,10,14,18,18,46,50,50,54,56,58,58,60,62,70,70,74,82,84,88,94,96};
int param0_4[] = {1,1,1,1,0,0,1,1,1,1,1,1,1,0};
int param0_5[] = {4,7,9,10,10,11,14,16,17,21,25,27,31,34,34,34,38,41,42,42,52,56,56,58,60,66,67,68,68,70,72,74,76,82,88,88,88,89,91,93,94,95,95};
int param0_6[] = {92,60,-60,64,18,70,56,34,58,14,28,-72,-22,-74,-46,-28,64,88,18,-50,-14,-20,64,6,-4,-98,60,98,84,-58,-98,66,80,68,-42,-58,82,90,-72,34,34,80,88,-64,66,-20,-26};
int param0_7[] = {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};
int param0_8[] = {33,18,98,47,76,58,29,68,62,78,12,95,20,88,39,12,43,45,5,45,96,64,38,28,70,25,65,79,39};
int *param0[9] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8};
int param1[] = {0,0,0,0,0,0,0,0,0,0};
int param2[] = {8,4,9,16,24,10,23,25,40,16};
int param3[] = {3,40,67,15,24,10,39,25,29,28};
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) n",
"c) ]",
"d) ]",
"e) #include"
] | 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 DP [ n + 1 ];
DP [ 0 ] = DP [ 1 ] = DP [ 2 ] = 1;
DP [ 3 ] = 2;
for ( int i = 4;
i <= n;
i ++ ) DP [ i ] = DP [ i - 1 ] + DP [ i - 3 ] + DP [ i - 4 ];
return DP [ n ];
}
int f_filled ( int n ) {}
;
DP [ 0 ] = DP [ 1 ] = DP [ 2 ] = 1;
DP [ 3 ] = 2;
for ( int i = 4;
i <= n;
i ++ ) DP [ i ] = DP [ i - 1 ] + DP [ i - 3 ] + DP [ i - 4 ];
return DP [ n ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {44,9,19,10,78,94,70,81,81,49};
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 ) { [MASK] DP [ n + 1 ]; DP [ 0 ] = DP [ 1 ] = DP [ 2 ] = 1; DP [ 3 ] = 2; for ( int i = 4; i <= n; i ++ ) DP [ i ] = DP [ i - 1 ] + DP [ i - 3 ] + DP [ i - 4 ]; return DP [ n ]; } int f_filled ( int n ) {};
DP [ 0 ] = DP [ 1 ] = DP [ 2 ] = 1;
DP [ 3 ] = 2;
for ( int i = 4;
i <= n;
i ++ ) DP [ i ] = DP [ i - 1 ] + DP [ i - 3 ] + DP [ i - 4 ];
return DP [ n ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {44,9,19,10,78,94,70,81,81,49};
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) javafx.util.Pair;",
"b) if",
"c) (",
"d) int",
"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 table [ n + 1 ];
memset ( table, 0, sizeof ( table ) );
table [ 0 ] = 1;
for ( int i = 1;
i < n;
i ++ ) for ( int j = i;
j <= n;
j ++ ) table [ j ] += table [ j - i ];
return table [ n ];
}
int f_filled ( int n ) {}
, sizeof ( table ) );
table [ 0 ] = 1;
for ( int i = 1;
i < n;
i ++ ) for ( int j = i;
j <= n;
j ++ ) table [ j ] += table [ j - i ];
return table [ n ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {66,90,8,77,44,20,34,22,50,10};
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 ) { int table [ n + 1 ]; memset ( table, 0, sizeof ( table ) ); table [ 0 ] = 1; for ( int i = 1; i < n; i ++ ) for ( int j = i; j <= n; j ++ ) table [ j ] += table [ j - i ]; return table [ n ]; } int f_filled ( int n ) {}, sizeof ( table ) );
table [ 0 ] = 1;
for ( int i = 1;
i < n;
i ++ ) for ( int j = i;
j <= n;
j ++ ) table [ j ] += table [ j - i ];
return table [ n ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {66,90,8,77,44,20,34,22,50,10};
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) x:",
"b) 2",
"c) ,",
"d) <stdio.h>",
"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 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[] = {24,46,47,41,98,69,83,2,12,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 * 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] 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[] = {24,46,47,41,98,69,83,2,12,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;
} | int | [
"a) =",
"b) 0",
"c) i",
"d) s",
"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);}
unsigned int f_gold ( unsigned int n ) {
unsigned int p = 1;
if ( n && ! ( n & ( n - 1 ) ) ) return n;
while ( p < n ) p <<= 1;
return p;
}
unsigned int f_filled ( unsigned int n ) {}
;}
unsigned int f_gold ( unsigned int n ) {
unsigned int p = 1;
if ( n && ! ( n & ( n - 1 ) ) ) return n;
while ( p < n ) p <<= 1;
return p;
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {31,89,92,66,38,34,17,24,54,20};
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 [MASK] arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} unsigned int f_gold ( unsigned int n ) { unsigned int p = 1; if ( n && ! ( n & ( n - 1 ) ) ) return n; while ( p < n ) p <<= 1; return p; } unsigned int f_filled ( unsigned int n ) {};}
unsigned int f_gold ( unsigned int n ) {
unsigned int p = 1;
if ( n && ! ( n & ( n - 1 ) ) ) return n;
while ( p < n ) p <<= 1;
return p;
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {31,89,92,66,38,34,17,24,54,20};
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) /=",
"b) 1",
"c) int",
"d) (int",
"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 k ) {
if ( k <= 0 ) return n;
return ( n & ~ ( 1 << ( k - 1 ) ) );
}
int f_filled ( int n, int k ) {}
ort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n, int k ) {
if ( k <= 0 ) return n;
return ( n & ~ ( 1 << ( k - 1 ) ) );
}
int f_filled ( int n, int k ) {}
int main(void) {
int n_success = 0;
int param0[] = {49,59,76,27,61,67,63,85,90,24};
int param1[] = {15,69,20,76,60,27,71,25,64,55};
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)? [MASK] 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 ( k <= 0 ) return n; return ( n & ~ ( 1 << ( k - 1 ) ) ); } int f_filled ( int n, int k ) {}ort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n, int k ) {
if ( k <= 0 ) return n;
return ( n & ~ ( 1 << ( k - 1 ) ) );
}
int f_filled ( int n, int k ) {}
int main(void) {
int n_success = 0;
int param0[] = {49,59,76,27,61,67,63,85,90,24};
int param1[] = {15,69,20,76,60,27,71,25,64,55};
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) arr",
"b) <string>",
"c) (",
"d) int",
"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 arr [ ], int n, int k ) {
int dist_count = 0;
for ( int i = 0;
i < n;
i ++ ) {
int j;
for ( j = 0;
j < n;
j ++ ) if ( i != j && arr [ j ] == arr [ i ] ) break;
if ( j == n ) dist_count ++;
if ( dist_count == k ) return arr [ i ];
}
return - 1;
}
int f_filled ( int arr [ ], int n, int k ) {}
++ ) if ( i != j && arr [ j ] == arr [ i ] ) break;
if ( j == n ) dist_count ++;
if ( dist_count == k ) return arr [ i ];
}
return - 1;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,3,8,18,20,33,53,56,60,71,76,80,81,87,88,89,92,95};
int param0_1[] = {-78,6,32,52,-12,-32,22,-40,-82,24,30,10,-40};
int param0_2[] = {0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {3,28,55,21,42,60,96,83,98,75,29,73,51,21,27,65,19,47,12,81,19,94,50,43,21,32,52,44,52,91,49,59,52,10,75,86,46,43,3,49,70,60,77,99,27,63};
int param0_4[] = {-96,-90,-76,-44,-16,-8,0,0,2,2,8,14,16,18,18,20,20,28,34,44,68,74,84,90};
int param0_5[] = {0,1,1,0,0,0,0,0,1,0,0,1,0};
int param0_6[] = {3,4,5,8,9,15,26,26,26,35,39,40,42,43,45,45,48,52,54,56,57,67,74,77,79,80,81,86,87,92,95,97};
int param0_7[] = {-76,-24,-12,66,-40,26,72,46,-56,58,-68,2,-82};
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,1,1,1,1};
int param0_9[] = {29,83,32,75,5,22,68,64,36,18,7,63,16,42,77,61,1,26,12,41,67,85,85,35,94,18,14,65,8,55,44,34,48,23,8,27,86,2,51,91};
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[] = {16,8,7,40,23,10,26,6,27,28};
int param2[] = {16,6,5,39,12,8,24,10,17,24};
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 dist_count = 0; for ( int i = 0; i < n; i ++ ) { int j; for ( j [MASK] 0; j < n; j ++ ) if ( i != j && arr [ j ] == arr [ i ] ) break; if ( j == n ) dist_count ++; if ( dist_count == k ) return arr [ i ]; } return - 1; } int f_filled ( int arr [ ], int n, int k ) {}++ ) if ( i != j && arr [ j ] == arr [ i ] ) break;
if ( j == n ) dist_count ++;
if ( dist_count == k ) return arr [ i ];
}
return - 1;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,3,8,18,20,33,53,56,60,71,76,80,81,87,88,89,92,95};
int param0_1[] = {-78,6,32,52,-12,-32,22,-40,-82,24,30,10,-40};
int param0_2[] = {0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {3,28,55,21,42,60,96,83,98,75,29,73,51,21,27,65,19,47,12,81,19,94,50,43,21,32,52,44,52,91,49,59,52,10,75,86,46,43,3,49,70,60,77,99,27,63};
int param0_4[] = {-96,-90,-76,-44,-16,-8,0,0,2,2,8,14,16,18,18,20,20,28,34,44,68,74,84,90};
int param0_5[] = {0,1,1,0,0,0,0,0,1,0,0,1,0};
int param0_6[] = {3,4,5,8,9,15,26,26,26,35,39,40,42,43,45,45,48,52,54,56,57,67,74,77,79,80,81,86,87,92,95,97};
int param0_7[] = {-76,-24,-12,66,-40,26,72,46,-56,58,-68,2,-82};
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,1,1,1,1};
int param0_9[] = {29,83,32,75,5,22,68,64,36,18,7,63,16,42,77,61,1,26,12,41,67,85,85,35,94,18,14,65,8,55,44,34,48,23,8,27,86,2,51,91};
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[] = {16,8,7,40,23,10,26,6,27,28};
int param2[] = {16,6,5,39,12,8,24,10,17,24};
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) i",
"c) small",
"d) x:",
"e) for"
] | 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 p ) {
if ( n >= p ) return 0;
int result = 1;
for ( int i = 1;
i <= n;
i ++ ) result = ( result * i ) % p;
return result;
}
int f_filled ( int n, int p ) {}
}
int f_gold ( int n, int p ) {
if ( n >= p ) return 0;
int result = 1;
for ( int i = 1;
i <= n;
i ++ ) result = ( result * i ) % p;
return result;
}
int f_filled ( int n, int p ) {}
int main(void) {
int n_success = 0;
int param0[] = {85,14,83,30,96,55,82,12,38,46};
int param1[] = {18,13,21,35,51,58,71,74,3,73};
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 n, int p ) { if ( n >= p ) return 0; int result = 1; for ( int i = 1; i <= n; i [MASK] ) result = ( result * i ) % p; return result; } int f_filled ( int n, int p ) {}}
int f_gold ( int n, int p ) {
if ( n >= p ) return 0;
int result = 1;
for ( int i = 1;
i <= n;
i ++ ) result = ( result * i ) % p;
return result;
}
int f_filled ( int n, int p ) {}
int main(void) {
int n_success = 0;
int param0[] = {85,14,83,30,96,55,82,12,38,46};
int param1[] = {18,13,21,35,51,58,71,74,3,73};
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) return",
"c) &",
"d) -",
"e) arr"
] | 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 ( double p ) {
return ceil ( sqrt ( 2 * 365 * log ( 1 / ( 1 - p ) ) ) );
}
int f_filled ( double p ) {}
0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( double p ) {
return ceil ( sqrt ( 2 * 365 * log ( 1 / ( 1 - p ) ) ) );
}
int f_filled ( double p ) {}
int main(void) {
int n_success = 0;
double param0[] = {0.9303713975220877,0.48126843587453595,0.48776789524757905,0.35184405927337793,0.8000415444743662,0.3528645948885943,0.33594265260473667,0.3603861267753616,7218.247044923335,-4701.904717953173};
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> #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 ( double p ) { return ceil ( sqrt ( 2 * 365 * log ( 1 / ( 1 - p ) ) ) ); } int f_filled ( double p ) {}0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( double p ) {
return ceil ( sqrt ( 2 * 365 * log ( 1 / ( 1 - p ) ) ) );
}
int f_filled ( double p ) {}
int main(void) {
int n_success = 0;
double param0[] = {0.9303713975220877,0.48126843587453595,0.48776789524757905,0.35184405927337793,0.8000415444743662,0.3528645948885943,0.33594265260473667,0.3603861267753616,7218.247044923335,-4701.904717953173};
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;
} | int | [
"a) l",
"b) n)",
"c) 1;",
"d) max",
"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 a [ ], int n ) {
int result = 1;
for ( int i = 1;
i <= n;
++ i ) {
long long y = ( i * ( i + 1 ) ) / 2;
if ( y < n ) result = i;
else break;
}
return result;
}
int f_filled ( int a [ ], int n ) {}
sult = 1;
for ( int i = 1;
i <= n;
++ i ) {
long long y = ( i * ( i + 1 ) ) / 2;
if ( y < n ) result = i;
else break;
}
return result;
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {8,10,11,14,14,17,20,20,22,22,22,23,25,30,33,39,39,41,43,45,46,46,46,50,51,53,57,59,60,64,64,66,72,72,75,77,85,85,87,88,90,91,93,94,94,95};
int param0_1[] = {-44,-90,20,4,-56,-50,-80,74,-82,20,62,-26,-10,-14,-76,82,-88,92,30,44,-62,-86,-20,-96,-60,-88,-78,-40,-48,-92,62,58,94,68,68,44,80,4,48,-92,30,-76,-46,-20,4};
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};
int param0_3[] = {8,34,48,10,5,12,80,7,67,1,79,59,63,13,16,23,62,56,99,89,7,80};
int param0_4[] = {-88,-46,-40,-40,38};
int param0_5[] = {1,0,0,1,0,1,1,0,1,0,0,0,0,1,1,0,0,1,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,1,1,1};
int param0_6[] = {8,15,35,39,49,81,86,91};
int param0_7[] = {-24,56,-74,-76,-80,86,90,0,-26,18,72,78,-66,-28,22,22,72,78,-50,-12,20,12,-68,-2,-58,-44,28,-58,90,-28,32,-70,-48,-66,-94,-50,18,-12,80,12,82,56,-64,10,-22};
int param0_8[] = {0,0};
int param0_9[] = {62,93,69,40,26,2,29,83,66,68,67,73,12,65,89,57,38,99,42,27,38,24,43,4,4,54,72,47,52,46,53,24,3,41,64,33,88,3,1,7,17,31,20,33,69,21,9,24,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[] = {38,36,28,12,3,44,7,36,1,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> [MASK] <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 result = 1; for ( int i = 1; i <= n; ++ i ) { long long y = ( i * ( i + 1 ) ) / 2; if ( y < n ) result = i; else break; } return result; } int f_filled ( int a [ ], int n ) {}sult = 1;
for ( int i = 1;
i <= n;
++ i ) {
long long y = ( i * ( i + 1 ) ) / 2;
if ( y < n ) result = i;
else break;
}
return result;
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {8,10,11,14,14,17,20,20,22,22,22,23,25,30,33,39,39,41,43,45,46,46,46,50,51,53,57,59,60,64,64,66,72,72,75,77,85,85,87,88,90,91,93,94,94,95};
int param0_1[] = {-44,-90,20,4,-56,-50,-80,74,-82,20,62,-26,-10,-14,-76,82,-88,92,30,44,-62,-86,-20,-96,-60,-88,-78,-40,-48,-92,62,58,94,68,68,44,80,4,48,-92,30,-76,-46,-20,4};
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};
int param0_3[] = {8,34,48,10,5,12,80,7,67,1,79,59,63,13,16,23,62,56,99,89,7,80};
int param0_4[] = {-88,-46,-40,-40,38};
int param0_5[] = {1,0,0,1,0,1,1,0,1,0,0,0,0,1,1,0,0,1,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,1,1,1};
int param0_6[] = {8,15,35,39,49,81,86,91};
int param0_7[] = {-24,56,-74,-76,-80,86,90,0,-26,18,72,78,-66,-28,22,22,72,78,-50,-12,20,12,-68,-2,-58,-44,28,-58,90,-28,32,-70,-48,-66,-94,-50,18,-12,80,12,82,56,-64,10,-22};
int param0_8[] = {0,0};
int param0_9[] = {62,93,69,40,26,2,29,83,66,68,67,73,12,65,89,57,38,99,42,27,38,24,43,4,4,54,72,47,52,46,53,24,3,41,64,33,88,3,1,7,17,31,20,33,69,21,9,24,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[] = {38,36,28,12,3,44,7,36,1,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 | [
"a) #include",
"b) ans;",
"c) (arr)",
"d) for",
"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 A [ ], int n ) {
sort ( A, A + n );
}
void f_filled ( int A [ ], int n ) {}
(arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
void f_gold ( int A [ ], int n ) {
sort ( A, A + n );
}
void f_filled ( int A [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,3,11,13,18,24,26,30,31,34,42,43,43,44,44,47,49,52,53,55,56,57,58,58,60,64,66,67,69,70,70,71,74,76,77,82,85,89,90,96,98};
int param0_1[] = {-78,81,87,14,25,24,-70,-92,-2,-43,11,-27,15,-80,-75,-81,-95,-25,28,-28,55,-60,-74,-73,90,-17,28,78,70,57,67,88,69,-67,-3,11,-84,-77,35,-74,-4,-88,-28,33};
int param0_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};
int param0_3[] = {6,46,50,38,88,18,27,41,72,92,74,17,62,29,58,70,78,22,6,26,39,12,99,14,22,51,23,48,71,50,89,13,85,10,55,9,79,52,2,25,13,98,51,58,34,35,3,59,70};
int param0_4[] = {-98,-88,-76,-71,-71,-63,-59,-58,-57,-42,-40,-37,-36,-34,-33,-33,-27,-26,-23,-9,-8,-6,-5,-1,0,3,16,21,29,30,33,39,39,43,47,50,52,60,63,66,73,74,76,77,92,92,96,97};
int param0_5[] = {1,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,0,0,0,1,0,1,0,1,1,1,1,0,0,0,0,1,1,1,0,1,0};
int param0_6[] = {46,86};
int param0_7[] = {58,-31,37,-15,-89,-31,-1,-9,94,59,61,67,-6,74,65,15,88,-69,-89,-13,21,30,5};
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};
int param0_9[] = {94,5,98,22,77,57,47,54,3,53,84,31};
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[] = {33,31,15,46,42,31,1,21,19,10};
int filled_function_param0_0[] = {2,3,11,13,18,24,26,30,31,34,42,43,43,44,44,47,49,52,53,55,56,57,58,58,60,64,66,67,69,70,70,71,74,76,77,82,85,89,90,96,98};
int filled_function_param0_1[] = {-78,81,87,14,25,24,-70,-92,-2,-43,11,-27,15,-80,-75,-81,-95,-25,28,-28,55,-60,-74,-73,90,-17,28,78,70,57,67,88,69,-67,-3,11,-84,-77,35,-74,-4,-88,-28,33};
int filled_function_param0_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};
int filled_function_param0_3[] = {6,46,50,38,88,18,27,41,72,92,74,17,62,29,58,70,78,22,6,26,39,12,99,14,22,51,23,48,71,50,89,13,85,10,55,9,79,52,2,25,13,98,51,58,34,35,3,59,70};
int filled_function_param0_4[] = {-98,-88,-76,-71,-71,-63,-59,-58,-57,-42,-40,-37,-36,-34,-33,-33,-27,-26,-23,-9,-8,-6,-5,-1,0,3,16,21,29,30,33,39,39,43,47,50,52,60,63,66,73,74,76,77,92,92,96,97};
int filled_function_param0_5[] = {1,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,0,0,0,1,0,1,0,1,1,1,1,0,0,0,0,1,1,1,0,1,0};
int filled_function_param0_6[] = {46,86};
int filled_function_param0_7[] = {58,-31,37,-15,-89,-31,-1,-9,94,59,61,67,-6,74,65,15,88,-69,-89,-13,21,30,5};
int filled_function_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};
int filled_function_param0_9[] = {94,5,98,22,77,57,47,54,3,53,84,31};
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[] = {33,31,15,46,42,31,1,21,19,10};
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 [MASK] { 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 A [ ], int n ) { sort ( A, A + n ); } void f_filled ( int A [ ], int n ) {}(arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
void f_gold ( int A [ ], int n ) {
sort ( A, A + n );
}
void f_filled ( int A [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,3,11,13,18,24,26,30,31,34,42,43,43,44,44,47,49,52,53,55,56,57,58,58,60,64,66,67,69,70,70,71,74,76,77,82,85,89,90,96,98};
int param0_1[] = {-78,81,87,14,25,24,-70,-92,-2,-43,11,-27,15,-80,-75,-81,-95,-25,28,-28,55,-60,-74,-73,90,-17,28,78,70,57,67,88,69,-67,-3,11,-84,-77,35,-74,-4,-88,-28,33};
int param0_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};
int param0_3[] = {6,46,50,38,88,18,27,41,72,92,74,17,62,29,58,70,78,22,6,26,39,12,99,14,22,51,23,48,71,50,89,13,85,10,55,9,79,52,2,25,13,98,51,58,34,35,3,59,70};
int param0_4[] = {-98,-88,-76,-71,-71,-63,-59,-58,-57,-42,-40,-37,-36,-34,-33,-33,-27,-26,-23,-9,-8,-6,-5,-1,0,3,16,21,29,30,33,39,39,43,47,50,52,60,63,66,73,74,76,77,92,92,96,97};
int param0_5[] = {1,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,0,0,0,1,0,1,0,1,1,1,1,0,0,0,0,1,1,1,0,1,0};
int param0_6[] = {46,86};
int param0_7[] = {58,-31,37,-15,-89,-31,-1,-9,94,59,61,67,-6,74,65,15,88,-69,-89,-13,21,30,5};
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};
int param0_9[] = {94,5,98,22,77,57,47,54,3,53,84,31};
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[] = {33,31,15,46,42,31,1,21,19,10};
int filled_function_param0_0[] = {2,3,11,13,18,24,26,30,31,34,42,43,43,44,44,47,49,52,53,55,56,57,58,58,60,64,66,67,69,70,70,71,74,76,77,82,85,89,90,96,98};
int filled_function_param0_1[] = {-78,81,87,14,25,24,-70,-92,-2,-43,11,-27,15,-80,-75,-81,-95,-25,28,-28,55,-60,-74,-73,90,-17,28,78,70,57,67,88,69,-67,-3,11,-84,-77,35,-74,-4,-88,-28,33};
int filled_function_param0_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};
int filled_function_param0_3[] = {6,46,50,38,88,18,27,41,72,92,74,17,62,29,58,70,78,22,6,26,39,12,99,14,22,51,23,48,71,50,89,13,85,10,55,9,79,52,2,25,13,98,51,58,34,35,3,59,70};
int filled_function_param0_4[] = {-98,-88,-76,-71,-71,-63,-59,-58,-57,-42,-40,-37,-36,-34,-33,-33,-27,-26,-23,-9,-8,-6,-5,-1,0,3,16,21,29,30,33,39,39,43,47,50,52,60,63,66,73,74,76,77,92,92,96,97};
int filled_function_param0_5[] = {1,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,0,0,0,1,0,1,0,1,1,1,1,0,0,0,0,1,1,1,0,1,0};
int filled_function_param0_6[] = {46,86};
int filled_function_param0_7[] = {58,-31,37,-15,-89,-31,-1,-9,94,59,61,67,-6,74,65,15,88,-69,-89,-13,21,30,5};
int filled_function_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};
int filled_function_param0_9[] = {94,5,98,22,77,57,47,54,3,53,84,31};
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[] = {33,31,15,46,42,31,1,21,19,10};
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) fibo",
"b) 9;",
"c) y)",
"d) int",
"e) int"
] | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.