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 n, int p ) {
int ans = 0;
int temp = p;
while ( temp <= n ) {
ans += n / temp;
temp = temp * p;
}
return ans;
}
int f_filled ( int n, int p ) {}
t), cmpfunc);}
int f_gold ( int n, int p ) {
int ans = 0;
int temp = p;
while ( temp <= n ) {
ans += n / temp;
temp = temp * p;
}
return ans;
}
int f_filled ( int n, int p ) {}
int main(void) {
int n_success = 0;
int param0[] = {76,77,9,59,8,97,78,41,72,71};
int param1[] = {43,91,42,67,52,8,24,88,61,28};
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) [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 n, int p ) { int ans = 0; int temp = p; while ( temp <= n ) { ans += n / temp; temp = temp * p; } return ans; } int f_filled ( int n, int p ) {}t), cmpfunc);}
int f_gold ( int n, int p ) {
int ans = 0;
int temp = p;
while ( temp <= n ) {
ans += n / temp;
temp = temp * p;
}
return ans;
}
int f_filled ( int n, int p ) {}
int main(void) {
int n_success = 0;
int param0[] = {76,77,9,59,8,97,78,41,72,71};
int param1[] = {43,91,42,67,52,8,24,88,61,28};
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) int",
"b) min_len",
"c) )",
"d) {",
"e) side"
] | 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 x, int y ) {
int res = 1;
for ( int i = 0;
i < y;
i ++ ) res = ( res * x ) % 10;
return res;
}
int f_filled ( int x, int y ) {}
{qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int x, int y ) {
int res = 1;
for ( int i = 0;
i < y;
i ++ ) res = ( res * x ) % 10;
return res;
}
int f_filled ( int x, int y ) {}
int main(void) {
int n_success = 0;
int param0[] = {33,95,21,3,40,64,17,58,44,27};
int param1[] = {55,7,63,62,53,24,23,74,13,54};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x [MASK] y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int x, int y ) { int res = 1; for ( int i = 0; i < y; i ++ ) res = ( res * x ) % 10; return res; } int f_filled ( int x, int y ) {}{qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int x, int y ) {
int res = 1;
for ( int i = 0;
i < y;
i ++ ) res = ( res * x ) % 10;
return res;
}
int f_filled ( int x, int y ) {}
int main(void) {
int n_success = 0;
int param0[] = {33,95,21,3,40,64,17,58,44,27};
int param1[] = {55,7,63,62,53,24,23,74,13,54};
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) math.sqrt",
"c) ]",
"d) if",
"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 process, int need ) {
int minResources = 0;
minResources = process * ( need - 1 ) + 1;
return minResources;
}
int f_filled ( int process, int need ) {}
of(int), cmpfunc);}
int f_gold ( int process, int need ) {
int minResources = 0;
minResources = process * ( need - 1 ) + 1;
return minResources;
}
int f_filled ( int process, int need ) {}
int main(void) {
int n_success = 0;
int param0[] = {38,82,2,38,31,80,11,2,26,37};
int param1[] = {37,3,26,72,85,73,9,31,59,67};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) [MASK] return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 process, int need ) { int minResources = 0; minResources = process * ( need - 1 ) + 1; return minResources; } int f_filled ( int process, int need ) {}of(int), cmpfunc);}
int f_gold ( int process, int need ) {
int minResources = 0;
minResources = process * ( need - 1 ) + 1;
return minResources;
}
int f_filled ( int process, int need ) {}
int main(void) {
int n_success = 0;
int param0[] = {38,82,2,38,31,80,11,2,26,37};
int param1[] = {37,3,26,72,85,73,9,31,59,67};
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) public",
"b) (",
"c) sizeof",
"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 ) {
int result = - 1;
for ( int i = 0;
i < n;
i ++ ) for ( int j = 0;
j < n - 1;
j ++ ) for ( int k = j + 1;
k < n;
k ++ ) if ( arr [ j ] * arr [ k ] == arr [ i ] ) result = max ( result, arr [ i ] );
return result;
}
int f_filled ( int arr [ ], int n ) {}
j < n - 1;
j ++ ) for ( int k = j + 1;
k < n;
k ++ ) if ( arr [ j ] * arr [ k ] == arr [ i ] ) result = max ( result, arr [ i ] );
return result;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,78,84};
int param0_1[] = {-54,64,60,14,18,-68,-54,-58,38,-72,-84,46,74,76,28,-2,54,24,18,-74,-78,14,-38,-70,26,-54,-36,-96,-12,8,62,-42,-84,10,-6,36,-72,10,10,-20,16,92,-64,-34,74,-98,18};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {39,49,94,80,48,34,63,82,47,51,60,68,79,23,97,22,54,53,40,2,25};
int param0_4[] = {-90,-52,-10,12,72};
int param0_5[] = {1,0,0};
int param0_6[] = {2,9,11,14,16,17,17,18,19,21,24,25,28,29,30,33,33,39,41,41,43,46,50,51,60,62,67,80,84,86,91,92,97};
int param0_7[] = {4};
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};
int param0_9[] = {52,8,31,92,20,18,34,5,15,8,73,20,40,61,80,51,95,73,38,30,21,69,52,38,68,77};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {2,26,22,10,3,2,27,0,16,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) { [MASK] (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 result = - 1; for ( int i = 0; i < n; i ++ ) for ( int j = 0; j < n - 1; j ++ ) for ( int k = j + 1; k < n; k ++ ) if ( arr [ j ] * arr [ k ] == arr [ i ] ) result = max ( result, arr [ i ] ); return result; } int f_filled ( int arr [ ], int n ) {} j < n - 1;
j ++ ) for ( int k = j + 1;
k < n;
k ++ ) if ( arr [ j ] * arr [ k ] == arr [ i ] ) result = max ( result, arr [ i ] );
return result;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,78,84};
int param0_1[] = {-54,64,60,14,18,-68,-54,-58,38,-72,-84,46,74,76,28,-2,54,24,18,-74,-78,14,-38,-70,26,-54,-36,-96,-12,8,62,-42,-84,10,-6,36,-72,10,10,-20,16,92,-64,-34,74,-98,18};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {39,49,94,80,48,34,63,82,47,51,60,68,79,23,97,22,54,53,40,2,25};
int param0_4[] = {-90,-52,-10,12,72};
int param0_5[] = {1,0,0};
int param0_6[] = {2,9,11,14,16,17,17,18,19,21,24,25,28,29,30,33,33,39,41,41,43,46,50,51,60,62,67,80,84,86,91,92,97};
int param0_7[] = {4};
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};
int param0_9[] = {52,8,31,92,20,18,34,5,15,8,73,20,40,61,80,51,95,73,38,30,21,69,52,38,68,77};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {2,26,22,10,3,2,27,0,16,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;
} | return | [
"a) y;",
"b) [",
"c) return",
"d) result",
"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;
else return ( n & 1 ) + f_gold ( n >> 1 );
}
int f_filled ( int n ) {}
}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
if ( n == 0 ) return 0;
else return ( n & 1 ) + f_gold ( n >> 1 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {43,94,72,86,42,33,8,74,29,34};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const [MASK] * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { if ( n == 0 ) return 0; else return ( n & 1 ) + f_gold ( n >> 1 ); } int f_filled ( int n ) {}}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
if ( n == 0 ) return 0;
else return ( n & 1 ) + f_gold ( n >> 1 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {43,94,72,86,42,33,8,74,29,34};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | void | [
"a) int",
"b) void",
"c) 0;",
"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 x ) {
int dp [ x + 1 ];
dp [ 0 ] = dp [ 1 ] = 1;
for ( int i = 2;
i <= x;
i ++ ) dp [ i ] = dp [ i - 1 ] + ( i - 1 ) * dp [ i - 2 ];
return dp [ x ];
}
int f_filled ( int x ) {}
( int x ) {
int dp [ x + 1 ];
dp [ 0 ] = dp [ 1 ] = 1;
for ( int i = 2;
i <= x;
i ++ ) dp [ i ] = dp [ i - 1 ] + ( i - 1 ) * dp [ i - 2 ];
return dp [ x ];
}
int f_filled ( int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {22,92,15,81,3,30,88,4,43,92};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include [MASK] #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int x ) { int dp [ x + 1 ]; dp [ 0 ] = dp [ 1 ] = 1; for ( int i = 2; i <= x; i ++ ) dp [ i ] = dp [ i - 1 ] + ( i - 1 ) * dp [ i - 2 ]; return dp [ x ]; } int f_filled ( int x ) {}( int x ) {
int dp [ x + 1 ];
dp [ 0 ] = dp [ 1 ] = 1;
for ( int i = 2;
i <= x;
i ++ ) dp [ i ] = dp [ i - 1 ] + ( i - 1 ) * dp [ i - 2 ];
return dp [ x ];
}
int f_filled ( int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {22,92,15,81,3,30,88,4,43,92};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | <stdlib.h> | [
"a) )",
"b) <stdlib.h>",
"c) if",
"d) vector",
"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 ( int num, int divisor ) {
if ( divisor == 0 ) {
printf("Error: divisor can't be zero
");
return - 1;
}
if ( divisor < 0 ) divisor = - divisor;
if ( num < 0 ) num = - num;
int i = 1;
int product = 0;
while ( product <= num ) {
product = divisor * i;
i ++;
}
return num - ( product - divisor );
}
int f_filled ( int num, int divisor ) {}
num = - num;
int i = 1;
int product = 0;
while ( product <= num ) {
product = divisor * i;
i ++;
}
return num - ( product - divisor );
}
int f_filled ( int num, int divisor ) {}
int main(void) {
int n_success = 0;
int param0[] = {34,63,15,56,63,28,54,2,94,82};
int param1[] = {55,22,26,58,94,45,97,58,91,40};
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("Error: divisor can't be zero
");
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 num, int divisor ) { if ( divisor == 0 ) { printf("Error: divisor can't be zero "); return - 1; } if ( divisor < 0 ) divisor = - divisor; if ( num < 0 ) num = - num; int i = 1; int product = 0; while ( product <= num ) { product = divisor * i; i ++; } return num - [MASK] product - divisor ); } int f_filled ( int num, int divisor ) {}num = - num;
int i = 1;
int product = 0;
while ( product <= num ) {
product = divisor * i;
i ++;
}
return num - ( product - divisor );
}
int f_filled ( int num, int divisor ) {}
int main(void) {
int n_success = 0;
int param0[] = {34,63,15,56,63,28,54,2,94,82};
int param1[] = {55,22,26,58,94,45,97,58,91,40};
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("Error: divisor can't be zero
");
return 0;
} | ( | [
"a) x:",
"b) >>",
"c) int",
"d) (",
"e) ="
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int dep [ ], int n ) {
sort ( arr, arr + n );
sort ( dep, dep + n );
int plat_needed = 1, result = 1;
int i = 1, j = 0;
while ( i < n && j < n ) {
if ( arr [ i ] <= dep [ j ] ) {
plat_needed ++;
i ++;
if ( plat_needed > result ) result = plat_needed;
}
else {
plat_needed --;
j ++;
}
}
return result;
}
int f_filled ( int arr [ ], int dep [ ], int n ) {}
i ++;
if ( plat_needed > result ) result = plat_needed;
}
else {
plat_needed --;
j ++;
}
}
return result;
}
int f_filled ( int arr [ ], int dep [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {8,24,28,64,75,86,93,95};
int param0_1[] = {2,-30,-8,-78,58,-42,-94,84,-58,14,78,34,30,6,-18,-92,0,94,-54,58,0,-86,66,86,8,-26,50,16,-30,-68,98,-28,-4,-6};
int param0_2[] = {0,0,0,0,0,0,1};
int param0_3[] = {51,5,48,61,71,2,4,35,50,76,59,64,81,5,21,95};
int param0_4[] = {-64,-52,44,52,90};
int param0_5[] = {0,0,1,0,1,0,1,1,0,1,1,1,0,1,0,1,0,1,0,0,0,1,1,1,0,1,0,1,1,1};
int param0_6[] = {2,15,25,55,72,96,98};
int param0_7[] = {-60,30,-58,52,40,74,74,76,-72,-48,8,-56,-24,-40,-98,-76,-56,-20,30,-30,-34,4,-34};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {37,84,20,34,56,1,87,72};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1_0[] = {19,30,41,51,62,68,85,96};
int param1_1[] = {40,22,-24,80,-76,-4,-8,-34,96,-98,16,28,14,52,10,-10,-62,64,-48,10,-64,-90,-52,46,34,50,50,-84,68,-12,-44,28,-22,78};
int param1_2[] = {0,0,0,0,0,1,1};
int param1_3[] = {67,84,86,43,50,90,49,8,40,67,5,51,40,28,31,47};
int param1_4[] = {-62,-16,22,26,58};
int param1_5[] = {0,0,1,1,1,0,1,1,0,0,0,0,1,1,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0};
int param1_6[] = {3,6,11,19,26,37,39};
int param1_7[] = {-96,-40,-76,52,-20,-28,-64,-72,36,56,52,34,14,8,-50,6,-82,-98,-8,18,-76,-66,-22};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {68,62,84,54,15,29,70,96};
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[] = {6,18,6,8,3,17,6,20,22,6};
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 dep [ ], int n ) { sort ( arr, arr + n ); sort ( dep, dep + n ); int plat_needed = 1, result = 1; int i = 1, j = 0; while ( i < n && j < n ) { if ( arr [ i ] <= dep [ [MASK] ] ) { plat_needed ++; i ++; if ( plat_needed > result ) result = plat_needed; } else { plat_needed --; j ++; } } return result; } int f_filled ( int arr [ ], int dep [ ], int n ) {} i ++;
if ( plat_needed > result ) result = plat_needed;
}
else {
plat_needed --;
j ++;
}
}
return result;
}
int f_filled ( int arr [ ], int dep [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {8,24,28,64,75,86,93,95};
int param0_1[] = {2,-30,-8,-78,58,-42,-94,84,-58,14,78,34,30,6,-18,-92,0,94,-54,58,0,-86,66,86,8,-26,50,16,-30,-68,98,-28,-4,-6};
int param0_2[] = {0,0,0,0,0,0,1};
int param0_3[] = {51,5,48,61,71,2,4,35,50,76,59,64,81,5,21,95};
int param0_4[] = {-64,-52,44,52,90};
int param0_5[] = {0,0,1,0,1,0,1,1,0,1,1,1,0,1,0,1,0,1,0,0,0,1,1,1,0,1,0,1,1,1};
int param0_6[] = {2,15,25,55,72,96,98};
int param0_7[] = {-60,30,-58,52,40,74,74,76,-72,-48,8,-56,-24,-40,-98,-76,-56,-20,30,-30,-34,4,-34};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {37,84,20,34,56,1,87,72};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1_0[] = {19,30,41,51,62,68,85,96};
int param1_1[] = {40,22,-24,80,-76,-4,-8,-34,96,-98,16,28,14,52,10,-10,-62,64,-48,10,-64,-90,-52,46,34,50,50,-84,68,-12,-44,28,-22,78};
int param1_2[] = {0,0,0,0,0,1,1};
int param1_3[] = {67,84,86,43,50,90,49,8,40,67,5,51,40,28,31,47};
int param1_4[] = {-62,-16,22,26,58};
int param1_5[] = {0,0,1,1,1,0,1,1,0,0,0,0,1,1,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0};
int param1_6[] = {3,6,11,19,26,37,39};
int param1_7[] = {-96,-40,-76,52,-20,-28,-64,-72,36,56,52,34,14,8,-50,6,-82,-98,-8,18,-76,-66,-22};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {68,62,84,54,15,29,70,96};
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[] = {6,18,6,8,3,17,6,20,22,6};
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;
} | j | [
"a) y)",
"b) j",
"c) (",
"d) arr",
"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 ( unsigned int n ) {
int res = 1;
for ( int i = 0;
i < n;
++ i ) {
res *= ( 2 * n - i );
res /= ( i + 1 );
}
return res / ( n + 1 );
}
int f_filled ( unsigned int n ) {}
_gold ( unsigned int n ) {
int res = 1;
for ( int i = 0;
i < n;
++ i ) {
res *= ( 2 * n - i );
res /= ( i + 1 );
}
return res / ( n + 1 );
}
int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {72,90,61,28,70,13,7,98,99,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; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) [MASK] ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( unsigned int n ) { int res = 1; for ( int i = 0; i < n; ++ i ) { res *= ( 2 * n - i ); res /= ( i + 1 ); } return res / ( n + 1 ); } int f_filled ( unsigned int n ) {}_gold ( unsigned int n ) {
int res = 1;
for ( int i = 0;
i < n;
++ i ) {
res *= ( 2 * n - i );
res /= ( i + 1 );
}
return res / ( n + 1 );
}
int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {72,90,61,28,70,13,7,98,99,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;
} | {return | [
"a) l",
"b) (",
"c) class",
"d) {return",
"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);}
long long f_gold ( int n ) {
int dp [ n + 1 ] [ 10 ];
if ( n == 1 ) return 10;
for ( int j = 0;
j <= 9;
j ++ ) dp [ 1 ] [ j ] = 1;
for ( int i = 2;
i <= n;
i ++ ) {
for ( int j = 0;
j <= 9;
j ++ ) {
if ( j == 0 ) dp [ i ] [ j ] = dp [ i - 1 ] [ j + 1 ];
else if ( j == 9 ) dp [ i ] [ j ] = dp [ i - 1 ] [ j - 1 ];
else dp [ i ] [ j ] = dp [ i - 1 ] [ j - 1 ] + dp [ i - 1 ] [ j + 1 ];
}
}
long long sum = 0;
for ( int j = 1;
j <= 9;
j ++ ) sum += dp [ n ] [ j ];
return sum;
}
long long f_filled ( int n ) {}
j ] = dp [ i - 1 ] [ j - 1 ] + dp [ i - 1 ] [ j + 1 ];
}
}
long long sum = 0;
for ( int j = 1;
j <= 9;
j ++ ) sum += dp [ n ] [ j ];
return sum;
}
long long f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {18,66,73,70,26,41,20,25,52,13};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} long long f_gold ( int n ) { int dp [ n + 1 ] [ 10 ]; if ( n == 1 ) return 10; for ( int j = 0; j <= [MASK] j ++ ) dp [ 1 ] [ j ] = 1; for ( int i = 2; i <= n; i ++ ) { for ( int j = 0; j <= 9; j ++ ) { if ( j == 0 ) dp [ i ] [ j ] = dp [ i - 1 ] [ j + 1 ]; else if ( j == 9 ) dp [ i ] [ j ] = dp [ i - 1 ] [ j - 1 ]; else dp [ i ] [ j ] = dp [ i - 1 ] [ j - 1 ] + dp [ i - 1 ] [ j + 1 ]; } } long long sum = 0; for ( int j = 1; j <= 9; j ++ ) sum += dp [ n ] [ j ]; return sum; } long long f_filled ( int n ) {} j ] = dp [ i - 1 ] [ j - 1 ] + dp [ i - 1 ] [ j + 1 ];
}
}
long long sum = 0;
for ( int j = 1;
j <= 9;
j ++ ) sum += dp [ n ] [ j ];
return sum;
}
long long f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {18,66,73,70,26,41,20,25,52,13};
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;
} | 9; | [
"a) 0",
"b) ]",
"c) 9;",
"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 k ) {
int count = 0;
for ( int i = 0;
i < n;
i ++ ) {
for ( int j = i + 1;
j < n;
j ++ ) if ( arr [ i ] - arr [ j ] == k || arr [ j ] - arr [ i ] == k ) count ++;
}
return count;
}
int f_filled ( int arr [ ], int n, int k ) {}
++ ) {
for ( int j = i + 1;
j < n;
j ++ ) if ( arr [ i ] - arr [ j ] == k || arr [ j ] - arr [ i ] == k ) count ++;
}
return count;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,14,17,19,22,23,23,27,30,31,34,37,37,39,39,42,57,61,68,73,77,79,91,96,97};
int param0_1[] = {-78,-42,28,-88,18,-52};
int param0_2[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param0_3[] = {8,46,57,28,80,2,75,57,83,45,32,49,77,30,94,33,23,29,35,81,85};
int param0_4[] = {-90,-72,-72,-62,-62,-54,-54,-52,-48,-38,-22,-22,-22,-12,-12,-8,-8,-8,-6,-6,-2,6,12,26,26,28,28,38,40,48,52,52,58,60,68,70,72,76,76,76,92};
int param0_5[] = {0,0,1,1,0,1,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1,0,1,0,0,1,0,0,1,0,1};
int param0_6[] = {3,13,19,23,27,32,49,52,54,57,58,58,63,67,68,68,69,70,75,80,86,90,91,95};
int param0_7[] = {-56,40,-66,42,8,-40,-8,-42};
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};
int param0_9[] = {99,12,90,10,86,86,81,19,1,1,98,82,34,39,34,1,54,47,39,82,21,50,82,41,98,47,88,46,72,28,28,29,60,87,92,53,93,29,74,75,11,32,48,47,85,16,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[] = {19,3,16,15,22,45,19,7,16,24};
int param2[] = {19,4,14,11,25,39,21,6,28,45};
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 [MASK] #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 count = 0; for ( int i = 0; i < n; i ++ ) { for ( int j = i + 1; j < n; j ++ ) if ( arr [ i ] - arr [ j ] == k || arr [ j ] - arr [ i ] == k ) count ++; } return count; } int f_filled ( int arr [ ], int n, int k ) {}++ ) {
for ( int j = i + 1;
j < n;
j ++ ) if ( arr [ i ] - arr [ j ] == k || arr [ j ] - arr [ i ] == k ) count ++;
}
return count;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,14,17,19,22,23,23,27,30,31,34,37,37,39,39,42,57,61,68,73,77,79,91,96,97};
int param0_1[] = {-78,-42,28,-88,18,-52};
int param0_2[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param0_3[] = {8,46,57,28,80,2,75,57,83,45,32,49,77,30,94,33,23,29,35,81,85};
int param0_4[] = {-90,-72,-72,-62,-62,-54,-54,-52,-48,-38,-22,-22,-22,-12,-12,-8,-8,-8,-6,-6,-2,6,12,26,26,28,28,38,40,48,52,52,58,60,68,70,72,76,76,76,92};
int param0_5[] = {0,0,1,1,0,1,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1,0,1,0,0,1,0,0,1,0,1};
int param0_6[] = {3,13,19,23,27,32,49,52,54,57,58,58,63,67,68,68,69,70,75,80,86,90,91,95};
int param0_7[] = {-56,40,-66,42,8,-40,-8,-42};
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};
int param0_9[] = {99,12,90,10,86,86,81,19,1,1,98,82,34,39,34,1,54,47,39,82,21,50,82,41,98,47,88,46,72,28,28,29,60,87,92,53,93,29,74,75,11,32,48,47,85,16,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[] = {19,3,16,15,22,45,19,7,16,24};
int param2[] = {19,4,14,11,25,39,21,6,28,45};
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;
} | <stdio.h> | [
"a) int",
"b) +",
"c) <stdio.h>",
"d) break",
"e) b)"
] | 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 ) {
int dp [ k ] [ n ], sum = 0;
memset ( dp, 0, sizeof ( dp ) );
for ( int i = 0;
i < n;
i ++ ) dp [ 0 ] [ i ] = 1;
for ( int l = 1;
l < k;
l ++ ) {
for ( int i = l;
i < n;
i ++ ) {
dp [ l ] [ i ] = 0;
for ( int j = l - 1;
j < i;
j ++ ) {
if ( arr [ j ] < arr [ i ] ) dp [ l ] [ i ] += dp [ l - 1 ] [ j ];
}
}
}
for ( int i = k - 1;
i < n;
i ++ ) sum += dp [ k - 1 ] [ i ];
return sum;
}
int f_filled ( int arr [ ], int n, int k ) {}
r [ i ] ) dp [ l ] [ i ] += dp [ l - 1 ] [ j ];
}
}
}
for ( int i = k - 1;
i < n;
i ++ ) sum += dp [ k - 1 ] [ i ];
return sum;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {10,18,66,68,83,86,97};
int param0_1[] = {-30,-16,-70,80,68,96,54,64,-56,96,46,-70,-14,28,-38,-52,-96,-4,-8,16,24,-10,4,54};
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};
int param0_3[] = {26,72,75,50,57,64,74,99,41,12,11,10,20,1,28,74,92,33,14,18,31,63,52,62,35,97,61,51,39,64,37,12,16,60,72,58,95,41,80,4,50,95,38,60,53};
int param0_4[] = {-94,-88,-74,-74,-72,-68,-62,-60,-60,-54,-54,-36,-30,-18,-6,12,28,32,32,44,50,52,72,74,84,84,88,92};
int param0_5[] = {1};
int param0_6[] = {2,2,10,11,16,23,32,34,34,35,35,41,42,43,44,44,44,45,46,47,49,51,52,52,54,56,59,60,64,65,66,66,67,69,71,77,78,79,82,86,88,89,90,93,95,95,98};
int param0_7[] = {-42,90,18,42,72,88,58,62,-86,14,76,-34,-64,12,-4,90,96,-34,-90,-84,54,-70,96,30,-26,44,-50,-14,50};
int param0_8[] = {0,0,0,0,1,1,1,1,1,1,1,1};
int param0_9[] = {44,19,10,19,84,31,68,2,35,94,18,83,93,84,37,79,50,22,77,3,60,4,70,26,58,60,59,22,75,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[] = {6,18,14,35,17,0,24,18,9,20};
int param2[] = {5,15,17,31,15,0,38,21,8,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 [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 ) { int dp [ k ] [ n ], sum = 0; memset ( dp, 0, sizeof ( dp ) ); for ( int i = 0; i < n; i ++ ) dp [ 0 ] [ i ] = 1; for ( int l = 1; l < k; l ++ ) { for ( int i = l; i < n; i ++ ) { dp [ l ] [ i ] = 0; for ( int j = l - 1; j < i; j ++ ) { if ( arr [ j ] < arr [ i ] ) dp [ l ] [ i ] += dp [ l - 1 ] [ j ]; } } } for ( int i = k - 1; i < n; i ++ ) sum += dp [ k - 1 ] [ i ]; return sum; } int f_filled ( int arr [ ], int n, int k ) {}r [ i ] ) dp [ l ] [ i ] += dp [ l - 1 ] [ j ];
}
}
}
for ( int i = k - 1;
i < n;
i ++ ) sum += dp [ k - 1 ] [ i ];
return sum;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {10,18,66,68,83,86,97};
int param0_1[] = {-30,-16,-70,80,68,96,54,64,-56,96,46,-70,-14,28,-38,-52,-96,-4,-8,16,24,-10,4,54};
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};
int param0_3[] = {26,72,75,50,57,64,74,99,41,12,11,10,20,1,28,74,92,33,14,18,31,63,52,62,35,97,61,51,39,64,37,12,16,60,72,58,95,41,80,4,50,95,38,60,53};
int param0_4[] = {-94,-88,-74,-74,-72,-68,-62,-60,-60,-54,-54,-36,-30,-18,-6,12,28,32,32,44,50,52,72,74,84,84,88,92};
int param0_5[] = {1};
int param0_6[] = {2,2,10,11,16,23,32,34,34,35,35,41,42,43,44,44,44,45,46,47,49,51,52,52,54,56,59,60,64,65,66,66,67,69,71,77,78,79,82,86,88,89,90,93,95,95,98};
int param0_7[] = {-42,90,18,42,72,88,58,62,-86,14,76,-34,-64,12,-4,90,96,-34,-90,-84,54,-70,96,30,-26,44,-50,-14,50};
int param0_8[] = {0,0,0,0,1,1,1,1,1,1,1,1};
int param0_9[] = {44,19,10,19,84,31,68,2,35,94,18,83,93,84,37,79,50,22,77,3,60,4,70,26,58,60,59,22,75,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[] = {6,18,14,35,17,0,24,18,9,20};
int param2[] = {5,15,17,31,15,0,38,21,8,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;
} | < | [
"a) <",
"b) }",
"c) f_gold",
"d) i",
"e) min(int"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int res = 1;
for ( int i = 2;
i <= sqrt ( n );
i ++ ) {
int curr_sum = 1;
int curr_term = 1;
while ( n % i == 0 ) {
n = n / i;
curr_term *= i;
curr_sum += curr_term;
}
res *= curr_sum;
}
if ( n >= 2 ) res *= ( 1 + n );
return res;
}
int f_filled ( int n ) {}
ile ( n % i == 0 ) {
n = n / i;
curr_term *= i;
curr_sum += curr_term;
}
res *= curr_sum;
}
if ( n >= 2 ) res *= ( 1 + n );
return res;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {96,32,93,78,30,5,62,27,95,45};
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) [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 n ) { int res = 1; for ( int i = 2; i <= sqrt ( n ); i ++ ) { int curr_sum = 1; int curr_term = 1; while ( n % i == 0 ) { n = n / i; curr_term *= i; curr_sum += curr_term; } res *= curr_sum; } if ( n >= 2 ) res *= ( 1 + n ); return res; } int f_filled ( int n ) {}ile ( n % i == 0 ) {
n = n / i;
curr_term *= i;
curr_sum += curr_term;
}
res *= curr_sum;
}
if ( n >= 2 ) res *= ( 1 + n );
return res;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {96,32,93,78,30,5,62,27,95,45};
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) f3",
"b) CHECK_TWO_GIVEN_CIRCLES_TOUCH_INTERSECT{",
"c) #include",
"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);}
char f_gold ( char strA [], char strB [] ) {
int res = 0, i;
for ( i = 0;
i < strlen(strA);
i ++ ) {
res ^= strA [ i ];
}
for ( i = 0;
i < strlen(strB);
i ++ ) {
res ^= strB [ i ];
}
return ( ( char ) ( res ) );
}
char f_filled ( char strA [], char strB [] ) {}
A);
i ++ ) {
res ^= strA [ i ];
}
for ( i = 0;
i < strlen(strB);
i ++ ) {
res ^= strB [ i ];
}
return ( ( char ) ( res ) );
}
char f_filled ( char strA [], char strB [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"obfLA mmMYvghH","2941","0111111","oWvbFstI","4937516500","101110100","hYZscJQFBE","58443","1100","ZUdYuIBVNaeeb"};
char param1[][100] = {"obfLA mmMYvghH","23941","01011111","oWvsbFstI","49376516500","1011210100","hYZscJQQFBE","584443","11000","ZUdYVuIBVNaeeb"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) [MASK] ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} char f_gold ( char strA [], char strB [] ) { int res = 0, i; for ( i = 0; i < strlen(strA); i ++ ) { res ^= strA [ i ]; } for ( i = 0; i < strlen(strB); i ++ ) { res ^= strB [ i ]; } return ( ( char ) ( res ) ); } char f_filled ( char strA [], char strB [] ) {}A);
i ++ ) {
res ^= strA [ i ];
}
for ( i = 0;
i < strlen(strB);
i ++ ) {
res ^= strB [ i ];
}
return ( ( char ) ( res ) );
}
char f_filled ( char strA [], char strB [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"obfLA mmMYvghH","2941","0111111","oWvbFstI","4937516500","101110100","hYZscJQFBE","58443","1100","ZUdYuIBVNaeeb"};
char param1[][100] = {"obfLA mmMYvghH","23941","01011111","oWvsbFstI","49376516500","1011210100","hYZscJQQFBE","584443","11000","ZUdYVuIBVNaeeb"};
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) <stdlib.h>",
"c) <",
"d) )",
"e) x:"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int n, int l, int r ) {
int count = 0;
for ( int i = l;
i < r;
i ++ ) if ( a [ i ] == a [ i + 1 ] ) count += 1;
return count;
}
int f_filled ( int a [ ], int n, int l, int r ) {}
a [ ], int n, int l, int r ) {
int count = 0;
for ( int i = l;
i < r;
i ++ ) if ( a [ i ] == a [ i + 1 ] ) count += 1;
return count;
}
int f_filled ( int a [ ], int n, int l, int r ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,13,13,16,16,19,39,41,48,52,57,62,65,67,76,84,88,91,95,96,97,98};
int param0_1[] = {62,76,86,-8,84,-6,72,84,6,-50,-18,-94,54,90,-74,-64,-26,-14,-32,62,10,4,70,-28,8,18,4,-62,-76,84,-78,-4,84,98,58,-68,42,-6,34,-38,52,-84,78};
int param0_2[] = {0,0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {11,75,98,29,62,53,48,91,86,66,48,94};
int param0_4[] = {-94,-84,-70,-70,-40,-40,-36,-24,10,48,62,74};
int param0_5[] = {1,0,1,1,0,1,0,1,1,1,1,0,1,1,0,1,1,1,1,1,1,0,1,0,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,0,1,1,0,0};
int param0_6[] = {1,2,6,7,10,11,13,19,19,25,29,30,32,34,35,45,45,46,47,48,48,53,58,61,64,65,67,75,76,81,81,84,84,85,86,94,94,96,99};
int param0_7[] = {-56,42,-34,-12,-86,82,-96,-66,30,16,-40,72,84,94,-48,-30,26,50,42,-44,-50,22,-38,8,34,94,2,16,-32,18,-58,12,-26,28,-62};
int param0_8[] = {0,0,0,0,1,1,1};
int param0_9[] = {6,29};
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[] = {18,32,10,8,11,36,25,21,4,1};
int param2[] = {12,38,6,6,7,40,19,30,5,1};
int param3[] = {17,23,6,6,8,37,37,26,5,1};
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 [MASK] < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a [ ], int n, int l, int r ) { int count = 0; for ( int i = l; i < r; i ++ ) if ( a [ i ] == a [ i + 1 ] ) count += 1; return count; } int f_filled ( int a [ ], int n, int l, int r ) {}a [ ], int n, int l, int r ) {
int count = 0;
for ( int i = l;
i < r;
i ++ ) if ( a [ i ] == a [ i + 1 ] ) count += 1;
return count;
}
int f_filled ( int a [ ], int n, int l, int r ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,13,13,16,16,19,39,41,48,52,57,62,65,67,76,84,88,91,95,96,97,98};
int param0_1[] = {62,76,86,-8,84,-6,72,84,6,-50,-18,-94,54,90,-74,-64,-26,-14,-32,62,10,4,70,-28,8,18,4,-62,-76,84,-78,-4,84,98,58,-68,42,-6,34,-38,52,-84,78};
int param0_2[] = {0,0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {11,75,98,29,62,53,48,91,86,66,48,94};
int param0_4[] = {-94,-84,-70,-70,-40,-40,-36,-24,10,48,62,74};
int param0_5[] = {1,0,1,1,0,1,0,1,1,1,1,0,1,1,0,1,1,1,1,1,1,0,1,0,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,0,1,1,0,0};
int param0_6[] = {1,2,6,7,10,11,13,19,19,25,29,30,32,34,35,45,45,46,47,48,48,53,58,61,64,65,67,75,76,81,81,84,84,85,86,94,94,96,99};
int param0_7[] = {-56,42,-34,-12,-86,82,-96,-66,30,16,-40,72,84,94,-48,-30,26,50,42,-44,-50,22,-38,8,34,94,2,16,-32,18,-58,12,-26,28,-62};
int param0_8[] = {0,0,0,0,1,1,1};
int param0_9[] = {6,29};
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[] = {18,32,10,8,11,36,25,21,4,1};
int param2[] = {12,38,6,6,7,40,19,30,5,1};
int param3[] = {17,23,6,6,8,37,37,26,5,1};
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) int",
"b) n",
"c) ==",
"d) f_gold",
"e) (x"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int res = 1;
while ( n % 2 == 0 ) n = n / 2;
for ( int i = 3;
i <= sqrt ( n );
i ++ ) {
int count = 0, curr_sum = 1;
int curr_term = 1;
while ( n % i == 0 ) {
count ++;
n = n / i;
curr_term *= i;
curr_sum += curr_term;
}
res *= curr_sum;
}
if ( n >= 2 ) res *= ( 1 + n );
return res;
}
int f_filled ( int n ) {}
) {
count ++;
n = n / i;
curr_term *= i;
curr_sum += curr_term;
}
res *= curr_sum;
}
if ( n >= 2 ) res *= ( 1 + n );
return res;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {20,6,39,80,88,7,16,27,83,6};
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> [MASK] <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { int res = 1; while ( n % 2 == 0 ) n = n / 2; for ( int i = 3; i <= sqrt ( n ); i ++ ) { int count = 0, curr_sum = 1; int curr_term = 1; while ( n % i == 0 ) { count ++; n = n / i; curr_term *= i; curr_sum += curr_term; } res *= curr_sum; } if ( n >= 2 ) res *= ( 1 + n ); return res; } int f_filled ( int n ) {} ) {
count ++;
n = n / i;
curr_term *= i;
curr_sum += curr_term;
}
res *= curr_sum;
}
if ( n >= 2 ) res *= ( 1 + n );
return res;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {20,6,39,80,88,7,16,27,83,6};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include | [
"a) arr",
"b) (",
"c) i",
"d) #include",
"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);}
double f_gold ( int side ) {
return ( ( ( 15 + ( 7 * ( sqrt ( 5 ) ) ) ) / 4 ) * ( pow ( side, 3 ) ) );
}
double f_filled ( int side ) {}
arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
double f_gold ( int side ) {
return ( ( ( 15 + ( 7 * ( sqrt ( 5 ) ) ) ) / 4 ) * ( pow ( side, 3 ) ) );
}
double f_filled ( int side ) {}
int main(void) {
int n_success = 0;
int param0[] = {56,73,22,10,84,20,51,91,10,83};
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 [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} double f_gold ( int side ) { return ( ( ( 15 + ( 7 * ( sqrt ( 5 ) ) ) ) / 4 ) * ( pow ( side, [MASK] ) ) ); } double f_filled ( int side ) {}arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
double f_gold ( int side ) {
return ( ( ( 15 + ( 7 * ( sqrt ( 5 ) ) ) ) / 4 ) * ( pow ( side, 3 ) ) );
}
double f_filled ( int side ) {}
int main(void) {
int n_success = 0;
int param0[] = {56,73,22,10,84,20,51,91,10,83};
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;
} | 3 | [
"a) return",
"b) 0",
"c) ]",
"d) i",
"e) 3"
] | 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 s [] ) {
if ( strlen(s) == 0 ) printf(0, endl);
int ans = 0;
int o = 0, c = 0;
for ( int i = 0;
i < strlen(s);
i ++ ) {
if ( s [ i ] == '(' ) o ++;
if ( s [ i ] == ')' ) c ++;
}
if ( o != c ) return - 1;
int a [ len(s) ];
if ( s [ 0 ] == '(' ) a [ 0 ] = 1;
else a [ 0 ] = - 1;
if ( a [ 0 ] < 0 ) ans += abs ( a [ 0 ] );
for ( int i = 1;
i < strlen(s);
i ++ ) {
if ( s [ i ] == '(' ) a [ i ] = a [ i - 1 ] + 1;
else a [ i ] = a [ i - 1 ] - 1;
if ( a [ i ] < 0 ) ans += abs ( a [ i ] );
}
return ans;
}
int f_filled ( char s [] ) {}
i ++ ) {
if ( s [ i ] == '(' ) a [ i ] = a [ i - 1 ] + 1;
else a [ i ] = a [ i - 1 ] - 1;
if ( a [ i ] < 0 ) ans += abs ( a [ i ] );
}
return ans;
}
int f_filled ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"()","))((","())","(()","(()()())","))())(()(())","))(())((","49","00001111","KDahByG "};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf(0, endl);
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char s [] ) { if ( strlen(s) == 0 ) printf(0, endl); int ans = 0; int o = 0, c = 0; for ( int i = 0; i < strlen(s); i ++ ) { if ( s [ i ] == '(' ) o ++; if ( s [ i ] == ')' ) c ++; } if ( o != c ) return - 1; int a [ len(s) ]; if ( s [ 0 ] == '(' ) a [ 0 ] = [MASK] else a [ 0 ] = - 1; if ( a [ 0 ] < 0 ) ans += abs ( a [ 0 ] ); for ( int i = 1; i < strlen(s); i ++ ) { if ( s [ i ] == '(' ) a [ i ] = a [ i - 1 ] + 1; else a [ i ] = a [ i - 1 ] - 1; if ( a [ i ] < 0 ) ans += abs ( a [ i ] ); } return ans; } int f_filled ( char s [] ) {} i ++ ) {
if ( s [ i ] == '(' ) a [ i ] = a [ i - 1 ] + 1;
else a [ i ] = a [ i - 1 ] - 1;
if ( a [ i ] < 0 ) ans += abs ( a [ i ] );
}
return ans;
}
int f_filled ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"()","))((","())","(()","(()()())","))())(()(())","))(())((","49","00001111","KDahByG "};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf(0, endl);
return 0;
} | 1; | [
"a) :",
"b) s",
"c) 1;",
"d) [",
"e) x:"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n, int k ) {
int count = 0;
sort ( arr, arr + n );
int l = 0;
int r = 0;
while ( r < n ) {
if ( arr [ r ] - arr [ l ] == k ) {
count ++;
l ++;
r ++;
}
else if ( arr [ r ] - arr [ l ] > k ) l ++;
else r ++;
}
return count;
}
int f_filled ( int arr [ ], int n, int k ) {}
arr [ l ] == k ) {
count ++;
l ++;
r ++;
}
else if ( arr [ r ] - arr [ l ] > k ) l ++;
else r ++;
}
return count;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {5,5,10,19,29,32,40,60,65,70,72,89,92};
int param0_1[] = {-38,40,8,64,-38,56,4,8,84,60,-48,-78,-82,-88,-30,58,-58,62,-52,-98,24,22,14,68,-74,48,-56,-72,-90,26,-10,58,40,36,-80,68,58,-74,-46,-62,-12,74,-58};
int param0_2[] = {0,0,1};
int param0_3[] = {16,80,59,29,14,44,13,76,7,65,62,1,34,49,70,96,73,71,42,73,66,96};
int param0_4[] = {-98,-88,-58,-56,-48,-34,-22,-18,-14,-14,-8,-4,-2,2,18,38,42,46,54,68,70,90,94,96,98};
int param0_5[] = {0,1,1};
int param0_6[] = {11,43,50,58,60,68,75};
int param0_7[] = {86,94,-80,0,52,-56,42,88,-10,24,6,8};
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};
int param0_9[] = {54,99,4,14,9,34,81,36,80,50,34,9,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[] = {7,24,1,12,23,2,4,11,29,9};
int param2[] = {12,36,1,16,22,1,4,9,30,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> #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 ) { int count = 0; sort ( arr, arr + n ); int l = 0; int r = 0; while ( r < n ) { if ( arr [ r ] - arr [ l ] == k ) { count ++; l ++; r ++; } else if ( arr [ r ] - arr [ l ] > k ) l ++; else r ++; } return count; } int f_filled ( int arr [ ], int n, int k ) {}arr [ l ] == k ) {
count ++;
l ++;
r ++;
}
else if ( arr [ r ] - arr [ l ] > k ) l ++;
else r ++;
}
return count;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {5,5,10,19,29,32,40,60,65,70,72,89,92};
int param0_1[] = {-38,40,8,64,-38,56,4,8,84,60,-48,-78,-82,-88,-30,58,-58,62,-52,-98,24,22,14,68,-74,48,-56,-72,-90,26,-10,58,40,36,-80,68,58,-74,-46,-62,-12,74,-58};
int param0_2[] = {0,0,1};
int param0_3[] = {16,80,59,29,14,44,13,76,7,65,62,1,34,49,70,96,73,71,42,73,66,96};
int param0_4[] = {-98,-88,-58,-56,-48,-34,-22,-18,-14,-14,-8,-4,-2,2,18,38,42,46,54,68,70,90,94,96,98};
int param0_5[] = {0,1,1};
int param0_6[] = {11,43,50,58,60,68,75};
int param0_7[] = {86,94,-80,0,52,-56,42,88,-10,24,6,8};
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};
int param0_9[] = {54,99,4,14,9,34,81,36,80,50,34,9,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[] = {7,24,1,12,23,2,4,11,29,9};
int param2[] = {12,36,1,16,22,1,4,9,30,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;
} | < | [
"a) <",
"b) mid",
"c) int",
"d) a",
"e) math.ceil"
] | 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 f [ n + 1 ];
int i;
f [ 0 ] = 0;
f [ 1 ] = 1;
f [ 2 ] = 1;
for ( i = 3;
i <= n;
i ++ ) f [ i ] = f [ f [ i - 1 ] ] + f [ i - f [ i - 1 ] ];
return f [ n ];
}
int f_filled ( int n ) {}
n + 1 ];
int i;
f [ 0 ] = 0;
f [ 1 ] = 1;
f [ 2 ] = 1;
for ( i = 3;
i <= n;
i ++ ) f [ i ] = f [ f [ i - 1 ] ] + f [ i - f [ i - 1 ] ];
return f [ n ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {39,93,3,28,23,95,41,31,46,29};
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 f [ n + 1 ]; int i; f [ 0 ] = 0; f [ 1 ] = 1; f [ 2 ] = 1; for ( i = 3; i <= n; i ++ ) f [ i ] = f [ f [MASK] i - 1 ] ] + f [ i - f [ i - 1 ] ]; return f [ n ]; } int f_filled ( int n ) {}n + 1 ];
int i;
f [ 0 ] = 0;
f [ 1 ] = 1;
f [ 2 ] = 1;
for ( i = 3;
i <= n;
i ++ ) f [ i ] = f [ f [ i - 1 ] ] + f [ i - f [ i - 1 ] ];
return f [ n ];
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {39,93,3,28,23,95,41,31,46,29};
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) std;",
"e) ;"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int n ) {
int i, total = 1;
for ( i = 2;
i <= ( n + 1 );
i ++ ) {
total += i;
total -= a [ i - 2 ];
}
return total;
}
int f_filled ( int a [ ], int n ) {}
f_gold ( int a [ ], int n ) {
int i, total = 1;
for ( i = 2;
i <= ( n + 1 );
i ++ ) {
total += i;
total -= a [ i - 2 ];
}
return total;
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {13,27,46,59,62,82,92};
int param0_1[] = {22,86,-64,-20,-56,-16,86,42,72,-90,10,42,56,8,50,24,-34,0,-78,64,18,20,-84,-22,90,-20,86,26,-54,0,90,-48,4,88,18,-64,-22,-74,48,-36,-86,-24,88,-64,68,62,92};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {55,89,56,85,26,4,91,91,3,77,63,59,76,90,1,94,44,70,8,54,3,91,29,95,28,75,20};
int param0_4[] = {-94,-84,-80,-78,-66,-62,-54,-52,-26,-8,-8,-6,4,4,8,14,26,58,60,62,62,76,78,86,92};
int param0_5[] = {1,0,0,0,1,0,0,1,1,0,0,0,1,1,0,0,1,0,0,1,0,0,0,1,1,1,1,1,1,1,0,0,0};
int param0_6[] = {1,2,7,7,9,14,23,29,31,31,35,35,38,41,44,49,49,50,51,54,55,56,57,63,67,69,73,79,79,80,86,88,93};
int param0_7[] = {78,-48,16,22,-16,34,56,-20,-62,-82,-74,-40,20,-24,-46,64,66,-76,58,-84,96,76,86,-32,46};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {73,76,25,59,40,85,90,38,13,97,93,99,45,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[] = {6,38,15,22,18,25,24,12,29,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) [MASK] (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a [ ], int n ) { int i, total = 1; for ( i = 2; i <= ( n + 1 ); i ++ ) { total += i; total -= a [ i - 2 ]; } return total; } int f_filled ( int a [ ], int n ) {} f_gold ( int a [ ], int n ) {
int i, total = 1;
for ( i = 2;
i <= ( n + 1 );
i ++ ) {
total += i;
total -= a [ i - 2 ];
}
return total;
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {13,27,46,59,62,82,92};
int param0_1[] = {22,86,-64,-20,-56,-16,86,42,72,-90,10,42,56,8,50,24,-34,0,-78,64,18,20,-84,-22,90,-20,86,26,-54,0,90,-48,4,88,18,-64,-22,-74,48,-36,-86,-24,88,-64,68,62,92};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {55,89,56,85,26,4,91,91,3,77,63,59,76,90,1,94,44,70,8,54,3,91,29,95,28,75,20};
int param0_4[] = {-94,-84,-80,-78,-66,-62,-54,-52,-26,-8,-8,-6,4,4,8,14,26,58,60,62,62,76,78,86,92};
int param0_5[] = {1,0,0,0,1,0,0,1,1,0,0,0,1,1,0,0,1,0,0,1,0,0,0,1,1,1,1,1,1,1,0,0,0};
int param0_6[] = {1,2,7,7,9,14,23,29,31,31,35,35,38,41,44,49,49,50,51,54,55,56,57,63,67,69,73,79,79,80,86,88,93};
int param0_7[] = {78,-48,16,22,-16,34,56,-20,-62,-82,-74,-40,20,-24,-46,64,66,-76,58,-84,96,76,86,-32,46};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {73,76,25,59,40,85,90,38,13,97,93,99,45,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[] = {6,38,15,22,18,25,24,12,29,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;
} | (sizeof | [
"a) (",
"b) <bits/stdc++.h>",
"c) (sizeof",
"d) int",
"e) ["
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int low, int high ) {
int max = arr [ low ];
int i;
for ( i = low + 1;
i <= high;
i ++ ) {
if ( arr [ i ] > max ) max = arr [ i ];
else break;
}
return max;
}
int f_filled ( int arr [ ], int low, int high ) {}
r [ low ];
int i;
for ( i = low + 1;
i <= high;
i ++ ) {
if ( arr [ i ] > max ) max = arr [ i ];
else break;
}
return max;
}
int f_filled ( int arr [ ], int low, int high ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {11,15,16,19,24,25,26,28,34,34,43,61,63,66,67,72,77,79,81,83,87,94,99};
int param0_1[] = {8,92};
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};
int param0_3[] = {84,39,92,89,38,75,18,39,83,67,41,46,49,27};
int param0_4[] = {-98,-94,-88,-84,-74,-72,-58,-52,-48,-48,-46,-42,-42,-32,-30,-30,-18,-10,-8,-8,-6,-4,4,6,28,30,34,38,44,48,56,58,60,64,86};
int param0_5[] = {0,1,0};
int param0_6[] = {5,9,10,16,18,19,23,24,26,33,37,44,46,54,55,57,58,59,63,64,70,75,77,81,83,84,85,85,88,89,96,97,99};
int param0_7[] = {86,20,-50,74,-78,86};
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};
int param0_9[] = {16,57,65,61,17,63,7,35,69,91,30,44,99,80,6,80,56,8,84,95,20,73,30,62,77,26,66,61,61,45};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {15,1,23,8,31,2,20,3,19,28};
int param2[] = {21,1,15,13,34,2,31,5,18,22};
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 [ ], [MASK] n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int low, int high ) { int max = arr [ low ]; int i; for ( i = low + 1; i <= high; i ++ ) { if ( arr [ i ] > max ) max = arr [ i ]; else break; } return max; } int f_filled ( int arr [ ], int low, int high ) {}r [ low ];
int i;
for ( i = low + 1;
i <= high;
i ++ ) {
if ( arr [ i ] > max ) max = arr [ i ];
else break;
}
return max;
}
int f_filled ( int arr [ ], int low, int high ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {11,15,16,19,24,25,26,28,34,34,43,61,63,66,67,72,77,79,81,83,87,94,99};
int param0_1[] = {8,92};
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};
int param0_3[] = {84,39,92,89,38,75,18,39,83,67,41,46,49,27};
int param0_4[] = {-98,-94,-88,-84,-74,-72,-58,-52,-48,-48,-46,-42,-42,-32,-30,-30,-18,-10,-8,-8,-6,-4,4,6,28,30,34,38,44,48,56,58,60,64,86};
int param0_5[] = {0,1,0};
int param0_6[] = {5,9,10,16,18,19,23,24,26,33,37,44,46,54,55,57,58,59,63,64,70,75,77,81,83,84,85,85,88,89,96,97,99};
int param0_7[] = {86,20,-50,74,-78,86};
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};
int param0_9[] = {16,57,65,61,17,63,7,35,69,91,30,44,99,80,6,80,56,8,84,95,20,73,30,62,77,26,66,61,61,45};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {15,1,23,8,31,2,20,3,19,28};
int param2[] = {21,1,15,13,34,2,31,5,18,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | int | [
"a) int",
"b) prev_zero",
"c) Vector",
"d) i",
"e) def"
] | 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 ceil ( log2 ( N + 1 ) ) - 1;
}
int f_filled ( int N ) {}
sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int N ) {
return ceil ( log2 ( N + 1 ) ) - 1;
}
int f_filled ( int N ) {}
int main(void) {
int n_success = 0;
int param0[] = {65,94,52,31,9,1,41,98,45,24};
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] ceil ( log2 ( N + 1 ) ) - 1; } int f_filled ( int N ) {}sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int N ) {
return ceil ( log2 ( N + 1 ) ) - 1;
}
int f_filled ( int N ) {}
int main(void) {
int n_success = 0;
int param0[] = {65,94,52,31,9,1,41,98,45,24};
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) (",
"b) static",
"c) s",
"d) return",
"e) x"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int a = ( n / 10 ) * 10;
int b = a + 10;
return ( n - a > b - n ) ? b : a;
}
int f_filled ( int n ) {}
t (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int a = ( n / 10 ) * 10;
int b = a + 10;
return ( n - a > b - n ) ? b : a;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {31,78,19,36,77,94,86,16,95,2};
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] sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { int a = ( n / 10 ) * 10; int b = a + 10; return ( n - a > b - n ) ? b : a; } int f_filled ( int n ) {}t (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int a = ( n / 10 ) * 10;
int b = a + 10;
return ( n - a > b - n ) ? b : a;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {31,78,19,36,77,94,86,16,95,2};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | / | [
"a) j",
"b) /",
"c) {",
"d) f_gold",
"e) #include"
] | 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 ) {
unordered_map < int, int > um;
int curr_sum = 0;
for ( int i = 0;
i < n;
i ++ ) {
curr_sum += ( arr [ i ] == 0 ) ? - 1 : arr [ i ];
um [ curr_sum ] ++;
}
int count = 0;
for ( auto itr = um . begin ( );
itr != um . end ( );
itr ++ ) {
if ( itr -> second > 1 ) count += ( ( itr -> second * ( itr -> second - 1 ) ) / 2 );
}
if ( um . find ( 0 ) != um . end ( ) ) count += um [ 0 ];
return count;
}
int f_filled ( int arr [ ], int n ) {}
> second > 1 ) count += ( ( itr -> second * ( itr -> second - 1 ) ) / 2 );
}
if ( um . find ( 0 ) != um . end ( ) ) count += um [ 0 ];
return count;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,12,18,19,19,20,20,21,25,29,38,54,54,71,72,72,74,75,77,78,80,80,81,84,97,97};
int param0_1[] = {10,70,24,-38,32,-68,88,-28,-24,-70,-64,50,-30,64,54,-6,18,-30,-30,-62,-10,94,-54,-22,-88,96,22,26,-92,-40,-76,46,36,30,24,-52,0};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {66,50,17,15,86,84,87,24,81,23,71,31,13,72,58,19,29,28,40,14,48,48,81,4,52,88,54,56,10,12,58,55,7,66,15,73,22,2,20,27,57,56,56,31,9,55};
int param0_4[] = {-98,-62,-60,16,78,82};
int param0_5[] = {1,0,1};
int param0_6[] = {2,31,34,64};
int param0_7[] = {-70,90,-10,-64,-76,-74,-12,-44,-48,-54,76,-78,8,0,0,78,-28,6,98,-84,60,60,2,48,-96,-28,-78,-76,-56,-26,-60,50,44,34,-90,80,-30,-98,62,36,-46,-72};
int param0_8[] = {1,1,1};
int param0_9[] = {37,70,80,61,86,10,17,98,54,89,87,84,11,55,3,52,4,90,98,31,20,62,71,58,58,6,92,5,99,99,72,40,82,54,23,19,85,91,62,98,62,72,93,74};
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[] = {24,24,11,40,5,2,2,25,1,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 [MASK] arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { unordered_map < int, int > um; int curr_sum = 0; for ( int i = 0; i < n; i ++ ) { curr_sum += ( arr [ i ] == 0 ) ? - 1 : arr [ i ]; um [ curr_sum ] ++; } int count = 0; for ( auto itr = um . begin ( ); itr != um . end ( ); itr ++ ) { if ( itr -> second > 1 ) count += ( ( itr -> second * ( itr -> second - 1 ) ) / 2 ); } if ( um . find ( 0 ) != um . end ( ) ) count += um [ 0 ]; return count; } int f_filled ( int arr [ ], int n ) {}> second > 1 ) count += ( ( itr -> second * ( itr -> second - 1 ) ) / 2 );
}
if ( um . find ( 0 ) != um . end ( ) ) count += um [ 0 ];
return count;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,12,18,19,19,20,20,21,25,29,38,54,54,71,72,72,74,75,77,78,80,80,81,84,97,97};
int param0_1[] = {10,70,24,-38,32,-68,88,-28,-24,-70,-64,50,-30,64,54,-6,18,-30,-30,-62,-10,94,-54,-22,-88,96,22,26,-92,-40,-76,46,36,30,24,-52,0};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {66,50,17,15,86,84,87,24,81,23,71,31,13,72,58,19,29,28,40,14,48,48,81,4,52,88,54,56,10,12,58,55,7,66,15,73,22,2,20,27,57,56,56,31,9,55};
int param0_4[] = {-98,-62,-60,16,78,82};
int param0_5[] = {1,0,1};
int param0_6[] = {2,31,34,64};
int param0_7[] = {-70,90,-10,-64,-76,-74,-12,-44,-48,-54,76,-78,8,0,0,78,-28,6,98,-84,60,60,2,48,-96,-28,-78,-76,-56,-26,-60,50,44,34,-90,80,-30,-98,62,36,-46,-72};
int param0_8[] = {1,1,1};
int param0_9[] = {37,70,80,61,86,10,17,98,54,89,87,84,11,55,3,52,4,90,98,31,20,62,71,58,58,6,92,5,99,99,72,40,82,54,23,19,85,91,62,98,62,72,93,74};
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[] = {24,24,11,40,5,2,2,25,1,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;
} | (int | [
"a) (int",
"b) :",
"c) ;",
"d) 1",
"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 ( char tree [], int k ) {
int level = - 1;
int sum = 0;
int n = strlen(tree);
for ( int i = 0;
i < n;
i ++ ) {
if ( tree [ i ] == '(' ) level ++;
else if ( tree [ i ] == ')' ) level --;
else {
if ( level == k ) sum += ( tree [ i ] - '0' );
}
}
return sum;
}
int f_filled ( char tree [], int k ) {}
] == '(' ) level ++;
else if ( tree [ i ] == ')' ) level --;
else {
if ( level == k ) sum += ( tree [ i ] - '0' );
}
}
return sum;
}
int f_filled ( char tree [], int k ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {
"(0(5(6()())(4()(9()())))(7(1()())(3()())))",
"(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))",
"(0(5(6()())(4()(9()())))(7(1()())(3()())))",
"(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))",
"(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))",
"(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))",
"(0(5(6()())(4()(9()())))(7(1()())(3()())))",
"(0(5(6()())(4()(9()())))(7(1()())(3()())))",
"0010",
"kjtdgmy"};
int param1[] = {2,3,1,2,4,100,3,0,12,97};
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 tree [], int k ) { int level = - 1; int sum = 0; int n = strlen(tree); for ( int i = 0; i < n; i ++ ) { if ( tree [ i ] == '(' ) level ++; else if ( tree [ i ] == ')' ) level --; else [MASK] if ( level == k ) sum += ( tree [ i ] - '0' ); } } return sum; } int f_filled ( char tree [], int k ) {} ] == '(' ) level ++;
else if ( tree [ i ] == ')' ) level --;
else {
if ( level == k ) sum += ( tree [ i ] - '0' );
}
}
return sum;
}
int f_filled ( char tree [], int k ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {
"(0(5(6()())(4()(9()())))(7(1()())(3()())))",
"(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))",
"(0(5(6()())(4()(9()())))(7(1()())(3()())))",
"(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))",
"(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))",
"(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))",
"(0(5(6()())(4()(9()())))(7(1()())(3()())))",
"(0(5(6()())(4()(9()())))(7(1()())(3()())))",
"0010",
"kjtdgmy"};
int param1[] = {2,3,1,2,4,100,3,0,12,97};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | { | [
"a) )",
"b) (",
"c) {",
"d) )",
"e) +"
] | 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);}
unsigned int f_gold ( unsigned int n ) {
int res = 1, i;
for ( i = 2;
i <= n;
i ++ ) res *= i;
return res;
}
unsigned int f_filled ( unsigned int n ) {}
arr, n, sizeof(int), cmpfunc);}
unsigned int f_gold ( unsigned int n ) {
int res = 1, i;
for ( i = 2;
i <= n;
i ++ ) res *= i;
return res;
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {15,7,16,67,71,16,77,27,37,73};
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) { [MASK] (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 ) { int res = 1, i; for ( i = 2; i <= n; i ++ ) res *= i; return res; } unsigned int f_filled ( unsigned int n ) {}arr, n, sizeof(int), cmpfunc);}
unsigned int f_gold ( unsigned int n ) {
int res = 1, i;
for ( i = 2;
i <= n;
i ++ ) res *= i;
return res;
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {15,7,16,67,71,16,77,27,37,73};
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) return",
"b) bool",
"c) -",
"d) *",
"e) void"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n, int a [ ] ) {
int res = 0;
for ( int i = 0;
i < 2 * n;
i ++ ) {
if ( i % 2 == 0 ) res += a [ i ] * a [ i ];
else res -= a [ i ] * a [ i ];
}
return res;
}
int f_filled ( int n, int a [ ] ) {}
int res = 0;
for ( int i = 0;
i < 2 * n;
i ++ ) {
if ( i % 2 == 0 ) res += a [ i ] * a [ i ];
else res -= a [ i ] * a [ i ];
}
return res;
}
int f_filled ( int n, int a [ ] ) {}
int main(void) {
int n_success = 0;
int param0[] = {22,18,18,11,21,26,6,1,13,11};
int param1_0[] = {4,4,5,11,13,14,19,20,25,25,26,33,34,37,43,44,44,45,47,48,50,50,60,61,64,65,71,73,79,80,83,85,87,90,95,96,98};
int param1_1[] = {-16,-38,-68,52,-92,76,94,-28,62,-26,38,-14,66,80,-70,52,-84,64,80,-36};
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};
int param1_3[] = {11,35,61,21,61,26,27,93,95,77,5,33,94,67};
int param1_4[] = {-96,-90,-64,-60,-52,-50,-42,-36,-30,-16,-8,-8,-4,18,20,22,24,34,52,54,58,64,74,78,80,86,88,96};
int param1_5[] = {0,0,1,0,1,1,1,1,1,0,1,0,0,0,0,1,1,1,0,1,0,0,1,0,0,0,1,0,0,0,1,1,1,0,0,1,0,0,1,1,0};
int param1_6[] = {4,28,35,42,44,58,64,69,72,76,90};
int param1_7[] = {-44,-34};
int param1_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param1_9[] = {83,48,93,25,25,35,39,34,98,80,22,14,48,64,77,87,56,27,33,15,81};
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> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n, int a [ ] ) { int res = 0; for ( int i = 0; i < 2 * n; i ++ ) { if ( i % 2 == 0 ) res += a [ i ] * a [ i ]; else res -= a [ i ] * a [ i ]; } return res; } int f_filled ( [MASK] n, int a [ ] ) {}int res = 0;
for ( int i = 0;
i < 2 * n;
i ++ ) {
if ( i % 2 == 0 ) res += a [ i ] * a [ i ];
else res -= a [ i ] * a [ i ];
}
return res;
}
int f_filled ( int n, int a [ ] ) {}
int main(void) {
int n_success = 0;
int param0[] = {22,18,18,11,21,26,6,1,13,11};
int param1_0[] = {4,4,5,11,13,14,19,20,25,25,26,33,34,37,43,44,44,45,47,48,50,50,60,61,64,65,71,73,79,80,83,85,87,90,95,96,98};
int param1_1[] = {-16,-38,-68,52,-92,76,94,-28,62,-26,38,-14,66,80,-70,52,-84,64,80,-36};
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};
int param1_3[] = {11,35,61,21,61,26,27,93,95,77,5,33,94,67};
int param1_4[] = {-96,-90,-64,-60,-52,-50,-42,-36,-30,-16,-8,-8,-4,18,20,22,24,34,52,54,58,64,74,78,80,86,88,96};
int param1_5[] = {0,0,1,0,1,1,1,1,1,0,1,0,0,0,0,1,1,1,0,1,0,0,1,0,0,0,1,0,0,0,1,1,1,0,0,1,0,0,1,1,0};
int param1_6[] = {4,28,35,42,44,58,64,69,72,76,90};
int param1_7[] = {-44,-34};
int param1_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param1_9[] = {83,48,93,25,25,35,39,34,98,80,22,14,48,64,77,87,56,27,33,15,81};
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) public",
"b) int",
"c) &&",
"d) ==",
"e) count"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int ans = 0;
for ( int i = 1;
i <= n;
i ++ ) for ( int j = 1;
j <= n;
j ++ ) ans += ( i / j );
return ans;
}
int f_filled ( int n ) {}
izeof(int), cmpfunc);}
int f_gold ( int n ) {
int ans = 0;
for ( int i = 1;
i <= n;
i ++ ) for ( int j = 1;
j <= n;
j ++ ) ans += ( i / j );
return ans;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {60,74,8,74,34,66,96,11,45,72};
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 ans = 0; for ( int i = 1; i <= n; i ++ ) for ( int j = 1; j <= n; j ++ ) ans += ( i / j ); return [MASK] } int f_filled ( int n ) {}izeof(int), cmpfunc);}
int f_gold ( int n ) {
int ans = 0;
for ( int i = 1;
i <= n;
i ++ ) for ( int j = 1;
j <= n;
j ++ ) ans += ( i / j );
return ans;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {60,74,8,74,34,66,96,11,45,72};
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;
} | ans; | [
"a) sort",
"b) False",
"c) if",
"d) ans;",
"e) ]"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b ) {
if ( b == 0 ) return 1;
int answer = a;
int increment = a;
int i, j;
for ( i = 1;
i < b;
i ++ ) {
for ( j = 1;
j < a;
j ++ ) {
answer += increment;
}
increment = answer;
}
return answer;
}
int f_filled ( int a, int b ) {}
i, j;
for ( i = 1;
i < b;
i ++ ) {
for ( j = 1;
j < a;
j ++ ) {
answer += increment;
}
increment = answer;
}
return answer;
}
int f_filled ( int a, int b ) {}
int main(void) {
int n_success = 0;
int param0[] = {66,82,12,55,34,22,13,57,76,76};
int param1[] = {4,66,38,33,26,23,98,84,94,95};
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) [MASK] sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int a, int b ) { if ( b == 0 ) return 1; int answer = a; int increment = a; int i, j; for ( i = 1; i < b; i ++ ) { for ( j = 1; j < a; j ++ ) { answer += increment; } increment = answer; } return answer; } int f_filled ( int a, int b ) {} i, j;
for ( i = 1;
i < b;
i ++ ) {
for ( j = 1;
j < a;
j ++ ) {
answer += increment;
}
increment = answer;
}
return answer;
}
int f_filled ( int a, int b ) {}
int main(void) {
int n_success = 0;
int param0[] = {66,82,12,55,34,22,13,57,76,76};
int param1[] = {4,66,38,33,26,23,98,84,94,95};
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) std;",
"e) )"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b, int k ) {
int c1 = ( b - a ) - 1;
int c2 = ( k - b ) + ( a - 1 );
if ( c1 == c2 ) return 0;
return min ( c1, c2 );
}
int f_filled ( int a, int b, int k ) {}
;}
int f_gold ( int a, int b, int k ) {
int c1 = ( b - a ) - 1;
int c2 = ( k - b ) + ( a - 1 );
if ( c1 == c2 ) return 0;
return min ( c1, c2 );
}
int f_filled ( int a, int b, int k ) {}
int main(void) {
int n_success = 0;
int param0[] = {83,3,11,50,40,62,40,66,6,25};
int param1[] = {98,39,96,67,16,86,78,11,9,5};
int param2[] = {86,87,30,48,32,76,71,74,19,5};
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 k ) { int c1 = ( b - a ) - 1; int c2 = ( k - b ) + ( a - 1 ); if ( c1 == c2 ) return 0; [MASK] min ( c1, c2 ); } int f_filled ( int a, int b, int k ) {};}
int f_gold ( int a, int b, int k ) {
int c1 = ( b - a ) - 1;
int c2 = ( k - b ) + ( a - 1 );
if ( c1 == c2 ) return 0;
return min ( c1, c2 );
}
int f_filled ( int a, int b, int k ) {}
int main(void) {
int n_success = 0;
int param0[] = {83,3,11,50,40,62,40,66,6,25};
int param1[] = {98,39,96,67,16,86,78,11,9,5};
int param2[] = {86,87,30,48,32,76,71,74,19,5};
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;
} | return | [
"a) 1",
"b) (",
"c) ,",
"d) java.util.stream.*;",
"e) return"
] | 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 result = 0;
set < int > Hash;
for ( int i = 0;
i < n;
i ++ ) Hash . insert ( arr [ i ] );
for ( int i = 0;
i < n;
i ++ ) {
for ( int j = i + 1;
j < n;
j ++ ) {
int product = arr [ i ] * arr [ j ];
if ( Hash . find ( product ) != Hash . end ( ) ) result ++;
}
}
return result;
}
int f_filled ( int arr [ ], int n ) {}
< n;
j ++ ) {
int product = arr [ i ] * arr [ j ];
if ( Hash . find ( product ) != Hash . end ( ) ) result ++;
}
}
return result;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,10,17,17,18,20,27,28,29,29,31,32,41,43,45,46,63,66,69,69,70,75,87,95};
int param0_1[] = {-60};
int param0_2[] = {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {52,83,36,57,93,11,32,91,52};
int param0_4[] = {-98,-94,-90,-88,-76,-76,-64,-62,-60,-50,-46,-32,-24,-22,-20,-16,-4,-2,6,10,20,28,30,32,34,38,40,42,54,64,72,76,82,82,86,92,92,98,98};
int param0_5[] = {0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,0,0,1,0,1,1,1,0,1,1,0};
int param0_6[] = {2,3,10,12,15,23,26,28,29,30,31,31,33,33,35,41,45,48,50,50,53,53,56,65,66,67,68,68,72,72,75,76,79,82,90,94,94,95,97,99};
int param0_7[] = {14,36,-54,-54};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1};
int param0_9[] = {5,69,37,80,21,98,70,70,74,95,6,67,44,55,52,89,84,99,65,52};
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,0,9,8,22,42,35,3,12,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 (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int result = 0; set < int > Hash; for ( int i = 0; [MASK] < n; i ++ ) Hash . insert ( arr [ i ] ); for ( int i = 0; i < n; i ++ ) { for ( int j = i + 1; j < n; j ++ ) { int product = arr [ i ] * arr [ j ]; if ( Hash . find ( product ) != Hash . end ( ) ) result ++; } } return result; } int f_filled ( int arr [ ], int n ) {} < n;
j ++ ) {
int product = arr [ i ] * arr [ j ];
if ( Hash . find ( product ) != Hash . end ( ) ) result ++;
}
}
return result;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,10,17,17,18,20,27,28,29,29,31,32,41,43,45,46,63,66,69,69,70,75,87,95};
int param0_1[] = {-60};
int param0_2[] = {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {52,83,36,57,93,11,32,91,52};
int param0_4[] = {-98,-94,-90,-88,-76,-76,-64,-62,-60,-50,-46,-32,-24,-22,-20,-16,-4,-2,6,10,20,28,30,32,34,38,40,42,54,64,72,76,82,82,86,92,92,98,98};
int param0_5[] = {0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,0,0,1,0,1,1,1,0,1,1,0};
int param0_6[] = {2,3,10,12,15,23,26,28,29,30,31,31,33,33,35,41,45,48,50,50,53,53,56,65,66,67,68,68,72,72,75,76,79,82,90,94,94,95,97,99};
int param0_7[] = {14,36,-54,-54};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1};
int param0_9[] = {5,69,37,80,21,98,70,70,74,95,6,67,44,55,52,89,84,99,65,52};
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,0,9,8,22,42,35,3,12,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;
} | i | [
"a) return",
"b) 1",
"c) return",
"d) (",
"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 ) {
return n * ( n - 1 );
}
int f_filled ( int n ) {}
eturn ((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 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {30,25,69,39,14,60,89,27,29,29};
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 [MASK] x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 ); } int f_filled ( int n ) {}eturn ((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 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {30,25,69,39,14,60,89,27,29,29};
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;
} | max(int | [
"a) &",
"b) (",
"c) max(int",
"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 a [ ], int n ) {
int mn = INT_MAX;
int sum = 0;
for ( int i = 0;
i < n;
i ++ ) {
mn = min ( a [ i ], mn );
sum += a [ i ];
}
return mn * ( sum - mn );
}
int f_filled ( int a [ ], int n ) {}
int mn = INT_MAX;
int sum = 0;
for ( int i = 0;
i < n;
i ++ ) {
mn = min ( a [ i ], mn );
sum += a [ i ];
}
return mn * ( sum - mn );
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,8,14,15,17,17,19,21,22,23,29,32,36,37,43,45,46,47,47,53,57,57,70,71,72,76,81,82,90,95,96,98,99};
int param0_1[] = {94,-18,50,94,-74,-50,-44,-92,-58,14,-66,-78};
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,1,1,1,1,1,1};
int param0_3[] = {15,18,64,28};
int param0_4[] = {-96,-88,-88,-84,-82,-78,-78,-60,-58,-56,-54,-52,-48,-44,-28,-26,-14,-12,6,10,10,14,14,50,52,54,60,62,62,64,66,70,72,72,78,80,84};
int param0_5[] = {0,1,1,0,1,1,1,1};
int param0_6[] = {3,10,14,14,15,16,18,20,21,30,31,33,35,39,46,48,59,59,61,77,78,79,81,83,85,92,97,97,99};
int param0_7[] = {4,-32,68,-48,54,24,78,98,-70,44,-82,-92,-16,-92,-70,52,-58,-62,-58,32,14,-4,80,-78,-26,-24,-8};
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};
int param0_9[] = {82,74,53,91,81,88,42,62,38,43,29,60,43,44,19,28,20,1,5,94,18,77,52,38,55,1,10,29,34,91,64,80,81,39,4,47,30,62,58,66,73,52,62,9,36,49};
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,10,24,2,31,6,23,18,35,38};
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 [MASK] x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 mn = INT_MAX; int sum = 0; for ( int i = 0; i < n; i ++ ) { mn = min ( a [ i ], mn ); sum += a [ i ]; } return mn * ( sum - mn ); } int f_filled ( int a [ ], int n ) {}
int mn = INT_MAX;
int sum = 0;
for ( int i = 0;
i < n;
i ++ ) {
mn = min ( a [ i ], mn );
sum += a [ i ];
}
return mn * ( sum - mn );
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,8,14,15,17,17,19,21,22,23,29,32,36,37,43,45,46,47,47,53,57,57,70,71,72,76,81,82,90,95,96,98,99};
int param0_1[] = {94,-18,50,94,-74,-50,-44,-92,-58,14,-66,-78};
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,1,1,1,1,1,1};
int param0_3[] = {15,18,64,28};
int param0_4[] = {-96,-88,-88,-84,-82,-78,-78,-60,-58,-56,-54,-52,-48,-44,-28,-26,-14,-12,6,10,10,14,14,50,52,54,60,62,62,64,66,70,72,72,78,80,84};
int param0_5[] = {0,1,1,0,1,1,1,1};
int param0_6[] = {3,10,14,14,15,16,18,20,21,30,31,33,35,39,46,48,59,59,61,77,78,79,81,83,85,92,97,97,99};
int param0_7[] = {4,-32,68,-48,54,24,78,98,-70,44,-82,-92,-16,-92,-70,52,-58,-62,-58,32,14,-4,80,-78,-26,-24,-8};
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};
int param0_9[] = {82,74,53,91,81,88,42,62,38,43,29,60,43,44,19,28,20,1,5,94,18,77,52,38,55,1,10,29,34,91,64,80,81,39,4,47,30,62,58,66,73,52,62,9,36,49};
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,10,24,2,31,6,23,18,35,38};
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;
} | max(int | [
"a) ;",
"b) max(int",
"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 l, int r, int x ) {
if ( r < l ) return - 1;
if ( arr [ l ] == x ) return l;
if ( arr [ r ] == x ) return r;
return f_gold ( arr, l + 1, r - 1, x );
}
int f_filled ( int arr [ ], int l, int r, int x ) {}
) {
if ( r < l ) return - 1;
if ( arr [ l ] == x ) return l;
if ( arr [ r ] == x ) return r;
return f_gold ( arr, l + 1, r - 1, x );
}
int f_filled ( int arr [ ], int l, int r, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {10,74,3};
int param0_1[] = {-90,72,36,96,42,0,-66,4};
int param0_2[] = {0};
int param0_3[] = {99,70,67,5};
int param0_4[] = {-98,-98,-26,-26,-24,-18,-16,80,5};
int param0_5[] = {1,1,1,1,0,1,0};
int param0_6[] = {1,5,12,12,17,17,12,95,96,98,4};
int param0_7[] = {50,-70,-30,-54,6,-10,70,84,5};
int param0_8[] = {0,1,5};
int param0_9[] = {59,21,28,3,14,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[] = {0,0,0,0,0,0,0,0,0,0};
int param2[] = {2,7,1,3,8,6,10,8,2,5};
int param3[] = {1,96,-1,3,80,1,12,27,14,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 [MASK] x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 ) return - 1; if ( arr [ l ] == x ) return l; if ( arr [ r ] == x ) return r; return f_gold ( arr, l + 1, r - 1, x ); } int f_filled ( int arr [ ], int l, int r, int x ) {}) {
if ( r < l ) return - 1;
if ( arr [ l ] == x ) return l;
if ( arr [ r ] == x ) return r;
return f_gold ( arr, l + 1, r - 1, x );
}
int f_filled ( int arr [ ], int l, int r, int x ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {10,74,3};
int param0_1[] = {-90,72,36,96,42,0,-66,4};
int param0_2[] = {0};
int param0_3[] = {99,70,67,5};
int param0_4[] = {-98,-98,-26,-26,-24,-18,-16,80,5};
int param0_5[] = {1,1,1,1,0,1,0};
int param0_6[] = {1,5,12,12,17,17,12,95,96,98,4};
int param0_7[] = {50,-70,-30,-54,6,-10,70,84,5};
int param0_8[] = {0,1,5};
int param0_9[] = {59,21,28,3,14,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[] = {0,0,0,0,0,0,0,0,0,0};
int param2[] = {2,7,1,3,8,6,10,8,2,5};
int param3[] = {1,96,-1,3,80,1,12,27,14,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;
} | max(int | [
"a) )",
"b) return",
"c) (",
"d) ;",
"e) max(int"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n, int k ) {
int max = * max_element ( arr, arr + n );
int res = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( ( max - arr [ i ] ) % k != 0 ) return - 1;
else res += ( max - arr [ i ] ) / k;
}
return res;
}
int f_filled ( int arr [ ], int n, int k ) {}
for ( int i = 0;
i < n;
i ++ ) {
if ( ( max - arr [ i ] ) % k != 0 ) return - 1;
else res += ( max - arr [ i ] ) / k;
}
return res;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {16};
int param0_1[] = {4,4,4,4,4};
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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {85,36,52,8,52,15,16};
int param0_4[] = {-10,-5,-5,-20,10,30};
int param0_5[] = {0,1,0,0,1,1,1,0,0,0,0,1,1,0,0,1,0};
int param0_6[] = {1,5,5,9,11,12,12,13,13,14,16,18,26,26,28,28,30,31,32,37,37,38,40,43,44,45,47,47,55,58,60,62,63,64,69,78,83,84,92,96,96,99};
int param0_7[] = {76,-78,92,-98,16,44,86,96,-8,2,-96,74,-28,12,54,-40,-64,-12,4,48,68,-82,8,0,-4,88,48,-54,90,62,-84,76,-48,62,-80,-94,38,-4,36};
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,1,1,1};
int param0_9[] = {62,99,29,23,55,30,79,63,1,88,59,8,11,80,23,51,97,32,80,48,84,36,73,59,1,34,92,10};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {4,5,39,5,6,10,26,34,39,18};
int param2[] = {3,3,1,6,5,15,33,3,10,1};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 max = * max_element ( arr, arr + n ); int res = 0; for ( int i [MASK] 0; i < n; i ++ ) { if ( ( max - arr [ i ] ) % k != 0 ) return - 1; else res += ( max - arr [ i ] ) / k; } return res; } int f_filled ( int arr [ ], int n, int k ) {}for ( int i = 0;
i < n;
i ++ ) {
if ( ( max - arr [ i ] ) % k != 0 ) return - 1;
else res += ( max - arr [ i ] ) / k;
}
return res;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {16};
int param0_1[] = {4,4,4,4,4};
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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {85,36,52,8,52,15,16};
int param0_4[] = {-10,-5,-5,-20,10,30};
int param0_5[] = {0,1,0,0,1,1,1,0,0,0,0,1,1,0,0,1,0};
int param0_6[] = {1,5,5,9,11,12,12,13,13,14,16,18,26,26,28,28,30,31,32,37,37,38,40,43,44,45,47,47,55,58,60,62,63,64,69,78,83,84,92,96,96,99};
int param0_7[] = {76,-78,92,-98,16,44,86,96,-8,2,-96,74,-28,12,54,-40,-64,-12,4,48,68,-82,8,0,-4,88,48,-54,90,62,-84,76,-48,62,-80,-94,38,-4,36};
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,1,1,1};
int param0_9[] = {62,99,29,23,55,30,79,63,1,88,59,8,11,80,23,51,97,32,80,48,84,36,73,59,1,34,92,10};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {4,5,39,5,6,10,26,34,39,18};
int param2[] = {3,3,1,6,5,15,33,3,10,1};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | = | [
"a) if",
"b) =",
"c) ],",
"d) #include",
"e) useOdd"
] | 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 ) {
return ( 1 << n );
}
int f_filled ( int n ) {}
{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 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {48,42,15,75,23,41,46,99,36,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 * [MASK] {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { return ( 1 << n ); } int f_filled ( int n ) {} {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 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {48,42,15,75,23,41,46,99,36,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;
} | b) | [
"a) #include",
"b) +=",
"c) \"a\";",
"d) [",
"e) b)"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int n ) {
if ( n == 0 ) return 0;
while ( n != 1 ) {
if ( n % 2 != 0 ) return 0;
n = n / 2;
}
return 1;
}
bool f_filled ( int n ) {}
arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int n ) {
if ( n == 0 ) return 0;
while ( n != 1 ) {
if ( n % 2 != 0 ) return 0;
n = n / 2;
}
return 1;
}
bool f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,2,8,1024,24,7,46,61,73,66};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len [MASK] 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 ) return 0; while ( n != 1 ) { if ( n % 2 != 0 ) return 0; n = n / 2; } return 1; } bool f_filled ( int n ) {}arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int n ) {
if ( n == 0 ) return 0;
while ( n != 1 ) {
if ( n % 2 != 0 ) return 0;
n = n / 2;
}
return 1;
}
bool f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,2,8,1024,24,7,46,61,73,66};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | (int | [
"a) arr",
"b) (",
"c) =",
"d) 1",
"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 b, int c ) {
int x = a - b;
int y = b - c;
int z = a - c;
if ( x * y > 0 ) return b;
else if ( x * z > 0 ) return c;
else return a;
}
int f_filled ( int a, int b, int c ) {}
nt a, int b, int c ) {
int x = a - b;
int y = b - c;
int z = a - c;
if ( x * y > 0 ) return b;
else if ( x * z > 0 ) return c;
else return a;
}
int f_filled ( int a, int b, int c ) {}
int main(void) {
int n_success = 0;
int param0[] = {48,21,71,93,3,58,88,8,17,13};
int param1[] = {46,7,4,34,61,78,41,84,66,3};
int param2[] = {38,16,31,11,32,6,66,38,27,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 a, int b, int c ) { int x = a - b; int y = b - c; int z = a [MASK] c; if ( x * y > 0 ) return b; else if ( x * z > 0 ) return c; else return a; } int f_filled ( int a, int b, int c ) {}nt a, int b, int c ) {
int x = a - b;
int y = b - c;
int z = a - c;
if ( x * y > 0 ) return b;
else if ( x * z > 0 ) return c;
else return a;
}
int f_filled ( int a, int b, int c ) {}
int main(void) {
int n_success = 0;
int param0[] = {48,21,71,93,3,58,88,8,17,13};
int param1[] = {46,7,4,34,61,78,41,84,66,3};
int param2[] = {38,16,31,11,32,6,66,38,27,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) cmpfunc",
"b) :",
"c) -",
"d) 1;",
"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 count = 0;
for ( int i = 5;
n / i >= 1;
i *= 5 ) count += n / i;
return count;
}
int f_filled ( int n ) {}
], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int count = 0;
for ( int i = 5;
n / i >= 1;
i *= 5 ) count += n / i;
return count;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {9,43,50,32,37,51,33,49,1,75};
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 [MASK] (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 i = 5; n / i >= 1; i *= 5 ) count += n / i; return count; } int f_filled ( int n ) {} ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int count = 0;
for ( int i = 5;
n / i >= 1;
i *= 5 ) count += n / i;
return count;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {9,43,50,32,37,51,33,49,1,75};
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) count",
"b) ((int)",
"c) yCount",
"d) );",
"e) max(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 n ) {
return 1 + n * ( n + 1 ) / 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 1 + n * ( n + 1 ) / 2;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {46,68,4,12,56,14,81,29,26,40};
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 ) { return 1 + n * ( n + [MASK] ) / 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 1 + n * ( n + 1 ) / 2;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {46,68,4,12,56,14,81,29,26,40};
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;
} | 1 | [
"a) int",
"b) <=",
"c) <",
"d) (arr)",
"e) 1"
] | 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 [], int n ) {
char reverseAlphabet [] = "zyxwvutsrqponmlkjihgfedcba";
int l = strlen(str);
for ( int i = n;
i < l;
i ++ ) str [ i ] = reverseAlphabet [ str [ i ] - 'a' ];
return str;
}
char f_filled [] ( char str [], int n ) {}
yxwvutsrqponmlkjihgfedcba";
int l = strlen(str);
for ( int i = n;
i < l;
i ++ ) str [ i ] = reverseAlphabet [ str [ i ] - 'a' ];
return str;
}
char f_filled [] ( char str [], int n ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"oncL","678","1000101101100","J","533740","000101","hZ","368838","011101","pMFMw"};
int param1[] = {17,38,78,37,55,77,3,11,88,89};
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, [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);} char f_gold [] ( char str [], int n ) { char reverseAlphabet [] = "zyxwvutsrqponmlkjihgfedcba"; int l = strlen(str); for ( int i = n; i < l; i ++ ) str [ i ] = reverseAlphabet [ str [ i ] - 'a' ]; return str; } char f_filled [] ( char str [], int n ) {}yxwvutsrqponmlkjihgfedcba";
int l = strlen(str);
for ( int i = n;
i < l;
i ++ ) str [ i ] = reverseAlphabet [ str [ i ] - 'a' ];
return str;
}
char f_filled [] ( char str [], int n ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"oncL","678","1000101101100","J","533740","000101","hZ","368838","011101","pMFMw"};
int param1[] = {17,38,78,37,55,77,3,11,88,89};
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) f_gold(k):",
"b) >",
"c) <limits.h>",
"d) x",
"e) int"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n, int m ) {
int count [ n + 1 ];
count [ 0 ] = 0;
for ( int i = 1;
i <= n;
i ++ ) {
if ( i > m ) count [ i ] = count [ i - 1 ] + count [ i - m ];
else if ( i < m ) count [ i ] = 1;
else count [ i ] = 2;
}
return count [ n ];
}
int f_filled ( int n, int m ) {}
) {
if ( i > m ) count [ i ] = count [ i - 1 ] + count [ i - m ];
else if ( i < m ) count [ i ] = 1;
else count [ i ] = 2;
}
return count [ n ];
}
int f_filled ( int n, int m ) {}
int main(void) {
int n_success = 0;
int param0[] = {93,17,38,33,78,40,95,12,69,78};
int param1[] = {54,4,39,64,35,61,6,8,60,21};
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 m ) { int count [ n + 1 ]; count [ 0 ] = 0; for ( int i = 1; i <= n; i ++ ) { if ( i > m ) count [ i ] = count [ i - 1 ] + count [ i - m ]; else if ( i < m ) count [ i ] = 1; else count [ i ] = 2; } return count [ n ]; } int f_filled ( int n, int m ) [MASK]) {
if ( i > m ) count [ i ] = count [ i - 1 ] + count [ i - m ];
else if ( i < m ) count [ i ] = 1;
else count [ i ] = 2;
}
return count [ n ];
}
int f_filled ( int n, int m ) {}
int main(void) {
int n_success = 0;
int param0[] = {93,17,38,33,78,40,95,12,69,78};
int param1[] = {54,4,39,64,35,61,6,8,60,21};
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) thi",
"c) {}",
"d) import",
"e) ["
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( char str [] ) {
int i = 0, j = strlen(str) - 1;
while ( i < j ) {
if ( str [ i ] != str [ j ] ) return false;
i ++;
j --;
}
return true;
}
bool f_filled ( char str [] ) {}
d ( char str [] ) {
int i = 0, j = strlen(str) - 1;
while ( i < j ) {
if ( str [ i ] != str [ j ] ) return false;
i ++;
j --;
}
return true;
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"ab","303","11110000","aba","404","10101","abab","6366","001",""};
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 [MASK] int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 i = 0, j = strlen(str) - 1; while ( i < j ) { if ( str [ i ] != str [ j ] ) return false; i ++; j --; } return true; } bool f_filled ( char str [] ) {}d ( char str [] ) {
int i = 0, j = strlen(str) - 1;
while ( i < j ) {
if ( str [ i ] != str [ j ] ) return false;
i ++;
j --;
}
return true;
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"ab","303","11110000","aba","404","10101","abab","6366","001",""};
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) x,",
"c) ],",
"d) return",
"e) arr"
] | 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 num = n;
int dec_value = 0;
int base = 1;
int temp = num;
while ( temp ) {
int last_digit = temp % 10;
temp = temp / 10;
dec_value += last_digit * base;
base = base * 8;
}
return dec_value;
}
int f_filled ( int n ) {}
t temp = num;
while ( temp ) {
int last_digit = temp % 10;
temp = temp / 10;
dec_value += last_digit * base;
base = base * 8;
}
return dec_value;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {37,25,63,66,32,5,41,82,54,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) [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 n ) { int num = n; int dec_value = 0; int base = 1; int temp = num; while ( temp ) { int last_digit = temp % 10; temp = temp / 10; dec_value += last_digit * base; base = base * 8; } return dec_value; } int f_filled ( int n ) {}t temp = num;
while ( temp ) {
int last_digit = temp % 10;
temp = temp / 10;
dec_value += last_digit * base;
base = base * 8;
}
return dec_value;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {37,25,63,66,32,5,41,82,54,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;
} | { | [
"a) (",
"b) return",
"c) {",
"d) positive",
"e) -"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int a [ ], int n ) {
int count_odd = 0, count_even = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( a [ i ] & 1 ) count_odd ++;
else count_even ++;
}
if ( count_odd % 2 && count_even % 2 ) return false;
else return true;
}
bool f_filled ( int a [ ], int n ) {}
< n;
i ++ ) {
if ( a [ i ] & 1 ) count_odd ++;
else count_even ++;
}
if ( count_odd % 2 && count_even % 2 ) return false;
else return true;
}
bool f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,1,7,7,8,10,10,10,14,15,18,20,23,24,24,26,30,32,32,33,36,42,43,46,48,51,51,52,53,58,58,59,59,59,60,67,71,72,74,76,77,83,84,86,90,91};
int param0_1[] = {-90,-20,-60,-64,-24,84,-2,-32,28,-54,44,-96,52,88,20,-56,-2};
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};
int param0_3[] = {98,70,24,18,7,4,78,19,70,56,99,54,69,15,88,20,40,13,19,56,62};
int param0_4[] = {-72,-66,-58,-20,36,80,92};
int param0_5[] = {0,1};
int param0_6[] = {6,13,14,16,21,26,26,28,29,35,38,42,47,47,62,67,77,81,81,83,84,88,90,96,97,98};
int param0_7[] = {-48,-8,20,32,-90,-42,-6,-88,-72,42,66,-62,82,-4,8,12,-22,82,56,96,-54,92,-42,30,-18,14,-6,-66,34,16,-84,-94,48,-48,52,-60,-92,-16};
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};
int param0_9[] = {45,86,53,80,27,45,1,85,91,93,92,43,75,86,81,48,21,34,5,10,88,42,7,15,96,85,62,86,52,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[] = {30,12,36,19,6,1,17,35,14,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);} bool f_gold ( int a [ ], int n ) { int count_odd = 0, count_even = 0; for ( int i = 0; i [MASK] n; i ++ ) { if ( a [ i ] & 1 ) count_odd ++; else count_even ++; } if ( count_odd % 2 && count_even % 2 ) return false; else return true; } bool f_filled ( int a [ ], int n ) {}< n;
i ++ ) {
if ( a [ i ] & 1 ) count_odd ++;
else count_even ++;
}
if ( count_odd % 2 && count_even % 2 ) return false;
else return true;
}
bool f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,1,7,7,8,10,10,10,14,15,18,20,23,24,24,26,30,32,32,33,36,42,43,46,48,51,51,52,53,58,58,59,59,59,60,67,71,72,74,76,77,83,84,86,90,91};
int param0_1[] = {-90,-20,-60,-64,-24,84,-2,-32,28,-54,44,-96,52,88,20,-56,-2};
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};
int param0_3[] = {98,70,24,18,7,4,78,19,70,56,99,54,69,15,88,20,40,13,19,56,62};
int param0_4[] = {-72,-66,-58,-20,36,80,92};
int param0_5[] = {0,1};
int param0_6[] = {6,13,14,16,21,26,26,28,29,35,38,42,47,47,62,67,77,81,81,83,84,88,90,96,97,98};
int param0_7[] = {-48,-8,20,32,-90,-42,-6,-88,-72,42,66,-62,82,-4,8,12,-22,82,56,96,-54,92,-42,30,-18,14,-6,-66,34,16,-84,-94,48,-48,52,-60,-92,-16};
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};
int param0_9[] = {45,86,53,80,27,45,1,85,91,93,92,43,75,86,81,48,21,34,5,10,88,42,7,15,96,85,62,86,52,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[] = {30,12,36,19,6,1,17,35,14,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;
} | < | [
"a) #include",
"b) j",
"c) <",
"d) max",
"e) (x"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
unsigned int f_gold ( unsigned int n ) {
unsigned int count = 0;
while ( n ) {
count += n & 1;
n >>= 1;
}
return count;
}
unsigned int f_filled ( unsigned int n ) {}
, cmpfunc);}
unsigned int f_gold ( unsigned int n ) {
unsigned int count = 0;
while ( n ) {
count += n & 1;
n >>= 1;
}
return count;
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {58,92,73,52,24,14,58,11,8,52};
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 int count = 0; while [MASK] n ) { count += n & 1; n >>= 1; } return count; } unsigned int f_filled ( unsigned int n ) {}, cmpfunc);}
unsigned int f_gold ( unsigned int n ) {
unsigned int count = 0;
while ( n ) {
count += n & 1;
n >>= 1;
}
return count;
}
unsigned int f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {58,92,73,52,24,14,58,11,8,52};
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) max(int",
"b) (",
"c) d",
"d) n;",
"e) f2"
] | 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 ) {
unordered_set < int > s;
int j = 0, ans = 0;
for ( int i = 0;
i < n;
i ++ ) {
while ( j < n && s . find ( arr [ j ] ) == s . end ( ) ) {
s . insert ( arr [ j ] );
j ++;
}
ans += ( ( j - i ) * ( j - i + 1 ) ) / 2;
s . erase ( arr [ i ] );
}
return ans;
}
int f_filled ( int arr [ ], int n ) {}
end ( ) ) {
s . insert ( arr [ j ] );
j ++;
}
ans += ( ( j - i ) * ( j - i + 1 ) ) / 2;
s . erase ( arr [ i ] );
}
return ans;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,4,5,6,12,15,16,17,20,20,22,24,24,27,28,34,37,39,39,41,43,49,49,51,55,62,63,67,71,74,74,74,77,84,84,89,89,97,99};
int param0_1[] = {-8,54,-22,18,20,44,0,54,90,-4,4,40,-74,-16};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {36,71,36,58,38,90,17};
int param0_4[] = {-90,-32,-16,18,38,82};
int param0_5[] = {1,0,1};
int param0_6[] = {3,11,21,25,28,28,38,42,48,53,55,55,55,58,71,75,79,80,80,94,96,99};
int param0_7[] = {-16,-52,-4,-46,54,0,8,-64,-82,-10,-62,-10,58,44,-28,86,-24,16,44,22,-28,-42,-52,8,76,-44,-34,2,88,-88,-14,-84,-36,-68,76,20,20,-50};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {19,13,61,32,92,90,12,81,52};
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[] = {24,13,28,4,5,2,20,35,27,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);} int f_gold ( int arr [ ], int [MASK] ) { unordered_set < int > s; int j = 0, ans = 0; for ( int i = 0; i < n; i ++ ) { while ( j < n && s . find ( arr [ j ] ) == s . end ( ) ) { s . insert ( arr [ j ] ); j ++; } ans += ( ( j - i ) * ( j - i + 1 ) ) / 2; s . erase ( arr [ i ] ); } return ans; } int f_filled ( int arr [ ], int n ) {}end ( ) ) {
s . insert ( arr [ j ] );
j ++;
}
ans += ( ( j - i ) * ( j - i + 1 ) ) / 2;
s . erase ( arr [ i ] );
}
return ans;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,4,5,6,12,15,16,17,20,20,22,24,24,27,28,34,37,39,39,41,43,49,49,51,55,62,63,67,71,74,74,74,77,84,84,89,89,97,99};
int param0_1[] = {-8,54,-22,18,20,44,0,54,90,-4,4,40,-74,-16};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {36,71,36,58,38,90,17};
int param0_4[] = {-90,-32,-16,18,38,82};
int param0_5[] = {1,0,1};
int param0_6[] = {3,11,21,25,28,28,38,42,48,53,55,55,55,58,71,75,79,80,80,94,96,99};
int param0_7[] = {-16,-52,-4,-46,54,0,8,-64,-82,-10,-62,-10,58,44,-28,86,-24,16,44,22,-28,-42,-52,8,76,-44,-34,2,88,-88,-14,-84,-36,-68,76,20,20,-50};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {19,13,61,32,92,90,12,81,52};
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[] = {24,13,28,4,5,2,20,35,27,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;
} | n | [
"a) =",
"b) 1",
"c) n",
"d) for",
"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 ) {
int result = INT_MAX;
sort ( arr, arr + n );
for ( int i = 0;
i <= n - k;
i ++ ) result = min ( result, arr [ i + k - 1 ] - arr [ i ] );
return result;
}
int f_filled ( int arr [ ], int n, int k ) {}
NT_MAX;
sort ( arr, arr + n );
for ( int i = 0;
i <= n - k;
i ++ ) result = min ( result, arr [ i + k - 1 ] - arr [ i ] );
return result;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,2,7,8,14,16,20,20,23,24,24,29,30,32,34,35,37,38,43,44,46,50,52,55,57,61,71,79,86,86,89,91,91,95};
int param0_1[] = {78,-4,76,0,-62,54,-70,62,90,-80,-68,90,-34,-66,-46,34,-18,-74,-66,34,34,-28,6,80,58,-50,-60,54,8,-52,-60,68,42,16,42,72,54,88,44,46,84,-34};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {32};
int param0_4[] = {-96,-78,-76,-72,-72,-70,-54,-46,-40,-34,-30,-26,-24,-22,-18,-16,-6,-4,-4,2,6,14,16,18,30,30,36,54,54,58,66,72,78,80,80,82,88,98};
int param0_5[] = {0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,1,0,1,0,1,1,1,0,0,0,0,1,1,0,1,1,0,1,1,0,0,1};
int param0_6[] = {3,13,14,18,23,32,67,72,75,76,87,95};
int param0_7[] = {8,30};
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};
int param0_9[] = {31,15,19,41,73,29,67,36,87,74,95,27,36,83,37,33,30,86,94,93,9,42,3,95,3,69,67,63,16,53,35,52,2,57,57,25,21,7,72,52,78,40};
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,33,8,0,26,39,10,1,27,36};
int param2[] = {17,33,13,0,25,41,8,1,33,37};
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 arr [ ], int n, int k ) { int result = INT_MAX; sort ( arr, arr + n ); for ( int i = 0; i <= n - k; i ++ ) result = min ( result, arr [ i + k - 1 ] - arr [ i ] ); return result; } int f_filled ( int arr [ ], int n, int k ) {}NT_MAX;
sort ( arr, arr + n );
for ( int i = 0;
i <= n - k;
i ++ ) result = min ( result, arr [ i + k - 1 ] - arr [ i ] );
return result;
}
int f_filled ( int arr [ ], int n, int k ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,1,2,7,8,14,16,20,20,23,24,24,29,30,32,34,35,37,38,43,44,46,50,52,55,57,61,71,79,86,86,89,91,91,95};
int param0_1[] = {78,-4,76,0,-62,54,-70,62,90,-80,-68,90,-34,-66,-46,34,-18,-74,-66,34,34,-28,6,80,58,-50,-60,54,8,-52,-60,68,42,16,42,72,54,88,44,46,84,-34};
int param0_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param0_3[] = {32};
int param0_4[] = {-96,-78,-76,-72,-72,-70,-54,-46,-40,-34,-30,-26,-24,-22,-18,-16,-6,-4,-4,2,6,14,16,18,30,30,36,54,54,58,66,72,78,80,80,82,88,98};
int param0_5[] = {0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,1,0,1,0,1,1,1,0,0,0,0,1,1,0,1,1,0,1,1,0,0,1};
int param0_6[] = {3,13,14,18,23,32,67,72,75,76,87,95};
int param0_7[] = {8,30};
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};
int param0_9[] = {31,15,19,41,73,29,67,36,87,74,95,27,36,83,37,33,30,86,94,93,9,42,3,95,3,69,67,63,16,53,35,52,2,57,57,25,21,7,72,52,78,40};
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,33,8,0,26,39,10,1,27,36};
int param2[] = {17,33,13,0,25,41,8,1,33,37};
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) :",
"b) y)",
"c) )",
"d) d",
"e) ;"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n, int x ) {
int i;
for ( i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == x ) return i;
}
return - 1;
}
int f_filled ( int arr [ ], int n, int x ) {}
nc);}
int f_gold ( int arr [ ], int n, int x ) {
int i;
for ( 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[] = {4,5,5,11,13,14,15,19,22,22,23,26,29,29,36,44,48,49,65,65,67,68,70,76,79,79,81,85,88,91,91,92,92,97};
int param0_1[] = {-24,-78,-32,-48,0,4,-42};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1};
int param0_3[] = {38,14,75,16,91,11,98,43,67,9,21,10,82,72,32,81,48,60,2,91,10,90,12,83};
int param0_4[] = {-92,-92,-82,-80,-76,-66,-64,-64,-56,-48,-38,-38,-34,-32,-32,-10,-8,-6,-2,0,8,10,18,20,22,22,30,34,38,38,38,44,50,52,56,64,64,66,70,76,88};
int param0_5[] = {0,1,1,0,0,1,1,0,0,0,1,1,1,1};
int param0_6[] = {1,4,4,4,4,8,12,13,14,14,22,25,25,27,29,33,36,38,40,40,40,41,47,47,47,48,48,50,51,52,52,52,55,56,59,59,62,64,66,77,82,84,90,91,91,93};
int param0_7[] = {-90,-60,-58,-72,92,54,-32,-70,-94,18,64,-90,-90,-56,82,-14,-74,-96,-90,-8,-48,76,-28,10,-52,-8,-46,-32,82,46,58,92,4,48,-96,-66,60,60,62,-68};
int param0_8[] = {0,0,0,0,0,0,1,1,1,1};
int param0_9[] = {42,17,77,96,72,36,74,97,7,94,80,7,27,58,49,81,51,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[] = {17,4,6,17,25,11,38,22,8,16};
int param2[] = {5,0,0,75,25,-1,4,22,8,11};
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) / [MASK] (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n, int x ) { int i; for ( i = 0; i < n; i ++ ) { if ( arr [ i ] == x ) return i; } return - 1; } int f_filled ( int arr [ ], int n, int x ) {}nc);}
int f_gold ( int arr [ ], int n, int x ) {
int i;
for ( 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[] = {4,5,5,11,13,14,15,19,22,22,23,26,29,29,36,44,48,49,65,65,67,68,70,76,79,79,81,85,88,91,91,92,92,97};
int param0_1[] = {-24,-78,-32,-48,0,4,-42};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1};
int param0_3[] = {38,14,75,16,91,11,98,43,67,9,21,10,82,72,32,81,48,60,2,91,10,90,12,83};
int param0_4[] = {-92,-92,-82,-80,-76,-66,-64,-64,-56,-48,-38,-38,-34,-32,-32,-10,-8,-6,-2,0,8,10,18,20,22,22,30,34,38,38,38,44,50,52,56,64,64,66,70,76,88};
int param0_5[] = {0,1,1,0,0,1,1,0,0,0,1,1,1,1};
int param0_6[] = {1,4,4,4,4,8,12,13,14,14,22,25,25,27,29,33,36,38,40,40,40,41,47,47,47,48,48,50,51,52,52,52,55,56,59,59,62,64,66,77,82,84,90,91,91,93};
int param0_7[] = {-90,-60,-58,-72,92,54,-32,-70,-94,18,64,-90,-90,-56,82,-14,-74,-96,-90,-8,-48,76,-28,10,-52,-8,-46,-32,82,46,58,92,4,48,-96,-66,60,60,62,-68};
int param0_8[] = {0,0,0,0,0,0,1,1,1,1};
int param0_9[] = {42,17,77,96,72,36,74,97,7,94,80,7,27,58,49,81,51,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[] = {17,4,6,17,25,11,38,22,8,16};
int param2[] = {5,0,0,75,25,-1,4,22,8,11};
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 | [
"a) 1",
"b) sizeof",
"c) );",
"d) 0",
"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 res = 0;
for ( int i = 0;
i < n - 1;
i ++ ) res = res ^ ( i + 1 ) ^ arr [ i ];
res = res ^ arr [ n - 1 ];
return res;
}
int f_filled ( int arr [ ], int n ) {}
t arr [ ], int n ) {
int res = 0;
for ( int i = 0;
i < n - 1;
i ++ ) res = res ^ ( i + 1 ) ^ arr [ i ];
res = res ^ arr [ n - 1 ];
return res;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,2,4,5,5,7,7,7,8,11,14,15,18,19,20,25,25,29,29,31,32,32,33,38,42,48,52,55,60,61,63,71,74,78,82,82,84,84,87,87,88,90,93,94,94};
int param0_1[] = {46,2,62,60,92,4,26,66,66,90,26,-14,76,-20,-68};
int param0_2[] = {0,0,0,1,1,1,1,1};
int param0_3[] = {87,67,11,47,64,81,94,75,58,77,18,2,85,26,6,44,55,19,46,49,5,69,44,12,42,66,46,9,26,49,68,95,6,9,11,72,5,67};
int param0_4[] = {-98,-94,-92,-82,-78,-64,-62,-58,-52,-44,-40,-38,-8,6,10,20,22,28,30,30,36,54,54,58,64,68,76,78,84,88,90,94,96};
int param0_5[] = {1,0,0,1,1,0,0,0,1,0,0,0,1,1,1,0,1,0,1,0,0,0,0,0,1,1};
int param0_6[] = {1,14,15,15,21,34,38,39,41,50,60,74,96,97};
int param0_7[] = {96,-12,-16,-52};
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[] = {66,21,21,59,78,8,46,41,16,32,97,93,32,86,91,61,67,61,97,49,66,35,24,35,65,45,83};
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,8,4,34,29,17,7,3,21,25};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a [MASK] *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int res = 0; for ( int i = 0; i < n - 1; i ++ ) res = res ^ ( i + 1 ) ^ arr [ i ]; res = res ^ arr [ n - 1 ]; return res; } int f_filled ( int arr [ ], int n ) {}t arr [ ], int n ) {
int res = 0;
for ( int i = 0;
i < n - 1;
i ++ ) res = res ^ ( i + 1 ) ^ arr [ i ];
res = res ^ arr [ n - 1 ];
return res;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {2,2,4,5,5,7,7,7,8,11,14,15,18,19,20,25,25,29,29,31,32,32,33,38,42,48,52,55,60,61,63,71,74,78,82,82,84,84,87,87,88,90,93,94,94};
int param0_1[] = {46,2,62,60,92,4,26,66,66,90,26,-14,76,-20,-68};
int param0_2[] = {0,0,0,1,1,1,1,1};
int param0_3[] = {87,67,11,47,64,81,94,75,58,77,18,2,85,26,6,44,55,19,46,49,5,69,44,12,42,66,46,9,26,49,68,95,6,9,11,72,5,67};
int param0_4[] = {-98,-94,-92,-82,-78,-64,-62,-58,-52,-44,-40,-38,-8,6,10,20,22,28,30,30,36,54,54,58,64,68,76,78,84,88,90,94,96};
int param0_5[] = {1,0,0,1,1,0,0,0,1,0,0,0,1,1,1,0,1,0,1,0,0,0,0,0,1,1};
int param0_6[] = {1,14,15,15,21,34,38,39,41,50,60,74,96,97};
int param0_7[] = {96,-12,-16,-52};
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[] = {66,21,21,59,78,8,46,41,16,32,97,93,32,86,91,61,67,61,97,49,66,35,24,35,65,45,83};
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,8,4,34,29,17,7,3,21,25};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | - | [
"a) int",
"b) namespace",
"c) for",
"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 ( char expr [] ) {
int len = strlen(expr);
if ( len % 2 ) return - 1;
stack < char > s;
for ( int i = 0;
i < len;
i ++ ) {
if ( expr [ i ] == '}' && ! s . empty ( ) ) {
if ( s . top ( ) == '{' ) s . pop ( );
else s . push ( expr [ i ] );
}
else s . push ( expr [ i ] );
}
int red_len = len(s);
int n = 0;
while ( ! s . empty ( ) && s . top ( ) == '{' ) {
s . pop ( );
n ++;
}
return ( red_len / 2 + n % 2 );
}
int f_filled ( char expr [] ) {}
);
}
int red_len = len(s);
int n = 0;
while ( ! s . empty ( ) && s . top ( ) == '{' ) {
s . pop ( );
n ++;
}
return ( red_len / 2 + n % 2 );
}
int f_filled ( char expr [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"}{","{{{","{{{{","{{{{}}","}{{}}{{{","{}","","8","01111000","XPkERzHcpId"};
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 ( [MASK] - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char expr [] ) { int len = strlen(expr); if ( len % 2 ) return - 1; stack < char > s; for ( int i = 0; i < len; i ++ ) { if ( expr [ i ] == '}' && ! s . empty ( ) ) { if ( s . top ( ) == '{' ) s . pop ( ); else s . push ( expr [ i ] ); } else s . push ( expr [ i ] ); } int red_len = len(s); int n = 0; while ( ! s . empty ( ) && s . top ( ) == '{' ) { s . pop ( ); n ++; } return ( red_len / 2 + n % 2 ); } int f_filled ( char expr [] ) {});
}
int red_len = len(s);
int n = 0;
while ( ! s . empty ( ) && s . top ( ) == '{' ) {
s . pop ( );
n ++;
}
return ( red_len / 2 + n % 2 );
}
int f_filled ( char expr [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"}{","{{{","{{{{","{{{{}}","}{{}}{{{","{}","","8","01111000","XPkERzHcpId"};
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) 0",
"c) =",
"d) for",
"e) *(int*)a"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
long f_gold ( int f, int d, int s ) {
long mem [ d + 1 ] [ s + 1 ];
memset ( mem, 0, sizeof mem );
mem [ 0 ] [ 0 ] = 1;
for ( int i = 1;
i <= d;
i ++ ) {
for ( int j = i;
j <= s;
j ++ ) {
mem [ i ] [ j ] = mem [ i ] [ j - 1 ] + mem [ i - 1 ] [ j - 1 ];
if ( j - f - 1 >= 0 ) mem [ i ] [ j ] -= mem [ i - 1 ] [ j - f - 1 ];
}
}
return mem [ d ] [ s ];
}
long f_filled ( int f, int d, int s ) {}
i ] [ j - 1 ] + mem [ i - 1 ] [ j - 1 ];
if ( j - f - 1 >= 0 ) mem [ i ] [ j ] -= mem [ i - 1 ] [ j - f - 1 ];
}
}
return mem [ d ] [ s ];
}
long f_filled ( int f, int d, int s ) {}
int main(void) {
int n_success = 0;
int param0[] = {57,58,38,5,91,76,38,97,97,99};
int param1[] = {5,45,89,39,90,56,43,26,90,2};
int param2[] = {33,4,9,30,47,46,84,52,90,26};
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);} long f_gold ( int f, int d, int s ) { long mem [ d + 1 ] [ s + 1 ]; memset ( mem, 0, sizeof mem ); mem [ 0 ] [ 0 ] = 1; for ( int i = 1; i <= d; i ++ ) { for ( int j = i; j [MASK] s; j ++ ) { mem [ i ] [ j ] = mem [ i ] [ j - 1 ] + mem [ i - 1 ] [ j - 1 ]; if ( j - f - 1 >= 0 ) mem [ i ] [ j ] -= mem [ i - 1 ] [ j - f - 1 ]; } } return mem [ d ] [ s ]; } long f_filled ( int f, int d, int s ) {}i ] [ j - 1 ] + mem [ i - 1 ] [ j - 1 ];
if ( j - f - 1 >= 0 ) mem [ i ] [ j ] -= mem [ i - 1 ] [ j - f - 1 ];
}
}
return mem [ d ] [ s ];
}
long f_filled ( int f, int d, int s ) {}
int main(void) {
int n_success = 0;
int param0[] = {57,58,38,5,91,76,38,97,97,99};
int param1[] = {5,45,89,39,90,56,43,26,90,2};
int param2[] = {33,4,9,30,47,46,84,52,90,26};
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) 1",
"c) )",
"d) <string>",
"e) <="
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int sum = 0;
for ( int i = 1;
i <= n;
++ i ) sum += ( n / i ) * i;
return sum;
}
int f_filled ( int n ) {}
rr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int sum = 0;
for ( int i = 1;
i <= n;
++ i ) sum += ( n / i ) * i;
return sum;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {73,41,36,28,49,24,85,59,82,40};
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; for ( int i = 1; i <= n; ++ i ) sum += ( n / i ) * i; return sum; } int f_filled ( int n ) {}rr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int n ) {
int sum = 0;
for ( int i = 1;
i <= n;
++ i ) sum += ( n / i ) * i;
return sum;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {73,41,36,28,49,24,85,59,82,40};
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) namespace",
"b) return",
"c) ]",
"d) ;",
"e) ])"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
char f_gold [] ( char X [], char Y [] ) {
int m = strlen(X);
int n = strlen(Y);
int dp [ m + 1 ] [ n + 1 ];
for ( int i = 0;
i <= m;
i ++ ) {
for ( int j = 0;
j <= n;
j ++ ) {
if ( i == 0 ) dp [ i ] [ j ] = j;
else if ( j == 0 ) dp [ i ] [ j ] = i;
else if ( X [ i - 1 ] == Y [ j - 1 ] ) dp [ i ] [ j ] = 1 + dp [ i - 1 ] [ j - 1 ];
else dp [ i ] [ j ] = 1 + min ( dp [ i - 1 ] [ j ], dp [ i ] [ j - 1 ] );
}
}
int index = dp [ m ] [ n ];
char str [];
int i = m, j = n;
while ( i > 0 && j > 0 ) {
if ( X [ i - 1 ] == Y [ j - 1 ] ) {
str . push_back ( X [ i - 1 ] );
i --, j --, index --;
}
else if ( dp [ i - 1 ] [ j ] > dp [ i ] [ j - 1 ] ) {
str . push_back ( Y [ j - 1 ] );
j --, index --;
}
else {
str . push_back ( X [ i - 1 ] );
i --, index --;
}
}
while ( i > 0 ) {
str . push_back ( X [ i - 1 ] );
i --, index --;
}
while ( j > 0 ) {
str . push_back ( Y [ j - 1 ] );
j --, index --;
}
reverse ( str . begin ( ), str . end ( ) );
return str;
}
char f_filled [] ( char X [], char Y [] ) {}
--;
}
while ( j > 0 ) {
str . push_back ( Y [ j - 1 ] );
j --, index --;
}
reverse ( str . begin ( ), str . end ( ) );
return str;
}
char f_filled [] ( char X [], char Y [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"TDqjbbdzRkA","1071","0","yqLp","22508607","11000010","fcOw","0089872133806","000010000110","aeQVc"};
char param1[][100] = {"Y","6273318333","100","oXDzdBmOmTHkM","736179592","01001","muMFduA","73","0011111100","fWZsG"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], [MASK] n) {qsort (arr, n, sizeof(int), cmpfunc);} char f_gold [] ( char X [], char Y [] ) { int m = strlen(X); int n = strlen(Y); int dp [ m + 1 ] [ n + 1 ]; for ( int i = 0; i <= m; i ++ ) { for ( int j = 0; j <= n; j ++ ) { if ( i == 0 ) dp [ i ] [ j ] = j; else if ( j == 0 ) dp [ i ] [ j ] = i; else if ( X [ i - 1 ] == Y [ j - 1 ] ) dp [ i ] [ j ] = 1 + dp [ i - 1 ] [ j - 1 ]; else dp [ i ] [ j ] = 1 + min ( dp [ i - 1 ] [ j ], dp [ i ] [ j - 1 ] ); } } int index = dp [ m ] [ n ]; char str []; int i = m, j = n; while ( i > 0 && j > 0 ) { if ( X [ i - 1 ] == Y [ j - 1 ] ) { str . push_back ( X [ i - 1 ] ); i --, j --, index --; } else if ( dp [ i - 1 ] [ j ] > dp [ i ] [ j - 1 ] ) { str . push_back ( Y [ j - 1 ] ); j --, index --; } else { str . push_back ( X [ i - 1 ] ); i --, index --; } } while ( i > 0 ) { str . push_back ( X [ i - 1 ] ); i --, index --; } while ( j > 0 ) { str . push_back ( Y [ j - 1 ] ); j --, index --; } reverse ( str . begin ( ), str . end ( ) ); return str; } char f_filled [] ( char X [], char Y [] ) {}--;
}
while ( j > 0 ) {
str . push_back ( Y [ j - 1 ] );
j --, index --;
}
reverse ( str . begin ( ), str . end ( ) );
return str;
}
char f_filled [] ( char X [], char Y [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"TDqjbbdzRkA","1071","0","yqLp","22508607","11000010","fcOw","0089872133806","000010000110","aeQVc"};
char param1[][100] = {"Y","6273318333","100","oXDzdBmOmTHkM","736179592","01001","muMFduA","73","0011111100","fWZsG"};
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) mat",
"b) int",
"c) )",
"d) )",
"e) arr"
] | 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;
for ( int i = 0;
i < m;
i ++ ) for ( int j = 0;
j < n;
j ++ ) if ( ( arr1 [ i ] + arr2 [ j ] ) == x ) count ++;
return count;
}
int f_filled ( int arr1 [ ], int arr2 [ ], int m, int n, int x ) {}
i = 0;
i < m;
i ++ ) for ( int j = 0;
j < n;
j ++ ) if ( ( arr1 [ i ] + arr2 [ j ] ) == x ) 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[] = {11,13,16,23,26,28,31,34,37,39,44,48,56,59,79,91,96,98};
int param0_1[] = {50,14,-98,14,90,36,66,44,10,-98,-24,-36,-32,-50};
int param0_2[] = {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {88,14,29,87,86,58};
int param0_4[] = {-98,-92,-88,-86,-82,-76,-72,-66,-56,-48,-34,-28,-28,-26,-20,-18,-18,-16,-16,-12,-4,0,6,12,16,20,22,30,34,34,36,56,58,62,64,80,82,94};
int param0_5[] = {1,1,1,1,0,1,1,0,0,0,1,1,1,1,1,0,0,0,1,0,0,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,1,0,1,1,1,0,0};
int param0_6[] = {70,70,74};
int param0_7[] = {-20,-12,-50,76,24,64,-22,-4,-68};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {68,75,51,45,73,95,48,53,70,41,65,47,46,43,79,29,50};
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[] = {1,1,9,14,17,23,26,31,33,36,53,60,71,75,76,84,87,88};
int param1_1[] = {34,-6,-66,0,-6,82,60,-98,-8,60,-2,4,22,76};
int param1_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param1_3[] = {91,95,64,4,63,35};
int param1_4[] = {-94,-90,-88,-84,-82,-78,-76,-72,-70,-58,-58,-46,-42,-40,-40,-32,-22,-20,-18,-12,-8,-6,6,6,18,20,34,46,60,62,66,72,72,76,76,78,92,98};
int param1_5[] = {1,0,1,1,0,0,1,0,1,0,1,0,1,0,0,0,1,1,0,1,1,0,1,1,1,0,1,0,1,0,1,0,0,0,0,1,0,1,1,0,1,0,0,1,0,0};
int param1_6[] = {15,55,84};
int param1_7[] = {18,98,-88,86,72,-44,82,94,58};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {4,6,76,65,16,13,85,43,31,14,81,90,24,87,40,25,88};
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[] = {9,11,14,3,34,39,1,5,27,10};
int param3[] = {15,12,9,5,32,26,1,4,26,10};
int param4[] = {11,8,12,5,23,34,1,7,37,9};
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; for ( int i = 0; i [MASK] m; i ++ ) for ( int j = 0; j < n; j ++ ) if ( ( arr1 [ i ] + arr2 [ j ] ) == x ) count ++; return count; } int f_filled ( int arr1 [ ], int arr2 [ ], int m, int n, int x ) {}i = 0;
i < m;
i ++ ) for ( int j = 0;
j < n;
j ++ ) if ( ( arr1 [ i ] + arr2 [ j ] ) == x ) 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[] = {11,13,16,23,26,28,31,34,37,39,44,48,56,59,79,91,96,98};
int param0_1[] = {50,14,-98,14,90,36,66,44,10,-98,-24,-36,-32,-50};
int param0_2[] = {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {88,14,29,87,86,58};
int param0_4[] = {-98,-92,-88,-86,-82,-76,-72,-66,-56,-48,-34,-28,-28,-26,-20,-18,-18,-16,-16,-12,-4,0,6,12,16,20,22,30,34,34,36,56,58,62,64,80,82,94};
int param0_5[] = {1,1,1,1,0,1,1,0,0,0,1,1,1,1,1,0,0,0,1,0,0,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,1,0,1,1,1,0,0};
int param0_6[] = {70,70,74};
int param0_7[] = {-20,-12,-50,76,24,64,-22,-4,-68};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {68,75,51,45,73,95,48,53,70,41,65,47,46,43,79,29,50};
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[] = {1,1,9,14,17,23,26,31,33,36,53,60,71,75,76,84,87,88};
int param1_1[] = {34,-6,-66,0,-6,82,60,-98,-8,60,-2,4,22,76};
int param1_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param1_3[] = {91,95,64,4,63,35};
int param1_4[] = {-94,-90,-88,-84,-82,-78,-76,-72,-70,-58,-58,-46,-42,-40,-40,-32,-22,-20,-18,-12,-8,-6,6,6,18,20,34,46,60,62,66,72,72,76,76,78,92,98};
int param1_5[] = {1,0,1,1,0,0,1,0,1,0,1,0,1,0,0,0,1,1,0,1,1,0,1,1,1,0,1,0,1,0,1,0,0,0,0,1,0,1,1,0,1,0,0,1,0,0};
int param1_6[] = {15,55,84};
int param1_7[] = {18,98,-88,86,72,-44,82,94,58};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {4,6,76,65,16,13,85,43,31,14,81,90,24,87,40,25,88};
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[] = {9,11,14,3,34,39,1,5,27,10};
int param3[] = {15,12,9,5,32,26,1,4,26,10};
int param4[] = {11,8,12,5,23,34,1,7,37,9};
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) (const",
"c) (int",
"d) +=",
"e) max"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int a1 [ ], int a2 [ ], int a3 [ ], int n1, int n2, int n3, int sum ) {
for ( int i = 0;
i < n1;
i ++ ) for ( int j = 0;
j < n2;
j ++ ) for ( int k = 0;
k < n3;
k ++ ) if ( a1 [ i ] + a2 [ j ] + a3 [ k ] == sum ) return true;
return false;
}
bool f_filled ( int a1 [ ], int a2 [ ], int a3 [ ], int n1, int n2, int n3, int sum ) {}
int k = 0;
k < n3;
k ++ ) if ( a1 [ i ] + a2 [ j ] + a3 [ k ] == sum ) return true;
return false;
}
bool f_filled ( int a1 [ ], int a2 [ ], int a3 [ ], int n1, int n2, int n3, int sum ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,9,10,19,24,25,26,30,36,43,44,49,52,62,66,69,72,77,80,80,82,84,90,93,94,98};
int param0_1[] = {-24,-80,-72,80,-96,-94,64,18,12,16,74,16,54,66,-96,-90,54,72,-32,-2,90,-18,-98,12,-42,-30,-82,-56,-86,40};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {28,15,21,28,85,68,24};
int param0_4[] = {-86,-82,-66,-44,-44,-38,-22,-6,-2,14,26,40,54,58,60,66,72,80,94,96,98};
int param0_5[] = {1,1,1,0,1,1,1,0,0,1,1,1,1,0,1,1,0,0,0,1,1,0,0,0,1,0,1,1,1,0,0,1,0,1};
int param0_6[] = {44,53,85,85,86,88,93};
int param0_7[] = {70,-38,62,-34,74,-32,-58,-34,-54};
int param0_8[] = {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {41,64,39,96,54,54,57,4,82,43,44,56,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[] = {4,8,17,20,22,25,27,30,31,33,35,35,38,41,49,51,60,61,66,67,69,82,84,85,86,88};
int param1_1[] = {30,-60,-24,18,40,44,-40,62,66,-38,50,-74,-42,-86,-82,-8,50,-72,-2,-48,-38,-20,-8,56,-32,68,94,80,-48,0};
int param1_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param1_3[] = {57,46,47,49,16,81,60};
int param1_4[] = {-96,-86,-74,-56,-52,-42,-32,-22,-16,-10,-4,-4,10,42,48,52,58,62,84,90,96};
int param1_5[] = {0,1,1,1,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,1,1,0,1,1,0,1,0,1};
int param1_6[] = {4,5,8,15,29,40,91};
int param1_7[] = {48,-86,-18,14,88,92,-56,-8,-74};
int param1_8[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param1_9[] = {44,58,40,87,22,82,8,81,88,42,15,14,81};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2_0[] = {12,14,17,20,22,27,29,31,32,38,41,43,56,59,59,64,66,67,68,69,71,76,83,83,85,99};
int param2_1[] = {-24,80,50,-56,-92,20,86,-42,-30,96,40,-32,-64,54,-38,-72,-70,54,-28,98,60,98,-12,-30,-30,68,-66,68,-58,52};
int param2_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param2_3[] = {76,49,6,44,71,24,57};
int param2_4[] = {-92,-92,-90,-82,-62,-44,-42,-40,-38,-36,-22,-20,-8,12,22,26,30,44,54,64,86};
int param2_5[] = {1,0,1,0,0,0,1,1,1,0,1,1,1,0,0,0,1,1,0,0,1,1,1,0,1,0,0,0,0,1,1,1,0,0};
int param2_6[] = {30,53,71,75,76,82,84};
int param2_7[] = {8,8,32,76,76,94,22,-60,-42};
int param2_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param2_9[] = {64,20,24,42,37,46,6,47,12,93,8,5,11};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {25,26,14,6,13,25,5,6,15,7};
int param4[] = {18,22,14,5,20,25,3,6,14,8};
int param5[] = {16,20,14,5,17,23,4,6,10,6};
int param6[] = {222,21,2,73,6,0,3,7,13,10};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i],param4[i],param5[i],param6[i]) == f_gold(param0[i],param1[i],param2[i],param3[i],param4[i],param5[i],param6[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) [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);} bool f_gold ( int a1 [ ], int a2 [ ], int a3 [ ], int n1, int n2, int n3, int sum ) { for ( int i = 0; i < n1; i ++ ) for ( int j = 0; j < n2; j ++ ) for ( int k = 0; k < n3; k ++ ) if ( a1 [ i ] + a2 [ j ] + a3 [ k ] == sum ) return true; return false; } bool f_filled ( int a1 [ ], int a2 [ ], int a3 [ ], int n1, int n2, int n3, int sum ) {} int k = 0;
k < n3;
k ++ ) if ( a1 [ i ] + a2 [ j ] + a3 [ k ] == sum ) return true;
return false;
}
bool f_filled ( int a1 [ ], int a2 [ ], int a3 [ ], int n1, int n2, int n3, int sum ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,9,10,19,24,25,26,30,36,43,44,49,52,62,66,69,72,77,80,80,82,84,90,93,94,98};
int param0_1[] = {-24,-80,-72,80,-96,-94,64,18,12,16,74,16,54,66,-96,-90,54,72,-32,-2,90,-18,-98,12,-42,-30,-82,-56,-86,40};
int param0_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {28,15,21,28,85,68,24};
int param0_4[] = {-86,-82,-66,-44,-44,-38,-22,-6,-2,14,26,40,54,58,60,66,72,80,94,96,98};
int param0_5[] = {1,1,1,0,1,1,1,0,0,1,1,1,1,0,1,1,0,0,0,1,1,0,0,0,1,0,1,1,1,0,0,1,0,1};
int param0_6[] = {44,53,85,85,86,88,93};
int param0_7[] = {70,-38,62,-34,74,-32,-58,-34,-54};
int param0_8[] = {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {41,64,39,96,54,54,57,4,82,43,44,56,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[] = {4,8,17,20,22,25,27,30,31,33,35,35,38,41,49,51,60,61,66,67,69,82,84,85,86,88};
int param1_1[] = {30,-60,-24,18,40,44,-40,62,66,-38,50,-74,-42,-86,-82,-8,50,-72,-2,-48,-38,-20,-8,56,-32,68,94,80,-48,0};
int param1_2[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param1_3[] = {57,46,47,49,16,81,60};
int param1_4[] = {-96,-86,-74,-56,-52,-42,-32,-22,-16,-10,-4,-4,10,42,48,52,58,62,84,90,96};
int param1_5[] = {0,1,1,1,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,1,1,0,1,1,0,1,0,1};
int param1_6[] = {4,5,8,15,29,40,91};
int param1_7[] = {48,-86,-18,14,88,92,-56,-8,-74};
int param1_8[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param1_9[] = {44,58,40,87,22,82,8,81,88,42,15,14,81};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2_0[] = {12,14,17,20,22,27,29,31,32,38,41,43,56,59,59,64,66,67,68,69,71,76,83,83,85,99};
int param2_1[] = {-24,80,50,-56,-92,20,86,-42,-30,96,40,-32,-64,54,-38,-72,-70,54,-28,98,60,98,-12,-30,-30,68,-66,68,-58,52};
int param2_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1};
int param2_3[] = {76,49,6,44,71,24,57};
int param2_4[] = {-92,-92,-90,-82,-62,-44,-42,-40,-38,-36,-22,-20,-8,12,22,26,30,44,54,64,86};
int param2_5[] = {1,0,1,0,0,0,1,1,1,0,1,1,1,0,0,0,1,1,0,0,1,1,1,0,1,0,0,0,0,1,1,1,0,0};
int param2_6[] = {30,53,71,75,76,82,84};
int param2_7[] = {8,8,32,76,76,94,22,-60,-42};
int param2_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1};
int param2_9[] = {64,20,24,42,37,46,6,47,12,93,8,5,11};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {25,26,14,6,13,25,5,6,15,7};
int param4[] = {18,22,14,5,20,25,3,6,14,8};
int param5[] = {16,20,14,5,17,23,4,6,10,6};
int param6[] = {222,21,2,73,6,0,3,7,13,10};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i],param4[i],param5[i],param6[i]) == f_gold(param0[i],param1[i],param2[i],param3[i],param4[i],param5[i],param6[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | {return | [
"a) %",
"b) a",
"c) {return",
"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 y ) {
int i = 0;
int min_dist = INT_MAX;
int prev;
for ( i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == x || arr [ i ] == y ) {
prev = i;
break;
}
}
for (;
i < n;
i ++ ) {
if ( arr [ i ] == x || arr [ i ] == y ) {
if ( arr [ prev ] != arr [ i ] && ( i - prev ) < min_dist ) {
min_dist = i - prev;
prev = i;
}
else prev = i;
}
}
return min_dist;
}
int f_filled ( int arr [ ], int n, int x, int y ) {}
i ] && ( i - prev ) < min_dist ) {
min_dist = i - prev;
prev = i;
}
else prev = i;
}
}
return min_dist;
}
int f_filled ( int arr [ ], int n, int x, int y ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,7,7,8,11,14,16,25,34,35,36,36,38,40,41,43,45,47,57,60,64,72,73,74,75,82,83,83,84,84,84,92};
int param0_1[] = {96,70,88,-64,-42,58,92,66,-14,90,-66,12,88,-12,48,-4,90,24,98,14,32,38,98,78,2,26,12,-36,90,80,40,58,88,64,16};
int param0_2[] = {0,0,1};
int param0_3[] = {46,96,82,73,30,36,56,20,5,36,4,7,89,63,54,97,80,56,93,34,90,56,25,27,75,68,14,90};
int param0_4[] = {-96,-88,-82,-66,-62,-52,-52,-46,-46,-40,-40,-28,-24,-12,0,4,10,24,42,46,48,48,50,60,62,64,64,70,92,98};
int param0_5[] = {0,0,1,0,1,1,0,1,1,1,1};
int param0_6[] = {1,2,2,6,10,14,15,18,19,22,23,29,30,37,40,40,41,41,42,42,44,46,46,54,56,72,73,81,83,83,86,88,93};
int param0_7[] = {46,86,-52,18,-32,86,2,38,72,72,-60,70,-58,66,-66,-72,-74,58,52,58,16,64,62,-62,80,-70,-96,-44,-20,-74,-10,14,-32,48,30,76,-16,80,66,-46,-92,26,-86,28,-76,-24,-98,54,50};
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[] = {32,65,10,72,17,58,79,28,67,36,18,35};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {22,25,1,26,24,10,27,30,38,7};
int param2[] = {7,58,1,54,0,0,1,25,0,10};
int param3[] = {40,70,1,82,4,1,42,45,0,7};
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 [ ], [MASK] n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n, int x, int y ) { int i = 0; int min_dist = INT_MAX; int prev; for ( i = 0; i < n; i ++ ) { if ( arr [ i ] == x || arr [ i ] == y ) { prev = i; break; } } for (; i < n; i ++ ) { if ( arr [ i ] == x || arr [ i ] == y ) { if ( arr [ prev ] != arr [ i ] && ( i - prev ) < min_dist ) { min_dist = i - prev; prev = i; } else prev = i; } } return min_dist; } int f_filled ( int arr [ ], int n, int x, int y ) {} i ] && ( i - prev ) < min_dist ) {
min_dist = i - prev;
prev = i;
}
else prev = i;
}
}
return min_dist;
}
int f_filled ( int arr [ ], int n, int x, int y ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,7,7,8,11,14,16,25,34,35,36,36,38,40,41,43,45,47,57,60,64,72,73,74,75,82,83,83,84,84,84,92};
int param0_1[] = {96,70,88,-64,-42,58,92,66,-14,90,-66,12,88,-12,48,-4,90,24,98,14,32,38,98,78,2,26,12,-36,90,80,40,58,88,64,16};
int param0_2[] = {0,0,1};
int param0_3[] = {46,96,82,73,30,36,56,20,5,36,4,7,89,63,54,97,80,56,93,34,90,56,25,27,75,68,14,90};
int param0_4[] = {-96,-88,-82,-66,-62,-52,-52,-46,-46,-40,-40,-28,-24,-12,0,4,10,24,42,46,48,48,50,60,62,64,64,70,92,98};
int param0_5[] = {0,0,1,0,1,1,0,1,1,1,1};
int param0_6[] = {1,2,2,6,10,14,15,18,19,22,23,29,30,37,40,40,41,41,42,42,44,46,46,54,56,72,73,81,83,83,86,88,93};
int param0_7[] = {46,86,-52,18,-32,86,2,38,72,72,-60,70,-58,66,-66,-72,-74,58,52,58,16,64,62,-62,80,-70,-96,-44,-20,-74,-10,14,-32,48,30,76,-16,80,66,-46,-92,26,-86,28,-76,-24,-98,54,50};
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[] = {32,65,10,72,17,58,79,28,67,36,18,35};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {22,25,1,26,24,10,27,30,38,7};
int param2[] = {7,58,1,54,0,0,1,25,0,10};
int param3[] = {40,70,1,82,4,1,42,45,0,7};
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) ==",
"b) int",
"c) ==",
"d) curr_rem",
"e) res;"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char S [], char T [] ) {
int m = strlen(T), n = strlen(S);
if ( m > n ) return 0;
int mat [ m + 1 ] [ n + 1 ];
for ( int i = 1;
i <= m;
i ++ ) mat [ i ] [ 0 ] = 0;
for ( int j = 0;
j <= n;
j ++ ) mat [ 0 ] [ j ] = 1;
for ( int i = 1;
i <= m;
i ++ ) {
for ( int j = 1;
j <= n;
j ++ ) {
if ( T [ i - 1 ] != S [ j - 1 ] ) mat [ i ] [ j ] = mat [ i ] [ j - 1 ];
else mat [ i ] [ j ] = mat [ i ] [ j - 1 ] + mat [ i - 1 ] [ j - 1 ];
}
}
return mat [ m ] [ n ];
}
int f_filled ( char S [], char T [] ) {}
) mat [ i ] [ j ] = mat [ i ] [ j - 1 ];
else mat [ i ] [ j ] = mat [ i ] [ j - 1 ] + mat [ i - 1 ] [ j - 1 ];
}
}
return mat [ m ] [ n ];
}
int f_filled ( char S [], char T [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"banana","49597223","1000010000011","BTlzufK","3474007","0010","dKHhoTD","9123259723","11001000111110","iY WJlIZ"};
char param1[][100] = {"ban","42","010","lf","370","00000","doT","123","0","iI"};
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 S [], char T [] ) { int m = strlen(T), n = strlen(S); if ( m > n ) return 0; int mat [ m + 1 ] [ n + 1 ]; for ( int i = 1; i <= m; i ++ ) mat [ i ] [ 0 ] = 0; for ( int j = 0; j <= n; j ++ ) mat [ 0 ] [ j ] = 1; for ( int i = 1; i <= m; i ++ ) { for ( int j = 1; j <= n; j ++ ) { if ( T [ i - 1 ] != S [ j - 1 ] ) mat [ i ] [ j ] = mat [ i ] [ j - 1 ]; else mat [ i ] [ j ] = mat [ i ] [ j - 1 ] + [MASK] [ i - 1 ] [ j - 1 ]; } } return mat [ m ] [ n ]; } int f_filled ( char S [], char T [] ) {}) mat [ i ] [ j ] = mat [ i ] [ j - 1 ];
else mat [ i ] [ j ] = mat [ i ] [ j - 1 ] + mat [ i - 1 ] [ j - 1 ];
}
}
return mat [ m ] [ n ];
}
int f_filled ( char S [], char T [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"banana","49597223","1000010000011","BTlzufK","3474007","0010","dKHhoTD","9123259723","11001000111110","iY WJlIZ"};
char param1[][100] = {"ban","42","010","lf","370","00000","doT","123","0","iI"};
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;
} | mat | [
"a) return",
"b) std;",
"c) j",
"d) (arr)[0]));}",
"e) mat"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( int A [ ], int arr_size, int sum ) {
int l, r;
sort ( A, A + arr_size );
for ( int i = 0;
i < arr_size - 2;
i ++ ) {
l = i + 1;
r = arr_size - 1;
while ( l < r ) {
if ( A [ i ] + A [ l ] + A [ r ] == sum ) {
printf ( "Triplet is %d, %d, %d", A [ i ], A [ l ], A [ r ] );
return true;
}
else if ( A [ i ] + A [ l ] + A [ r ] < sum ) l ++;
else r --;
}
}
return false;
}
bool f_filled ( int A [ ], int arr_size, int sum ) {}
[ r ] );
return true;
}
else if ( A [ i ] + A [ l ] + A [ r ] < sum ) l ++;
else r --;
}
}
return false;
}
bool f_filled ( int A [ ], int arr_size, int sum ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {28,47,65,89};
int param0_1[] = {-26,-64,-2,96,-52,-14,-56,52,-70,70,-64,74,-8,18,78,14,6,-16,50,84,-90,12,-88,52,52,-40,58,-48,98,-66,46,-88,68,12,0,70,-42};
int param0_2[] = {0};
int param0_3[] = {49,66,22,93,52,54,80,87};
int param0_4[] = {-96,-92,-86,-74,-62,-60,-56,-54,-46,-38,-32,-26,-16,-16,-8,-4,0,6,20,28,42,44,56};
int param0_5[] = {1,0,0,0,0,0,1,0,1,0,1,1,0,0,1,1,0,0,0,1,1,0,1,1,0,1,1,0,1,1,1,1,1,0,1,0,0,1,0,0,0,0,1};
int param0_6[] = {1,2,16,16,20,24,24,38,41,54,57,72,79,83,89,90,96,97,98};
int param0_7[] = {52,22,78,-30};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {72,40,92,11,98,20,4,58,49,11,58,28,16,16,44,10,50,23,83,41,41,92,1,28,26,83,6,52,48,9,77,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[] = {3,22,0,5,13,39,12,2,21,29};
int param2[] = {3,24,0,7,19,39,12,3,16,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) / [MASK] (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int A [ ], int arr_size, int sum ) { int l, r; sort ( A, A + arr_size ); for ( int i = 0; i < arr_size - 2; i ++ ) { l = i + 1; r = arr_size - 1; while ( l < r ) { if ( A [ i ] + A [ l ] + A [ r ] == sum ) { printf ( "Triplet is %d, %d, %d", A [ i ], A [ l ], A [ r ] ); return true; } else if ( A [ i ] + A [ l ] + A [ r ] < sum ) l ++; else r --; } } return false; } bool f_filled ( int A [ ], int arr_size, int sum ) {} [ r ] );
return true;
}
else if ( A [ i ] + A [ l ] + A [ r ] < sum ) l ++;
else r --;
}
}
return false;
}
bool f_filled ( int A [ ], int arr_size, int sum ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {28,47,65,89};
int param0_1[] = {-26,-64,-2,96,-52,-14,-56,52,-70,70,-64,74,-8,18,78,14,6,-16,50,84,-90,12,-88,52,52,-40,58,-48,98,-66,46,-88,68,12,0,70,-42};
int param0_2[] = {0};
int param0_3[] = {49,66,22,93,52,54,80,87};
int param0_4[] = {-96,-92,-86,-74,-62,-60,-56,-54,-46,-38,-32,-26,-16,-16,-8,-4,0,6,20,28,42,44,56};
int param0_5[] = {1,0,0,0,0,0,1,0,1,0,1,1,0,0,1,1,0,0,0,1,1,0,1,1,0,1,1,0,1,1,1,1,1,0,1,0,0,1,0,0,0,0,1};
int param0_6[] = {1,2,16,16,20,24,24,38,41,54,57,72,79,83,89,90,96,97,98};
int param0_7[] = {52,22,78,-30};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {72,40,92,11,98,20,4,58,49,11,58,28,16,16,44,10,50,23,83,41,41,92,1,28,26,83,6,52,48,9,77,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[] = {3,22,0,5,13,39,12,2,21,29};
int param2[] = {3,24,0,7,19,39,12,3,16,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;
} | sizeof | [
"a) *;",
"b) n",
"c) import",
"d) sizeof",
"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 i = 0;
int ans = 0;
while ( ( 1 << i ) <= n ) {
bool k = 0;
int change = 1 << i;
for ( int j = 0;
j <= n;
j ++ ) {
ans += k;
if ( change == 1 ) {
k = ! k;
change = 1 << i;
}
else {
change --;
}
}
i ++;
}
return ans;
}
int f_filled ( int n ) {}
ans += k;
if ( change == 1 ) {
k = ! k;
change = 1 << i;
}
else {
change --;
}
}
i ++;
}
return ans;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {90,56,43,31,77,35,43,66,15,95};
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 < [MASK] x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int n ) { int i = 0; int ans = 0; while ( ( 1 << i ) <= n ) { bool k = 0; int change = 1 << i; for ( int j = 0; j <= n; j ++ ) { ans += k; if ( change == 1 ) { k = ! k; change = 1 << i; } else { change --; } } i ++; } return ans; } int f_filled ( int n ) {}
ans += k;
if ( change == 1 ) {
k = ! k;
change = 1 << i;
}
else {
change --;
}
}
i ++;
}
return ans;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {90,56,43,31,77,35,43,66,15,95};
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) for",
"d) y)?",
"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);}
void f_gold ( int a [ ], int n ) {
unordered_map < int, int > count;
for ( int i = 0;
i < n;
i ++ ) count [ a [ i ] ] ++;
int next_missing = 1;
for ( int i = 0;
i < n;
i ++ ) {
if ( count [ a [ i ] ] != 1 || a [ i ] > n || a [ i ] < 1 ) {
count [ a [ i ] ] --;
while ( count . find ( next_missing ) != count . end ( ) ) next_missing ++;
a [ i ] = next_missing;
count [ next_missing ] = 1;
}
}
}
void f_filled ( int a [ ], int n ) {}
while ( count . find ( next_missing ) != count . end ( ) ) next_missing ++;
a [ i ] = next_missing;
count [ next_missing ] = 1;
}
}
}
void f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {19};
int param0_1[] = {-47,72};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {93,3,20,59,36,19,90,67,19,20,96,71,52,33,40,39};
int param0_4[] = {-98,-93,-91,-89,-63,-58,-52,-52,-46,-40,-25,-16,-10,-1,-1,4,12,12,13,13,16,20,29,29,31,40,44,47,48,51,52,52,59,60,61,64,66,78,85,97};
int param0_5[] = {0,1,1,1,1,1,1,0,1,0,0,1,0,1,0,1,0,1,1,1,1,1,0,0,0};
int param0_6[] = {4,6,8,17,19,21,22,24,27,27,28,30,30,30,32,33,35,37,38,44,46,46,48,49,51,53,54,59,60,61,63,64,64,69,76,85,86,87,92,93,93,95,97,97,97,98,99,99};
int param0_7[] = {-75,-46,-42,-33,4,74,-76,14,-68,75,-14,51,94,27,55,30,-83,4};
int param0_8[] = {0,0,0,0,0,1,1,1,1};
int param0_9[] = {24,13,60,7,57,36,45,20,65,8,16,14,76,87,15,92,98,66,32,87,63,86,51,25,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[] = {0,1,18,9,22,12,26,9,5,24};
int filled_function_param0_0[] = {19};
int filled_function_param0_1[] = {-47,72};
int filled_function_param0_2[] = {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_3[] = {93,3,20,59,36,19,90,67,19,20,96,71,52,33,40,39};
int filled_function_param0_4[] = {-98,-93,-91,-89,-63,-58,-52,-52,-46,-40,-25,-16,-10,-1,-1,4,12,12,13,13,16,20,29,29,31,40,44,47,48,51,52,52,59,60,61,64,66,78,85,97};
int filled_function_param0_5[] = {0,1,1,1,1,1,1,0,1,0,0,1,0,1,0,1,0,1,1,1,1,1,0,0,0};
int filled_function_param0_6[] = {4,6,8,17,19,21,22,24,27,27,28,30,30,30,32,33,35,37,38,44,46,46,48,49,51,53,54,59,60,61,63,64,64,69,76,85,86,87,92,93,93,95,97,97,97,98,99,99};
int filled_function_param0_7[] = {-75,-46,-42,-33,4,74,-76,14,-68,75,-14,51,94,27,55,30,-83,4};
int filled_function_param0_8[] = {0,0,0,0,0,1,1,1,1};
int filled_function_param0_9[] = {24,13,60,7,57,36,45,20,65,8,16,14,76,87,15,92,98,66,32,87,63,86,51,25,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[] = {0,1,18,9,22,12,26,9,5,24};
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 [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} void f_gold ( int a [ ], int n ) { unordered_map < int, int > count; for ( int i = 0; i < n; i ++ ) count [ a [ i ] [MASK] ++; int next_missing = 1; for ( int i = 0; i < n; i ++ ) { if ( count [ a [ i ] ] != 1 || a [ i ] > n || a [ i ] < 1 ) { count [ a [ i ] ] --; while ( count . find ( next_missing ) != count . end ( ) ) next_missing ++; a [ i ] = next_missing; count [ next_missing ] = 1; } } } void f_filled ( int a [ ], int n ) {} while ( count . find ( next_missing ) != count . end ( ) ) next_missing ++;
a [ i ] = next_missing;
count [ next_missing ] = 1;
}
}
}
void f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {19};
int param0_1[] = {-47,72};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {93,3,20,59,36,19,90,67,19,20,96,71,52,33,40,39};
int param0_4[] = {-98,-93,-91,-89,-63,-58,-52,-52,-46,-40,-25,-16,-10,-1,-1,4,12,12,13,13,16,20,29,29,31,40,44,47,48,51,52,52,59,60,61,64,66,78,85,97};
int param0_5[] = {0,1,1,1,1,1,1,0,1,0,0,1,0,1,0,1,0,1,1,1,1,1,0,0,0};
int param0_6[] = {4,6,8,17,19,21,22,24,27,27,28,30,30,30,32,33,35,37,38,44,46,46,48,49,51,53,54,59,60,61,63,64,64,69,76,85,86,87,92,93,93,95,97,97,97,98,99,99};
int param0_7[] = {-75,-46,-42,-33,4,74,-76,14,-68,75,-14,51,94,27,55,30,-83,4};
int param0_8[] = {0,0,0,0,0,1,1,1,1};
int param0_9[] = {24,13,60,7,57,36,45,20,65,8,16,14,76,87,15,92,98,66,32,87,63,86,51,25,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[] = {0,1,18,9,22,12,26,9,5,24};
int filled_function_param0_0[] = {19};
int filled_function_param0_1[] = {-47,72};
int filled_function_param0_2[] = {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_3[] = {93,3,20,59,36,19,90,67,19,20,96,71,52,33,40,39};
int filled_function_param0_4[] = {-98,-93,-91,-89,-63,-58,-52,-52,-46,-40,-25,-16,-10,-1,-1,4,12,12,13,13,16,20,29,29,31,40,44,47,48,51,52,52,59,60,61,64,66,78,85,97};
int filled_function_param0_5[] = {0,1,1,1,1,1,1,0,1,0,0,1,0,1,0,1,0,1,1,1,1,1,0,0,0};
int filled_function_param0_6[] = {4,6,8,17,19,21,22,24,27,27,28,30,30,30,32,33,35,37,38,44,46,46,48,49,51,53,54,59,60,61,63,64,64,69,76,85,86,87,92,93,93,95,97,97,97,98,99,99};
int filled_function_param0_7[] = {-75,-46,-42,-33,4,74,-76,14,-68,75,-14,51,94,27,55,30,-83,4};
int filled_function_param0_8[] = {0,0,0,0,0,1,1,1,1};
int filled_function_param0_9[] = {24,13,60,7,57,36,45,20,65,8,16,14,76,87,15,92,98,66,32,87,63,86,51,25,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[] = {0,1,18,9,22,12,26,9,5,24};
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) import",
"b) f_filled",
"c) false;",
"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 ) {
return ( ( n + 1 ) * ( n + 2 ) ) / 2;
}
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 + 1 ) * ( n + 2 ) ) / 2;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {41,72,54,75,87,41,78,80,46,9};
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 ) { return ( ( n + 1 ) * ( n + 2 ) ) / 2; } int [MASK] ( 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 + 1 ) * ( n + 2 ) ) / 2;
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {41,72,54,75,87,41,78,80,46,9};
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) }",
"b) f_gold",
"c) f_filled",
"d) }",
"e) else"
] | 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 s [] ) {
int l = strlen(s);
int j;
for ( int i = 0, j = l - 1;
i <= j;
i ++, j -- ) {
if ( s [ i ] != s [ j ] ) return false;
}
return true;
}
bool f_filled ( char s [] ) {}
har s [] ) {
int l = strlen(s);
int j;
for ( int i = 0, j = l - 1;
i <= j;
i ++, j -- ) {
if ( s [ i ] != s [ j ] ) return false;
}
return true;
}
bool f_filled ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"aadaa","2674377254","11","0011000","26382426486138","111010111010","abccba","5191","1110101101","abcdecbe"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int [MASK] int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 l = strlen(s); int j; for ( int i = 0, j = l - 1; i <= j; i ++, j -- ) { if ( s [ i ] != s [ j ] ) return false; } return true; } bool f_filled ( char s [] ) {}har s [] ) {
int l = strlen(s);
int j;
for ( int i = 0, j = l - 1;
i <= j;
i ++, j -- ) {
if ( s [ i ] != s [ j ] ) return false;
}
return true;
}
bool f_filled ( char s [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"aadaa","2674377254","11","0011000","26382426486138","111010111010","abccba","5191","1110101101","abcdecbe"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | x, | [
"a) long",
"b) x,",
"c) =",
"d) 1",
"e) java.util."
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int m, int n ) {
int path = 1;
for ( int i = n;
i < ( m + n - 1 );
i ++ ) {
path *= i;
path /= ( i - n + 1 );
}
return path;
}
int f_filled ( int m, int n ) {}
}
int f_gold ( int m, int n ) {
int path = 1;
for ( int i = n;
i < ( m + n - 1 );
i ++ ) {
path *= i;
path /= ( i - n + 1 );
}
return path;
}
int f_filled ( int m, int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {10,52,5,84,27,77,52,3,5,14};
int param1[] = {3,8,23,56,30,90,50,25,75,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 [MASK] int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 path = 1; for ( int i = n; i < ( m + n - 1 ); i ++ ) { path *= i; path /= ( i - n + 1 ); } return path; } int f_filled ( int m, int n ) {}}
int f_gold ( int m, int n ) {
int path = 1;
for ( int i = n;
i < ( m + n - 1 );
i ++ ) {
path *= i;
path /= ( i - n + 1 );
}
return path;
}
int f_filled ( int m, int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {10,52,5,84,27,77,52,3,5,14};
int param1[] = {3,8,23,56,30,90,50,25,75,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;
} | x, | [
"a) ,",
"b) \"",
"c) long",
"d) x,",
"e) n2"
] | 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);}
long long int f_gold ( int n ) {
int N = 10;
long long count = 1;
for ( int i = 1;
i <= n;
i ++ ) {
count *= ( N + i - 1 );
count /= i;
}
return count;
}
long long int f_filled ( int n ) {}
gold ( int n ) {
int N = 10;
long long count = 1;
for ( int i = 1;
i <= n;
i ++ ) {
count *= ( N + i - 1 );
count /= i;
}
return count;
}
long long int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {40,11,94,73,6,73,58,40,64,66};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include [MASK] #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} long long int f_gold ( int n ) { int N = 10; long long count = 1; for ( int i = 1; i <= n; i ++ ) { count *= ( N + i - 1 ); count /= i; } return count; } long long int f_filled ( int n ) {}gold ( int n ) {
int N = 10;
long long count = 1;
for ( int i = 1;
i <= n;
i ++ ) {
count *= ( N + i - 1 );
count /= i;
}
return count;
}
long long int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {40,11,94,73,6,73,58,40,64,66};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | <math.h> | [
"a) }",
"b) <math.h>",
"c) if",
"d) >",
"e) if"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int m, int n ) {
int T [ m + 1 ] [ n + 1 ];
for ( int i = 0;
i < m + 1;
i ++ ) {
for ( int j = 0;
j < n + 1;
j ++ ) {
if ( i == 0 || j == 0 ) T [ i ] [ j ] = 0;
else if ( i < j ) T [ i ] [ j ] = 0;
else if ( j == 1 ) T [ i ] [ j ] = i;
else T [ i ] [ j ] = T [ i - 1 ] [ j ] + T [ i / 2 ] [ j - 1 ];
}
}
return T [ m ] [ n ];
}
int f_filled ( int m, int n ) {}
] [ j ] = 0;
else if ( j == 1 ) T [ i ] [ j ] = i;
else T [ i ] [ j ] = T [ i - 1 ] [ j ] + T [ i / 2 ] [ j - 1 ];
}
}
return T [ m ] [ n ];
}
int f_filled ( int m, int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {10,5,2,83,91,18,83,98,43,31};
int param1[] = {4,2,8,7,0,53,41,53,37,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; } [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);} int f_gold ( int m, int n ) { int T [ m + 1 ] [ n + 1 ]; for ( int i = 0; i < m + 1; i ++ ) { for ( int j = 0; j < n + 1; j ++ ) { if ( i == 0 || j == 0 ) T [ i ] [ j ] = 0; else if ( i < j ) T [ i ] [ j ] = 0; else if ( j == 1 ) T [ i ] [ j ] = i; else T [ i ] [ j ] = T [ i - 1 ] [ j ] + T [ i / 2 ] [ j - 1 ]; } } return T [ m ] [ n ]; } int f_filled ( int m, int n ) {}] [ j ] = 0;
else if ( j == 1 ) T [ i ] [ j ] = i;
else T [ i ] [ j ] = T [ i - 1 ] [ j ] + T [ i / 2 ] [ j - 1 ];
}
}
return T [ m ] [ n ];
}
int f_filled ( int m, int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {10,5,2,83,91,18,83,98,43,31};
int param1[] = {4,2,8,7,0,53,41,53,37,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;
} | int | [
"a) 1",
"b) (",
"c) 1;",
"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 ( char n [] ) {
int len = strlen(n);
if ( len == 1 ) {
int oneDigit = n . at ( 0 ) - '0';
if ( oneDigit % 4 == 0 ) return 1;
return 0;
}
int twoDigit, count = 0;
for ( int i = 0;
i < ( len - 1 );
i ++ ) {
twoDigit = ( n . at ( i ) - '0' ) * 10 + ( n . at ( i + 1 ) - '0' );
if ( twoDigit % 4 == 0 ) count ++;
}
twoDigit = ( n . at ( len - 1 ) - '0' ) * 10 + ( n . at ( 0 ) - '0' );
if ( twoDigit % 4 == 0 ) count ++;
return count;
}
int f_filled ( char n [] ) {}
f ( twoDigit % 4 == 0 ) count ++;
}
twoDigit = ( n . at ( len - 1 ) - '0' ) * 10 + ( n . at ( 0 ) - '0' );
if ( twoDigit % 4 == 0 ) count ++;
return count;
}
int f_filled ( char n [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"MRRuQJvxe","87395768","10111100110111","aVDUEfzG","55794792","111010","cndMLMJVmzuH","487717559382","11110","dRMDPyr"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char n [] ) { int len = strlen(n); if ( len == 1 ) { int oneDigit = n . at ( 0 ) - '0'; if ( oneDigit % 4 == 0 ) return 1; return 0; } int twoDigit, count = 0; for ( int i = 0; i < ( len - 1 ); i ++ ) { twoDigit = ( n . at ( i ) - '0' ) * 10 + ( n . at ( i + 1 ) - '0' ); if ( twoDigit % 4 == 0 ) count ++; } twoDigit = ( n . at ( len - 1 ) [MASK] '0' ) * 10 + ( n . at ( 0 ) - '0' ); if ( twoDigit % 4 == 0 ) count ++; return count; } int f_filled ( char n [] ) {}f ( twoDigit % 4 == 0 ) count ++;
}
twoDigit = ( n . at ( len - 1 ) - '0' ) * 10 + ( n . at ( 0 ) - '0' );
if ( twoDigit % 4 == 0 ) count ++;
return count;
}
int f_filled ( char n [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"MRRuQJvxe","87395768","10111100110111","aVDUEfzG","55794792","111010","cndMLMJVmzuH","487717559382","11110","dRMDPyr"};
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) 1",
"d) arr",
"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 );
int diff = INT_MAX;
for ( int i = 0;
i < n - 1;
i ++ ) if ( arr [ i + 1 ] - arr [ i ] < diff ) diff = arr [ i + 1 ] - arr [ i ];
return diff;
}
int f_filled ( int arr [ ], int n ) {}
);
int diff = INT_MAX;
for ( int i = 0;
i < n - 1;
i ++ ) if ( arr [ i + 1 ] - arr [ i ] < diff ) diff = arr [ i + 1 ] - arr [ i ];
return diff;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,25,44,46,54,60,81};
int param0_1[] = {82,68,-98,-66,-36,-42,98,-38,58,-6,-28,70,-24,18,16,10,92,44,28,-96,-72,24,28,-80,-4,38,88,76};
int param0_2[] = {1,1,1};
int param0_3[] = {87,25,80,45,44,20,48,47,51,54,68,47,89,95,15,29,5,45,2,64,53,96,94,22,23,43,61,75,74,50};
int param0_4[] = {-74,-48,-42,-26,-16,-12,0,4,8,18,46,46,62,70,74,88,92,96,98};
int param0_5[] = {0,1,1,1,0,1,1,0,0,1,1,1,0,0,1,1,0,1,0,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0};
int param0_6[] = {27,42,59,80};
int param0_7[] = {-96,-94,10,-36,18,-40};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {96};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {3,22,2,15,18,36,2,4,12,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) [MASK] (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 diff = INT_MAX; for ( int i = 0; i < n - 1; i ++ ) if ( arr [ i + 1 ] - arr [ i ] < diff ) diff = arr [ i + 1 ] - arr [ i ]; return diff; } int f_filled ( int arr [ ], int n ) {});
int diff = INT_MAX;
for ( int i = 0;
i < n - 1;
i ++ ) if ( arr [ i + 1 ] - arr [ i ] < diff ) diff = arr [ i + 1 ] - arr [ i ];
return diff;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {3,25,44,46,54,60,81};
int param0_1[] = {82,68,-98,-66,-36,-42,98,-38,58,-6,-28,70,-24,18,16,10,92,44,28,-96,-72,24,28,-80,-4,38,88,76};
int param0_2[] = {1,1,1};
int param0_3[] = {87,25,80,45,44,20,48,47,51,54,68,47,89,95,15,29,5,45,2,64,53,96,94,22,23,43,61,75,74,50};
int param0_4[] = {-74,-48,-42,-26,-16,-12,0,4,8,18,46,46,62,70,74,88,92,96,98};
int param0_5[] = {0,1,1,1,0,1,1,0,0,1,1,1,0,0,1,1,0,1,0,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0};
int param0_6[] = {27,42,59,80};
int param0_7[] = {-96,-94,10,-36,18,-40};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {96};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {3,22,2,15,18,36,2,4,12,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;
} | (sizeof | [
"a) i",
"b) ];",
"c) (sizeof",
"d) (arr)[0]));}",
"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);}
long int f_gold ( int n ) {
if ( n == 1 ) return 1;
long int z;
float e = 2.71;
z = sqrt ( 2 * 3.14 * n ) * pow ( ( n / e ), n );
return z;
}
long int f_filled ( int n ) {}
cmpfunc);}
long int f_gold ( int n ) {
if ( n == 1 ) return 1;
long int z;
float e = 2.71;
z = sqrt ( 2 * 3.14 * n ) * pow ( ( n / e ), n );
return z;
}
long int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
double param0[] = {1.0,5.0,10.0,20.0,40.0,2.0,3.0,-1.0,4663.43115050185,-3722.039522409859};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, [MASK] void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} long int f_gold ( int n ) { if ( n == 1 ) return 1; long int z; float e = 2.71; z = sqrt ( 2 * 3.14 * n ) * pow ( ( n / e ), n ); return z; } long int f_filled ( int n ) {} cmpfunc);}
long int f_gold ( int n ) {
if ( n == 1 ) return 1;
long int z;
float e = 2.71;
z = sqrt ( 2 * 3.14 * n ) * pow ( ( n / e ), n );
return z;
}
long int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
double param0[] = {1.0,5.0,10.0,20.0,40.0,2.0,3.0,-1.0,4663.43115050185,-3722.039522409859};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | const | [
"a) <bits/stdc++.h>",
"b) import",
"c) )",
"d) const",
"e) return"
] | 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 < 3 ) return n;
if ( n >= 3 && n < 10 ) return n - 1;
int po = 1;
while ( n / po > 9 ) po = po * 10;
int msd = n / po;
if ( msd != 3 ) return f_gold ( msd ) * f_gold ( po - 1 ) + f_gold ( msd ) + f_gold ( n % po );
else return f_gold ( msd * po - 1 );
}
int f_filled ( int n ) {}
= po * 10;
int msd = n / po;
if ( msd != 3 ) return f_gold ( msd ) * f_gold ( po - 1 ) + f_gold ( msd ) + f_gold ( n % po );
else return f_gold ( msd * po - 1 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {85,86,3,35,59,38,33,15,75,74};
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 ) { if ( n < 3 ) return n; if ( n >= 3 && n < 10 ) return [MASK] - 1; int po = 1; while ( n / po > 9 ) po = po * 10; int msd = n / po; if ( msd != 3 ) return f_gold ( msd ) * f_gold ( po - 1 ) + f_gold ( msd ) + f_gold ( n % po ); else return f_gold ( msd * po - 1 ); } int f_filled ( int n ) {}= po * 10;
int msd = n / po;
if ( msd != 3 ) return f_gold ( msd ) * f_gold ( po - 1 ) + f_gold ( msd ) + f_gold ( n % po );
else return f_gold ( msd * po - 1 );
}
int f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {85,86,3,35,59,38,33,15,75,74};
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) namespace",
"c) n,",
"d) n",
"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 ( int x, int y ) {
int res1 = log ( y ) / log ( x );
double res2 = log ( y ) / log ( x );
return ( res1 == res2 );
}
bool f_filled ( int x, int y ) {}
, sizeof(int), cmpfunc);}
bool f_gold ( int x, int y ) {
int res1 = log ( y ) / log ( x );
double res2 = log ( y ) / log ( x );
return ( res1 == res2 );
}
bool f_filled ( int x, int y ) {}
int main(void) {
int n_success = 0;
int param0[] = {57,3,10,10,6,2,2,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) [MASK] sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( int x, int y ) { int res1 = log ( y ) / log ( x ); double res2 = log ( y ) / log ( x ); return ( res1 == res2 ); } bool f_filled ( int x, int y ) {}, sizeof(int), cmpfunc);}
bool f_gold ( int x, int y ) {
int res1 = log ( y ) / log ( x );
double res2 = log ( y ) / log ( x );
return ( res1 == res2 );
}
bool f_filled ( int x, int y ) {}
int main(void) {
int n_success = 0;
int param0[] = {57,3,10,10,6,2,2,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) return",
"c) x",
"d) /",
"e) ["
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int max_len = 0;
for ( int i = 0;
i < n;
i ++ ) {
int curr_sum = 0;
for ( int j = i;
j < n;
j ++ ) {
curr_sum += arr [ j ];
if ( curr_sum == 0 ) max_len = max ( max_len, j - i + 1 );
}
}
return max_len;
}
int f_filled ( int arr [ ], int n ) {}
t j = i;
j < n;
j ++ ) {
curr_sum += arr [ j ];
if ( curr_sum == 0 ) max_len = max ( max_len, j - i + 1 );
}
}
return max_len;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,6,6,15,23,26,27,30,34,35,38,42,43,44,46,50,53,53,57,62,65,67,70,76,79,81,82,85,90};
int param0_1[] = {72,-6,-24,-82,16,78,-82,38,-2,78,-60,40,26,-82,-32,-56,52,14,62,-18,-84,-94,48,54,2,-28};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {14,67,44,5,60,87,23,37,44,70,47,52,38,30,78,60,95,62,3,45,96,35,81,8,82,75,76,64,33,65,65,49,1,63,99,53,40,12,46,93,88,27,89,89,60,3,92,63};
int param0_4[] = {-98,-98,-96,-86,-74,-74,-72,-70,-70,-66,-66,-66,-64,-64,-50,-50,-48,-38,-28,-24,-24,-18,-16,-14,-8,-6,-2,-2,10,28,32,38,42,54,54,62,68,84,88};
int param0_5[] = {0,1,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0,0,0,1,1,0};
int param0_6[] = {6,14,26,27,37,50,51,54,55,67,68,72,83,84,95,99};
int param0_7[] = {-6,-96,-46,4,-50,-56,-34,6,-72,-68,92,88,-80,18,58,20,34,-22,-18,-90,-80,-24,-82,6,54,70,22,94};
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};
int param0_9[] = {65,34,82,43,15,94,34,50,70,77,83,26,85,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[] = {19,24,18,39,25,12,10,22,45,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 max_len = 0; for ( int i = 0; i < n; i ++ ) { int curr_sum = 0; for ( int j = i; j < n; j ++ ) { [MASK] += arr [ j ]; if ( curr_sum == 0 ) max_len = max ( max_len, j - i + 1 ); } } return max_len; } int f_filled ( int arr [ ], int n ) {}t j = i;
j < n;
j ++ ) {
curr_sum += arr [ j ];
if ( curr_sum == 0 ) max_len = max ( max_len, j - i + 1 );
}
}
return max_len;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,2,6,6,15,23,26,27,30,34,35,38,42,43,44,46,50,53,53,57,62,65,67,70,76,79,81,82,85,90};
int param0_1[] = {72,-6,-24,-82,16,78,-82,38,-2,78,-60,40,26,-82,-32,-56,52,14,62,-18,-84,-94,48,54,2,-28};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {14,67,44,5,60,87,23,37,44,70,47,52,38,30,78,60,95,62,3,45,96,35,81,8,82,75,76,64,33,65,65,49,1,63,99,53,40,12,46,93,88,27,89,89,60,3,92,63};
int param0_4[] = {-98,-98,-96,-86,-74,-74,-72,-70,-70,-66,-66,-66,-64,-64,-50,-50,-48,-38,-28,-24,-24,-18,-16,-14,-8,-6,-2,-2,10,28,32,38,42,54,54,62,68,84,88};
int param0_5[] = {0,1,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0,0,0,1,1,0};
int param0_6[] = {6,14,26,27,37,50,51,54,55,67,68,72,83,84,95,99};
int param0_7[] = {-6,-96,-46,4,-50,-56,-34,6,-72,-68,92,88,-80,18,58,20,34,-22,-18,-90,-80,-24,-82,6,54,70,22,94};
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};
int param0_9[] = {65,34,82,43,15,94,34,50,70,77,83,26,85,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[] = {19,24,18,39,25,12,10,22,45,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;
} | curr_sum | [
"a) curr_sum",
"b) i",
"c) max",
"d) int",
"e) );"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int k, char s1 [], char s2 [] ) {
int n = strlen(s1);
int m = strlen(s2);
int lcs [ n + 1 ] [ m + 1 ];
int cnt [ n + 1 ] [ m + 1 ];
memset ( lcs, 0, sizeof ( lcs ) );
memset ( cnt, 0, sizeof ( cnt ) );
for ( int i = 1;
i <= n;
i ++ ) {
for ( int j = 1;
j <= m;
j ++ ) {
lcs [ i ] [ j ] = max ( lcs [ i - 1 ] [ j ], lcs [ i ] [ j - 1 ] );
if ( s1 [ i - 1 ] == s2 [ j - 1 ] ) cnt [ i ] [ j ] = cnt [ i - 1 ] [ j - 1 ] + 1;
if ( cnt [ i ] [ j ] >= k ) {
for ( int a = k;
a <= cnt [ i ] [ j ];
a ++ ) lcs [ i ] [ j ] = max ( lcs [ i ] [ j ], lcs [ i - a ] [ j - a ] + a );
}
}
}
return lcs [ n ] [ m ];
}
int f_filled ( int k, char s1 [], char s2 [] ) {}
[ i ] [ j ];
a ++ ) lcs [ i ] [ j ] = max ( lcs [ i ] [ j ], lcs [ i - a ] [ j - a ] + a );
}
}
}
return lcs [ n ] [ m ];
}
int f_filled ( int k, char s1 [], char s2 [] ) {}
int main(void) {
int n_success = 0;
int param0[] = {4,2,3,5,2,3,3,1,2,2};
char param1[][100] = {"aggayxysdfa","55571659965107","01011011100","aggasdfa","5710246551","0100010","aabcaaaa","1219","111000011","wiC oD"};
char param2[][100] = {"aggajxaaasdfa","390286654154","0000110001000","aggajasdfaxy","79032504084062","10100000","baaabcd","3337119582","011","csiuGOUwE"};
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 k, char s1 [], char s2 [] ) { int n = strlen(s1); int m = strlen(s2); int lcs [ n + 1 ] [ m + [MASK] ]; int cnt [ n + 1 ] [ m + 1 ]; memset ( lcs, 0, sizeof ( lcs ) ); memset ( cnt, 0, sizeof ( cnt ) ); for ( int i = 1; i <= n; i ++ ) { for ( int j = 1; j <= m; j ++ ) { lcs [ i ] [ j ] = max ( lcs [ i - 1 ] [ j ], lcs [ i ] [ j - 1 ] ); if ( s1 [ i - 1 ] == s2 [ j - 1 ] ) cnt [ i ] [ j ] = cnt [ i - 1 ] [ j - 1 ] + 1; if ( cnt [ i ] [ j ] >= k ) { for ( int a = k; a <= cnt [ i ] [ j ]; a ++ ) lcs [ i ] [ j ] = max ( lcs [ i ] [ j ], lcs [ i - a ] [ j - a ] + a ); } } } return lcs [ n ] [ m ]; } int f_filled ( int k, char s1 [], char s2 [] ) {}[ i ] [ j ];
a ++ ) lcs [ i ] [ j ] = max ( lcs [ i ] [ j ], lcs [ i - a ] [ j - a ] + a );
}
}
}
return lcs [ n ] [ m ];
}
int f_filled ( int k, char s1 [], char s2 [] ) {}
int main(void) {
int n_success = 0;
int param0[] = {4,2,3,5,2,3,3,1,2,2};
char param1[][100] = {"aggayxysdfa","55571659965107","01011011100","aggasdfa","5710246551","0100010","aabcaaaa","1219","111000011","wiC oD"};
char param2[][100] = {"aggajxaaasdfa","390286654154","0000110001000","aggajasdfaxy","79032504084062","10100000","baaabcd","3337119582","011","csiuGOUwE"};
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;
} | 1 | [
"a) ;",
"b) x1,",
"c) table",
"d) 1",
"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 diameter, int height ) {
return 2 * ( diameter + height );
}
int f_filled ( int diameter, int height ) {}
oid sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int diameter, int height ) {
return 2 * ( diameter + height );
}
int f_filled ( int diameter, int height ) {}
int main(void) {
int n_success = 0;
int param0[] = {70,97,49,56,87,64,75,90,55,73};
int param1[] = {78,46,26,61,79,21,93,16,16,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 [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 diameter, int height ) { return 2 * ( diameter + height ); } int f_filled ( int diameter, int height ) {}oid sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int diameter, int height ) {
return 2 * ( diameter + height );
}
int f_filled ( int diameter, int height ) {}
int main(void) {
int n_success = 0;
int param0[] = {70,97,49,56,87,64,75,90,55,73};
int param1[] = {78,46,26,61,79,21,93,16,16,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;
} | );} | [
"a) (",
"b) for",
"c) );}",
"d) (",
"e) :"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( unsigned int n ) {
return n != 0 && ( ( n & ( n - 1 ) ) == 0 ) && ! ( n & 0xAAAAAAAA );
}
bool f_filled ( unsigned int n ) {}
[ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( unsigned int n ) {
return n != 0 && ( ( n & ( n - 1 ) ) == 0 ) && ! ( n & 0xAAAAAAAA );
}
bool f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,4,64,-64,128,1024,97,86,14,99};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 ( unsigned int n ) { return n != 0 && ( ( n & ( n - 1 ) ) == 0 ) && ! ( n & 0xAAAAAAAA ); } bool f_filled ( [MASK] int n ) {} [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
bool f_gold ( unsigned int n ) {
return n != 0 && ( ( n & ( n - 1 ) ) == 0 ) && ! ( n & 0xAAAAAAAA );
}
bool f_filled ( unsigned int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,4,64,-64,128,1024,97,86,14,99};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | unsigned | [
"a) (",
"b) max_end",
"c) (sizeof",
"d) unsigned",
"e) #include"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b ) {
if ( a == 0 || b == 0 ) return 1;
return floor ( log10 ( abs ( a ) ) + log10 ( abs ( b ) ) ) + 1;
}
int f_filled ( int a, int b ) {}
n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b ) {
if ( a == 0 || b == 0 ) return 1;
return floor ( log10 ( abs ( a ) ) + log10 ( abs ( b ) ) ) + 1;
}
int f_filled ( int a, int b ) {}
int main(void) {
int n_success = 0;
int param0[] = {97,52,95,35,40,18,92,73,10,82};
int param1[] = {91,49,34,40,85,97,15,98,62,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) [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 a, int b ) { if ( a == 0 || b == 0 ) return 1; return floor ( log10 ( abs ( a ) ) + log10 ( abs ( b ) ) ) + 1; } int f_filled ( int a, int b ) {} n, sizeof(int), cmpfunc);}
int f_gold ( int a, int b ) {
if ( a == 0 || b == 0 ) return 1;
return floor ( log10 ( abs ( a ) ) + log10 ( abs ( b ) ) ) + 1;
}
int f_filled ( int a, int b ) {}
int main(void) {
int n_success = 0;
int param0[] = {97,52,95,35,40,18,92,73,10,82};
int param1[] = {91,49,34,40,85,97,15,98,62,22};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | { | [
"a) for",
"b) (",
"c) {",
"d) math.pi",
"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 str [], int i = 0 ) {
if ( str [ i ] == '\0' ) return 0;
if ( isupper ( str [ i ] ) ) return str [ i ];
return f_gold ( str, i + 1 );
}
char f_filled ( char str [], int i = 0 ) {}
ld ( char str [], int i = 0 ) {
if ( str [ i ] == '\0' ) return 0;
if ( isupper ( str [ i ] ) ) return str [ i ];
return f_gold ( str, i + 1 );
}
char f_filled ( char str [], int i = 0 ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"bqDNcKByTnd","55228579663548","011","iWPNIfEbTXSN","317256850800","01","sPohONiPM","690818686620","1","xVz IfQBHyEZMa"};
int param1[] = {0,0,0,0,0,0,0,0,0,82};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, [MASK] void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} char f_gold ( char str [], int i = 0 ) { if ( str [ i ] == '\0' ) return 0; if ( isupper ( str [ i ] ) ) return str [ i ]; return f_gold ( str, i + 1 ); } char f_filled ( char str [], int i = 0 ) {}ld ( char str [], int i = 0 ) {
if ( str [ i ] == '\0' ) return 0;
if ( isupper ( str [ i ] ) ) return str [ i ];
return f_gold ( str, i + 1 );
}
char f_filled ( char str [], int i = 0 ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"bqDNcKByTnd","55228579663548","011","iWPNIfEbTXSN","317256850800","01","sPohONiPM","690818686620","1","xVz IfQBHyEZMa"};
int param1[] = {0,0,0,0,0,0,0,0,0,82};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | const | [
"a) const",
"b) =",
"c) ]",
"d) return",
"e) min"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
int sum = INT_MIN;
for ( int i = 0;
i < n;
i ++ ) for ( int j = i + 1;
j < n;
j ++ ) for ( int k = j + 1;
k < n;
k ++ ) if ( sum < arr [ i ] + arr [ j ] + arr [ k ] ) sum = arr [ i ] + arr [ j ] + arr [ k ];
return sum;
}
int f_filled ( int arr [ ], int n ) {}
< n;
j ++ ) for ( int k = j + 1;
k < n;
k ++ ) if ( sum < arr [ i ] + arr [ j ] + arr [ k ] ) sum = arr [ i ] + arr [ j ] + arr [ k ];
return sum;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {6,10,14,19,24,29,42,43,44,47,47,55,57,59,60,61,76,76,77,81,84,92,92,93,95,97};
int param0_1[] = {-98,72,52,-62,74,-26,-82,-74,90,58,94,-2,76,-28,12,64,-94,86,56,10,40,20,92,-4,-80,26,-40,36,66,-46,4,-42,-76,76,-90,-48,22,30,48,38,78};
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,1,1};
int param0_3[] = {96,96,38,26,2,36,15,51,78,98,94,31,62,21,7,68,37,4};
int param0_4[] = {-8,12,68,78,78};
int param0_5[] = {0,0,0,0,1,0,0,0,1,0,1,1,1,0,1,1,0,1,1,1,1,0,1,1,1,0,0,1,1,0,1,0,0,0,0,0,0,0,0};
int param0_6[] = {1,15,16,17,28,28,28,30,31,37,38,38,45,45,46,46,50,51,53,53,55,55,56,58,58,64,78,82,82,85,87,89,89,90,94,95};
int param0_7[] = {-56,-72,-20,88,20,86,30,36,-44,-66,-26,-88,12,-76,78,62,62,68,-34,0,-22,64,72,56,-64,-16,-4,86,0,98,-70,98,-68,92,-84,-56,28,-74,6,-10,-82,36,-12,-26,66,-60,-68,70,2};
int param0_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_9[] = {85,31,15,68,92,89,32,56,27,70,82,58,63,83,89,95,78,9,27,34,24,42,66,6,1,71,55,23,75,26,19,58,25};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {15,28,22,10,4,35,29,36,11,16};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int arr [ ], int n ) { int sum = INT_MIN; for ( int i [MASK] 0; i < n; i ++ ) for ( int j = i + 1; j < n; j ++ ) for ( int k = j + 1; k < n; k ++ ) if ( sum < arr [ i ] + arr [ j ] + arr [ k ] ) sum = arr [ i ] + arr [ j ] + arr [ k ]; return sum; } int f_filled ( int arr [ ], int n ) {}< n;
j ++ ) for ( int k = j + 1;
k < n;
k ++ ) if ( sum < arr [ i ] + arr [ j ] + arr [ k ] ) sum = arr [ i ] + arr [ j ] + arr [ k ];
return sum;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {6,10,14,19,24,29,42,43,44,47,47,55,57,59,60,61,76,76,77,81,84,92,92,93,95,97};
int param0_1[] = {-98,72,52,-62,74,-26,-82,-74,90,58,94,-2,76,-28,12,64,-94,86,56,10,40,20,92,-4,-80,26,-40,36,66,-46,4,-42,-76,76,-90,-48,22,30,48,38,78};
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,1,1};
int param0_3[] = {96,96,38,26,2,36,15,51,78,98,94,31,62,21,7,68,37,4};
int param0_4[] = {-8,12,68,78,78};
int param0_5[] = {0,0,0,0,1,0,0,0,1,0,1,1,1,0,1,1,0,1,1,1,1,0,1,1,1,0,0,1,1,0,1,0,0,0,0,0,0,0,0};
int param0_6[] = {1,15,16,17,28,28,28,30,31,37,38,38,45,45,46,46,50,51,53,53,55,55,56,58,58,64,78,82,82,85,87,89,89,90,94,95};
int param0_7[] = {-56,-72,-20,88,20,86,30,36,-44,-66,-26,-88,12,-76,78,62,62,68,-34,0,-22,64,72,56,-64,-16,-4,86,0,98,-70,98,-68,92,-84,-56,28,-74,6,-10,-82,36,-12,-26,66,-60,-68,70,2};
int param0_8[] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_9[] = {85,31,15,68,92,89,32,56,27,70,82,58,63,83,89,95,78,9,27,34,24,42,66,6,1,71,55,23,75,26,19,58,25};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {15,28,22,10,4,35,29,36,11,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) n2",
"b) import",
"c) )",
"d) =",
"e) max"
] | d |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int arr [ ], int n ) {
unordered_map < int, int > um;
int sum = 0, maxLen = 0;
for ( int i = 0;
i < n;
i ++ ) {
sum += arr [ i ] == 0 ? - 1 : 1;
if ( sum == 1 ) maxLen = i + 1;
else if ( um . find ( sum ) == um . end ( ) ) um [ sum ] = i;
if ( um . find ( sum - 1 ) != um . end ( ) ) {
if ( maxLen < ( i - um [ sum - 1 ] ) ) maxLen = i - um [ sum - 1 ];
}
}
return maxLen;
}
int f_filled ( int arr [ ], int n ) {}
i;
if ( um . find ( sum - 1 ) != um . end ( ) ) {
if ( maxLen < ( i - um [ sum - 1 ] ) ) maxLen = i - um [ sum - 1 ];
}
}
return maxLen;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {6,10,31,35};
int param0_1[] = {4,88,-72,28,-54,32,-34};
int param0_2[] = {0,0,0,1,1,1,1,1,1};
int param0_3[] = {39,22,15,10,34,87,46,83,74,77,61,90,43,67,64,72,92,52,68,53,67,32,82,76,76,47,74,47,8,80,85,58,75};
int param0_4[] = {-82,-58,-50,-30,-14,-4,-2,-2,0,22,36,58,70,80,80,82,84,90};
int param0_5[] = {1,0,1,0,0,1,1,1,0,0,1};
int param0_6[] = {4,11,17,21,21,22,30,31,36,37,39,40,45,46,47,48,52,53,53,60,60,65,66,66,67,67,87,88,91,97};
int param0_7[] = {-4,-60,-78,-50,64,18,0,76,12,86,-22};
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};
int param0_9[] = {4,39,50,37,71,66,55,34,1,41,34,99,69,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[] = {2,6,4,26,14,7,29,7,17,11};
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;
} | [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 n ) { unordered_map < int, int > um; int sum = 0, maxLen = 0; for ( int i = 0; i < n; i ++ ) { sum += arr [ i ] == 0 ? - 1 : 1; if ( sum == 1 ) maxLen = i + 1; else if ( um . find ( sum ) == um . end ( ) ) um [ sum ] = i; if ( um . find ( sum - 1 ) != um . end ( ) ) { if ( maxLen < ( i - um [ sum - 1 ] ) ) maxLen = i - um [ sum - 1 ]; } } return maxLen; } int f_filled ( int arr [ ], int n ) {}i;
if ( um . find ( sum - 1 ) != um . end ( ) ) {
if ( maxLen < ( i - um [ sum - 1 ] ) ) maxLen = i - um [ sum - 1 ];
}
}
return maxLen;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {6,10,31,35};
int param0_1[] = {4,88,-72,28,-54,32,-34};
int param0_2[] = {0,0,0,1,1,1,1,1,1};
int param0_3[] = {39,22,15,10,34,87,46,83,74,77,61,90,43,67,64,72,92,52,68,53,67,32,82,76,76,47,74,47,8,80,85,58,75};
int param0_4[] = {-82,-58,-50,-30,-14,-4,-2,-2,0,22,36,58,70,80,80,82,84,90};
int param0_5[] = {1,0,1,0,0,1,1,1,0,0,1};
int param0_6[] = {4,11,17,21,21,22,30,31,36,37,39,40,45,46,47,48,52,53,53,60,60,65,66,66,67,67,87,88,91,97};
int param0_7[] = {-4,-60,-78,-50,64,18,0,76,12,86,-22};
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};
int param0_9[] = {4,39,50,37,71,66,55,34,1,41,34,99,69,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[] = {2,6,4,26,14,7,29,7,17,11};
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) i",
"d) return",
"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 arr [ ], int n, int x, int y ) {
int count = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] >= x && arr [ i ] <= y ) count ++;
}
return count;
}
int f_filled ( int arr [ ], int n, int x, int y ) {}
int y ) {
int count = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] >= x && arr [ i ] <= y ) count ++;
}
return count;
}
int f_filled ( int arr [ ], int n, int x, int y ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,16,19,24,36,38,42,49,51,53,53,57,57,58,71,78,78,92,92,93};
int param0_1[] = {28,-74,-18,10,26,28,-96,-80,82,94,22,50,72,-90,76,50,20,-44,-80};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {25,8,66,90,50,65,76,90,27};
int param0_4[] = {-98,-96,-90,-82,-80,-78,-70,-66,-60,-60,-50,-48,-34,-26,-24,-16,-14,-8,-6,4,22,24,26,30,30,48,52,56,60,62,74,76,78,86};
int param0_5[] = {1,1,1,0,1,1,0,0,0,1,1,0,1,1,0,0,0,0};
int param0_6[] = {4,6,17,19,24,29,30,31,32,37,37,40,43,44,44,45,57,64,69,70,73,78,86,89,91,92,94};
int param0_7[] = {32,-88,70,-6,28,-48};
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};
int param0_9[] = {37,84,97,74,12,26,47,10,14,33};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {13,18,30,4,32,15,17,4,13,5};
int param2[] = {12,13,21,8,24,16,21,3,12,9};
int param3[] = {13,13,31,5,24,12,15,4,11,8};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 y ) { int count = 0; for ( [MASK] i = 0; i < n; i ++ ) { if ( arr [ i ] >= x && arr [ i ] <= y ) count ++; } return count; } int f_filled ( int arr [ ], int n, int x, int y ) {} int y ) {
int count = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] >= x && arr [ i ] <= y ) count ++;
}
return count;
}
int f_filled ( int arr [ ], int n, int x, int y ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {9,16,19,24,36,38,42,49,51,53,53,57,57,58,71,78,78,92,92,93};
int param0_1[] = {28,-74,-18,10,26,28,-96,-80,82,94,22,50,72,-90,76,50,20,-44,-80};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {25,8,66,90,50,65,76,90,27};
int param0_4[] = {-98,-96,-90,-82,-80,-78,-70,-66,-60,-60,-50,-48,-34,-26,-24,-16,-14,-8,-6,4,22,24,26,30,30,48,52,56,60,62,74,76,78,86};
int param0_5[] = {1,1,1,0,1,1,0,0,0,1,1,0,1,1,0,0,0,0};
int param0_6[] = {4,6,17,19,24,29,30,31,32,37,37,40,43,44,44,45,57,64,69,70,73,78,86,89,91,92,94};
int param0_7[] = {32,-88,70,-6,28,-48};
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};
int param0_9[] = {37,84,97,74,12,26,47,10,14,33};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {13,18,30,4,32,15,17,4,13,5};
int param2[] = {12,13,21,8,24,16,21,3,12,9};
int param3[] = {13,13,31,5,24,12,15,4,11,8};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | int | [
"a) 1",
"b) ]",
"c) int",
"d) {",
"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 x ) {
if ( x == 0 || x == 1 ) return x;
int i = 1, result = 1;
while ( result <= x ) {
i ++;
result = i * i;
}
return i - 1;
}
int f_filled ( int x ) {}
unc);}
int f_gold ( int x ) {
if ( x == 0 || x == 1 ) return x;
int i = 1, result = 1;
while ( result <= x ) {
i ++;
result = i * i;
}
return i - 1;
}
int f_filled ( int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {89,11,14,92,76,63,51,16,83,66};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (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 x ) { if ( x == 0 || x == 1 ) return x; int i = 1, result = 1; while ( result <= x ) { i ++; result = i * i; } return i - 1; } int f_filled ( int x ) {}unc);}
int f_gold ( int x ) {
if ( x == 0 || x == 1 ) return x;
int i = 1, result = 1;
while ( result <= x ) {
i ++;
result = i * i;
}
return i - 1;
}
int f_filled ( int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {89,11,14,92,76,63,51,16,83,66};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | (int | [
"a) {",
"b) if",
"c) (x",
"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);}
float f_gold ( int n ) {
return ( 0.666 ) * ( 1 - 1 / pow ( 10, n ) );
}
float f_filled ( int n ) {}
sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
float f_gold ( int n ) {
return ( 0.666 ) * ( 1 - 1 / pow ( 10, n ) );
}
float f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,2,3,4,5,74,77,67,9,12};
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 [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} float f_gold ( int n ) { return ( 0.666 ) * ( 1 - 1 / pow ( 10, n ) [MASK] } float f_filled ( int n ) {} sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
float f_gold ( int n ) {
return ( 0.666 ) * ( 1 - 1 / pow ( 10, n ) );
}
float f_filled ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,2,3,4,5,74,77,67,9,12};
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;
} | ); | [
"a) [",
"b) y)",
"c) );",
"d) class",
"e) #include"
] | 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 [] ( int n ) {
if ( n == 0 ) return "0";
char bin [] = "";
while ( n > 0 ) {
bin = ( ( n & 1 ) == 0 ? '0' : '1' ) + bin;
n >>= 1;
}
return bin;
}
char f_filled [] ( int n ) {}
d [] ( int n ) {
if ( n == 0 ) return "0";
char bin [] = "";
while ( n > 0 ) {
bin = ( ( n & 1 ) == 0 ? '0' : '1' ) + bin;
n >>= 1;
}
return bin;
}
char f_filled [] ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {35,17,8,99,57,39,99,14,22,7};
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 [] ( int n ) { if ( n == 0 ) return "0"; char bin [] = ""; while ( n > 0 ) { bin = ( ( n & 1 ) == 0 [MASK] '0' : '1' ) + bin; n >>= 1; } return bin; } char f_filled [] ( int n ) {}d [] ( int n ) {
if ( n == 0 ) return "0";
char bin [] = "";
while ( n > 0 ) {
bin = ( ( n & 1 ) == 0 ? '0' : '1' ) + bin;
n >>= 1;
}
return bin;
}
char f_filled [] ( int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {35,17,8,99,57,39,99,14,22,7};
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) M",
"e) ]"
] | b |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int b [ ], int n ) {
sort ( a, a + n );
sort ( b, b + n );
int result = 0;
for ( int i = 0;
i < n;
++ i ) {
result = result + abs ( a [ i ] - b [ i ] );
}
return result;
}
int f_filled ( int a [ ], int b [ ], int n ) {}
sort ( b, b + n );
int result = 0;
for ( int i = 0;
i < n;
++ i ) {
result = result + abs ( a [ i ] - b [ i ] );
}
return result;
}
int f_filled ( int a [ ], int b [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,6,6,7,10,11,13,18,19,19,19,31,34,37,37,40,41,41,47,47,53,54,55,55,56,56,60,60,62,62,66,73,75,76,78,81,81,85,88,90,91,92,93,95,97,98};
int param0_1[] = {-12,-6,78,62,86,-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[] = {76,74};
int param0_4[] = {-92,-90,-88,-84,-76,-54,-44,-42,-38,-30,34,42};
int param0_5[] = {1,1,0,0,1,1,1,0,1,1,0,0,1,0,0,1,1,1};
int param0_6[] = {4,5,6,13,16,24,36,40,40,44,47,52,58,58,59,63,66,67,69,70,74,77,81,88,89,90,94,96};
int param0_7[] = {-16,66,-2,54,-8,10,44,-36,-54,50,92,84,-36,40,-12,98,36,22,-10};
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[] = {42,24,43,64,55,94,26,30,76,3,37,43,81,7,15,64,63,88,34,8,55,32,19,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_0[] = {2,2,4,7,8,8,8,8,8,9,9,12,15,16,21,25,26,27,29,34,34,35,38,40,40,44,44,47,48,54,58,61,63,64,66,69,69,70,73,74,75,76,79,80,80,93};
int param1_1[] = {-86,20,32,52,50,-60};
int param1_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param1_3[] = {16,98};
int param1_4[] = {-80,-54,-34,12,14,16,16,46,50,64,84,92};
int param1_5[] = {0,1,1,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1};
int param1_6[] = {1,7,10,17,21,22,22,27,36,37,39,46,52,53,56,59,65,67,70,75,78,78,79,89,89,94,96,97};
int param1_7[] = {-76,-74,62,22,50,84,78,26,-62,-10,86,-10,-92,-10,86,-6,-58,-26,-18};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {96,11,63,90,28,80,44,63,17,81,80,69,66,22,81,4,86,74,91,17,3,81,65,98};
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[] = {23,4,14,1,8,14,24,16,36,22};
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) [MASK] (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 = result + abs ( a [ i ] - b [ i ] ); } return result; } int f_filled ( int a [ ], int b [ ], int n ) {}sort ( b, b + n );
int result = 0;
for ( int i = 0;
i < n;
++ i ) {
result = result + abs ( a [ i ] - b [ i ] );
}
return result;
}
int f_filled ( int a [ ], int b [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {1,6,6,7,10,11,13,18,19,19,19,31,34,37,37,40,41,41,47,47,53,54,55,55,56,56,60,60,62,62,66,73,75,76,78,81,81,85,88,90,91,92,93,95,97,98};
int param0_1[] = {-12,-6,78,62,86,-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[] = {76,74};
int param0_4[] = {-92,-90,-88,-84,-76,-54,-44,-42,-38,-30,34,42};
int param0_5[] = {1,1,0,0,1,1,1,0,1,1,0,0,1,0,0,1,1,1};
int param0_6[] = {4,5,6,13,16,24,36,40,40,44,47,52,58,58,59,63,66,67,69,70,74,77,81,88,89,90,94,96};
int param0_7[] = {-16,66,-2,54,-8,10,44,-36,-54,50,92,84,-36,40,-12,98,36,22,-10};
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[] = {42,24,43,64,55,94,26,30,76,3,37,43,81,7,15,64,63,88,34,8,55,32,19,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_0[] = {2,2,4,7,8,8,8,8,8,9,9,12,15,16,21,25,26,27,29,34,34,35,38,40,40,44,44,47,48,54,58,61,63,64,66,69,69,70,73,74,75,76,79,80,80,93};
int param1_1[] = {-86,20,32,52,50,-60};
int param1_2[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1};
int param1_3[] = {16,98};
int param1_4[] = {-80,-54,-34,12,14,16,16,46,50,64,84,92};
int param1_5[] = {0,1,1,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1};
int param1_6[] = {1,7,10,17,21,22,22,27,36,37,39,46,52,53,56,59,65,67,70,75,78,78,79,89,89,94,96,97};
int param1_7[] = {-76,-74,62,22,50,84,78,26,-62,-10,86,-10,-92,-10,86,-6,-58,-26,-18};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {96,11,63,90,28,80,44,63,17,81,80,69,66,22,81,4,86,74,91,17,3,81,65,98};
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[] = {23,4,14,1,8,14,24,16,36,22};
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;
} | {qsort | [
"a) int",
"b) )",
"c) def",
"d) )",
"e) {qsort"
] | 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 num, int divisor ) {
return ( num - divisor * ( num / divisor ) );
}
int f_filled ( int num, int divisor ) {}
sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int num, int divisor ) {
return ( num - divisor * ( num / divisor ) );
}
int f_filled ( int num, int divisor ) {}
int main(void) {
int n_success = 0;
int param0[] = {80,63,1,22,66,61,45,29,95,9};
int param1[] = {54,21,56,39,7,67,63,44,65,68};
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 [MASK] arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int num, int divisor ) { return ( num - divisor * ( num / divisor ) ); } int f_filled ( int num, int divisor ) {}sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int num, int divisor ) {
return ( num - divisor * ( num / divisor ) );
}
int f_filled ( int num, int divisor ) {}
int main(void) {
int n_success = 0;
int param0[] = {80,63,1,22,66,61,45,29,95,9};
int param1[] = {54,21,56,39,7,67,63,44,65,68};
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) ,",
"b) =",
"c) class",
"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 arr [ ], int n, int k ) {
if ( k > n ) return - 1;
int * csum = new int [ n ];
csum [ 0 ] = arr [ 0 ];
for ( int i = 1;
i < n;
i ++ ) csum [ i ] = csum [ i - 1 ] + arr [ i ];
int max_sum = csum [ k - 1 ], max_end = k - 1;
for ( int i = k;
i < n;
i ++ ) {
int curr_sum = csum [ i ] - csum [ i - k ];
if ( curr_sum > max_sum ) {
max_sum = curr_sum;
max_end = i;
}
}
delete [ ] csum;
return max_end - k + 1;
}
int f_filled ( int arr [ ], int n, int k ) {}
csum [ i - k ];
if ( curr_sum > max_sum ) {
max_sum = curr_sum;
max_end = i;
}
}
delete [ ] csum;
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,4,6,19,21,23,32,34,47,51,56,57,57,65,68,68,69,70,71,73,74,74,77,77,79,82,82,86,87,87,88,89,90,91,92};
int param0_1[] = {24,62,-32,-28,42,-46,-96,-70,-68,60,44,34,-30,96,-26,92,62,42,-46,-38,44,54,-94,52,66,68,-96,-58,84,-2,66,30,42};
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};
int param0_3[] = {94,6,48,34,31};
int param0_4[] = {-98,-88,-82,-80,-76,-70,-70,-60,-60,-52,-50,-46,-44,-44,-44,-20,-18,-12,-12,-12,-10,-8,-6,-4,4,4,18,28,32,34,42,42,44,46,48,54,60,70,70,72,78,78,78,78,84,86,90,96,98};
int param0_5[] = {0,1,0,0,1,0,1,1,0,0,1,1,0,0,0,0,0};
int param0_6[] = {1,5,13,17,26,26,32,35,38,38,39,45,52,58,60,61,62,63,82,83,85,89,89,91};
int param0_7[] = {-68,-52,4,-90,90,88,38,-18,86,4,14,-32,-14,-44,-88,-50,-12,-26,-68,-20,-30,22,0,14,-40,58,-6,28,-44,8,28,96,-46,-12};
int param0_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {17,33,36,34,32,10,37,48,47,32,21,18,75,8,18,52,21,73,25,25,80,32,10,24,1,89,7,42,86,85,73,12,20,20,1,74,77,4,24,74,8};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {29,23,32,4,45,15,13,32,13,20};
int param2[] = {20,31,31,3,30,8,22,22,11,28};
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 ( k > n ) return - 1; int * csum = new int [ n ]; csum [ 0 ] = arr [ 0 ]; for ( int i = 1; i < n; i ++ ) csum [ i ] = csum [ i - 1 ] + arr [ i ]; int max_sum = csum [ k - 1 ], max_end = k - 1; for ( int i = k; i < n; i ++ ) { int curr_sum = csum [ [MASK] ] - csum [ i - k ]; if ( curr_sum > max_sum ) { max_sum = curr_sum; max_end = i; } } delete [ ] csum; return max_end - k + 1; } int f_filled ( int arr [ ], int n, int k ) {}csum [ i - k ];
if ( curr_sum > max_sum ) {
max_sum = curr_sum;
max_end = i;
}
}
delete [ ] csum;
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,4,6,19,21,23,32,34,47,51,56,57,57,65,68,68,69,70,71,73,74,74,77,77,79,82,82,86,87,87,88,89,90,91,92};
int param0_1[] = {24,62,-32,-28,42,-46,-96,-70,-68,60,44,34,-30,96,-26,92,62,42,-46,-38,44,54,-94,52,66,68,-96,-58,84,-2,66,30,42};
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};
int param0_3[] = {94,6,48,34,31};
int param0_4[] = {-98,-88,-82,-80,-76,-70,-70,-60,-60,-52,-50,-46,-44,-44,-44,-20,-18,-12,-12,-12,-10,-8,-6,-4,4,4,18,28,32,34,42,42,44,46,48,54,60,70,70,72,78,78,78,78,84,86,90,96,98};
int param0_5[] = {0,1,0,0,1,0,1,1,0,0,1,1,0,0,0,0,0};
int param0_6[] = {1,5,13,17,26,26,32,35,38,38,39,45,52,58,60,61,62,63,82,83,85,89,89,91};
int param0_7[] = {-68,-52,4,-90,90,88,38,-18,86,4,14,-32,-14,-44,-88,-50,-12,-26,-68,-20,-30,22,0,14,-40,58,-6,28,-44,8,28,96,-46,-12};
int param0_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param0_9[] = {17,33,36,34,32,10,37,48,47,32,21,18,75,8,18,52,21,73,25,25,80,32,10,24,1,89,7,42,86,85,73,12,20,20,1,74,77,4,24,74,8};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {29,23,32,4,45,15,13,32,13,20};
int param2[] = {20,31,31,3,30,8,22,22,11,28};
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) i",
"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 ( char str [] ) {
int sum = 0;
int n = strlen(str);
for ( int i = 0;
i < n;
i ++ ) sum += str [ i ] - '0';
return ( sum == n - 1 || sum == 1 );
}
bool f_filled ( char str [] ) {}
gold ( char str [] ) {
int sum = 0;
int n = strlen(str);
for ( int i = 0;
i < n;
i ++ ) sum += str [ i ] - '0';
return ( sum == n - 1 || sum == 1 );
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"00001","0000","11","111110","1","111010111010","hUInqJXNdbfP","5191","1110101101","NupSrU xz"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} bool f_gold ( char str [] ) { int sum = 0; int n = strlen(str); for ( int i = 0; i < n; i ++ ) sum += str [ i ] - '0'; return ( sum == n - 1 || sum == [MASK] ); } bool f_filled ( char str [] ) {}gold ( char str [] ) {
int sum = 0;
int n = strlen(str);
for ( int i = 0;
i < n;
i ++ ) sum += str [ i ] - '0';
return ( sum == n - 1 || sum == 1 );
}
bool f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"00001","0000","11","111110","1","111010111010","hUInqJXNdbfP","5191","1110101101","NupSrU xz"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | 1 | [
"a) void",
"b) mp",
"c) 1",
"d) <bits/stdc++.h>",
"e) <string>"
] | c |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( char str [] ) {
char temp [] = "";
int sum = 0;
for ( char ch : str ) {
if ( isdigit ( ch ) ) temp += ch;
else {
sum += atoi ( temp . c_str ( ) );
temp = "";
}
}
return sum + atoi ( temp . c_str ( ) );
}
int f_filled ( char str [] ) {}
) {
if ( isdigit ( ch ) ) temp += ch;
else {
sum += atoi ( temp . c_str ( ) );
temp = "";
}
}
return sum + atoi ( temp . c_str ( ) );
}
int f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"FpuZdXbJ","8248545127035","00101111101","WuaZuohxsww","77298","101110","HiHCWcmzqGMdE","9661651","000110100111","nwuNyyVBJFWvO"};
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 [MASK] * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( char str [] ) { char temp [] = ""; int sum = 0; for ( char ch : str ) { if ( isdigit ( ch ) ) temp += ch; else { sum += atoi ( temp . c_str ( ) ); temp = ""; } } return sum + atoi ( temp . c_str ( ) ); } int f_filled ( char str [] ) {}) {
if ( isdigit ( ch ) ) temp += ch;
else {
sum += atoi ( temp . c_str ( ) );
temp = "";
}
}
return sum + atoi ( temp . c_str ( ) );
}
int f_filled ( char str [] ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"FpuZdXbJ","8248545127035","00101111101","WuaZuohxsww","77298","101110","HiHCWcmzqGMdE","9661651","000110100111","nwuNyyVBJFWvO"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | void | [
"a) +",
"b) x",
"c) n",
"d) void",
"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 ) {
for ( int i = 0;
i < n;
i ++ ) if ( arr [ i ] & 1 ) arr [ i ] *= - 1;
sort ( arr, arr + n );
for ( int i = 0;
i < n;
i ++ ) if ( arr [ i ] & 1 ) arr [ i ] *= - 1;
}
void f_filled ( int arr [ ], int n ) {}
< n;
i ++ ) if ( arr [ i ] & 1 ) arr [ i ] *= - 1;
sort ( arr, arr + n );
for ( int i = 0;
i < n;
i ++ ) if ( arr [ i ] & 1 ) arr [ i ] *= - 1;
}
void f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4};
int param0_1[] = {8,-74,89,65,51,-15,68,51,23,44,89};
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};
int param0_3[] = {51,74,43,15,38,15,5,93};
int param0_4[] = {-96,-75,-64,-20,-5,-2,1,40,46,64};
int param0_5[] = {0,0,1,0,0,1,0,0,0};
int param0_6[] = {1,2,4,4,17,22,23,28,35,38,39,39,41,42,42,45,46,49,49,49,50,59,62,68,69,71,73,76,78,79,80,87,88,88,90,90,91,93,95,96,98};
int param0_7[] = {11,68,-52,-49,-57,-2,83,77,24,-20,85,11,43,-73,96,92,58,64,95,13,-14,14,24,-51,-24,-45,-44,96,-5,-56,59};
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};
int param0_9[] = {44,7,44,68,34,66,69,55,10,96,42,41,77,69,10,10,91,60,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[] = {0,8,28,6,7,5,34,24,14,13};
int filled_function_param0_0[] = {4};
int filled_function_param0_1[] = {8,-74,89,65,51,-15,68,51,23,44,89};
int filled_function_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};
int filled_function_param0_3[] = {51,74,43,15,38,15,5,93};
int filled_function_param0_4[] = {-96,-75,-64,-20,-5,-2,1,40,46,64};
int filled_function_param0_5[] = {0,0,1,0,0,1,0,0,0};
int filled_function_param0_6[] = {1,2,4,4,17,22,23,28,35,38,39,39,41,42,42,45,46,49,49,49,50,59,62,68,69,71,73,76,78,79,80,87,88,88,90,90,91,93,95,96,98};
int filled_function_param0_7[] = {11,68,-52,-49,-57,-2,83,77,24,-20,85,11,43,-73,96,92,58,64,95,13,-14,14,24,-51,-24,-45,-44,96,-5,-56,59};
int filled_function_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};
int filled_function_param0_9[] = {44,7,44,68,34,66,69,55,10,96,42,41,77,69,10,10,91,60,51};
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[] = {0,8,28,6,7,5,34,24,14,13};
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 ( [MASK] - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} void f_gold ( int arr [ ], int n ) { for ( int i = 0; i < n; i ++ ) if ( arr [ i ] & 1 ) arr [ i ] *= - 1; sort ( arr, arr + n ); for ( int i = 0; i < n; i ++ ) if ( arr [ i ] & 1 ) arr [ i ] *= - 1; } void f_filled ( int arr [ ], int n ) {}< n;
i ++ ) if ( arr [ i ] & 1 ) arr [ i ] *= - 1;
sort ( arr, arr + n );
for ( int i = 0;
i < n;
i ++ ) if ( arr [ i ] & 1 ) arr [ i ] *= - 1;
}
void f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4};
int param0_1[] = {8,-74,89,65,51,-15,68,51,23,44,89};
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};
int param0_3[] = {51,74,43,15,38,15,5,93};
int param0_4[] = {-96,-75,-64,-20,-5,-2,1,40,46,64};
int param0_5[] = {0,0,1,0,0,1,0,0,0};
int param0_6[] = {1,2,4,4,17,22,23,28,35,38,39,39,41,42,42,45,46,49,49,49,50,59,62,68,69,71,73,76,78,79,80,87,88,88,90,90,91,93,95,96,98};
int param0_7[] = {11,68,-52,-49,-57,-2,83,77,24,-20,85,11,43,-73,96,92,58,64,95,13,-14,14,24,-51,-24,-45,-44,96,-5,-56,59};
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};
int param0_9[] = {44,7,44,68,34,66,69,55,10,96,42,41,77,69,10,10,91,60,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[] = {0,8,28,6,7,5,34,24,14,13};
int filled_function_param0_0[] = {4};
int filled_function_param0_1[] = {8,-74,89,65,51,-15,68,51,23,44,89};
int filled_function_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};
int filled_function_param0_3[] = {51,74,43,15,38,15,5,93};
int filled_function_param0_4[] = {-96,-75,-64,-20,-5,-2,1,40,46,64};
int filled_function_param0_5[] = {0,0,1,0,0,1,0,0,0};
int filled_function_param0_6[] = {1,2,4,4,17,22,23,28,35,38,39,39,41,42,42,45,46,49,49,49,50,59,62,68,69,71,73,76,78,79,80,87,88,88,90,90,91,93,95,96,98};
int filled_function_param0_7[] = {11,68,-52,-49,-57,-2,83,77,24,-20,85,11,43,-73,96,92,58,64,95,13,-14,14,24,-51,-24,-45,-44,96,-5,-56,59};
int filled_function_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};
int filled_function_param0_9[] = {44,7,44,68,34,66,69,55,10,96,42,41,77,69,10,10,91,60,51};
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[] = {0,8,28,6,7,5,34,24,14,13};
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;
} | *(int*)a | [
"a) 2",
"b) *(int*)a",
"c) {return",
"d) public",
"e) False"
] | 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 k, int x [ ], int y [ ], int n ) {
int dis [ n ];
for ( int i = 0;
i < n;
i ++ ) dis [ i ] = x [ i ] * x [ i ] + y [ i ] * y [ i ];
sort ( dis, dis + n );
return dis [ k - 1 ];
}
int f_filled ( int k, int x [ ], int y [ ], int n ) {}
;
for ( int i = 0;
i < n;
i ++ ) dis [ i ] = x [ i ] * x [ i ] + y [ i ] * y [ i ];
sort ( dis, dis + n );
return dis [ k - 1 ];
}
int f_filled ( int k, int x [ ], int y [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,18,13,15,11,27,25,33,4,7};
int param1_0[] = {7,91};
int param1_1[] = {-44,32,-78,40,12,-54,-80,94,66,50,-52,20,84,-76,84,-90,-62,44,-26,-44,-12,-14,38,44,76,-60,98,-88,38,48,84,-76,-70,34};
int param1_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_3[] = {68,59,97,56,66,12,22,62,26,14,9,74,7,47,58,20,79,56,43,98,60,52,88,66,20,13,25,36,3};
int param1_4[] = {-82,-66,-56,-54,-36,-20,0,8,18,20,22,56,56,66,76,82,90,98};
int param1_5[] = {0,0,1,1,0,0,0,1,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,1,1,1,0,1,0,0,0};
int param1_6[] = {3,6,6,7,9,10,11,13,14,17,17,20,20,22,31,34,38,39,51,55,58,59,59,61,62,71,75,75,77,79,79,81,87,90,92,92,92,94,95,96};
int param1_7[] = {-60,6,-66,-84,-86,-26,-2,36,-40,4,8,4,70,-16,-46,-94,90,-68,54,42,50,96,-16,50,92,12,-34,-42,90,82,24,32,-84,-14,-6,-76,68,-20,-90,12,14,54,-98,-34,20,46,-32,44,-34};
int param1_8[] = {0,0,0,0,1,1,1};
int param1_9[] = {58,81,35,53,29,76,58,77,21,39,1,49,77,43,88};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2_0[] = {15,83};
int param2_1[] = {74,26,-28,-86,-98,44,82,-2,-56,4,90,-14,-22,50,-14,8,-58,-70,84,-24,-54,82,66,60,52,2,-54,2,42,-8,88,22,-68,20};
int param2_2[] = {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param2_3[] = {47,12,60,97,28,75,81,14,31,69,66,60,77,20,11,78,4,52,47,67,11,50,89,23,81,62,53,95,14};
int param2_4[] = {-88,-72,-56,-44,-44,-30,-24,-12,-10,-4,4,6,8,34,56,72,74,94};
int param2_5[] = {0,1,0,1,0,0,1,1,1,0,1,0,0,0,0,1,1,0,1,1,1,1,0,0,1,0,1,0,0,0,1,1,0,0,0,1};
int param2_6[] = {2,3,5,11,13,14,16,17,17,17,18,18,23,24,27,33,37,41,42,45,47,47,56,58,61,65,67,68,71,72,75,76,78,83,86,92,93,94,96,96};
int param2_7[] = {12,52,66,-58,94,36,-92,-2,-78,80,-90,20,-40,32,76,-68,64,52,80,-76,-48,36,-46,6,74,70,-4,-26,96,-10,50,-94,-88,56,-88,54,-42,-34,-66,14,-78,32,-32,90,-68,-18,-26,-56,-8};
int param2_8[] = {0,1,1,1,1,1,1};
int param2_9[] = {88,77,5,55,78,80,70,2,68,63,80,85,81,67,88};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {1,25,17,28,14,25,33,26,3,12};
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, [MASK] sizeof(int), cmpfunc);} int f_gold ( int k, int x [ ], int y [ ], int n ) { int dis [ n ]; for ( int i = 0; i < n; i ++ ) dis [ i ] = x [ i ] * x [ i ] + y [ i ] * y [ i ]; sort ( dis, dis + n ); return dis [ k - 1 ]; } int f_filled ( int k, int x [ ], int y [ ], int n ) {};
for ( int i = 0;
i < n;
i ++ ) dis [ i ] = x [ i ] * x [ i ] + y [ i ] * y [ i ];
sort ( dis, dis + n );
return dis [ k - 1 ];
}
int f_filled ( int k, int x [ ], int y [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {1,18,13,15,11,27,25,33,4,7};
int param1_0[] = {7,91};
int param1_1[] = {-44,32,-78,40,12,-54,-80,94,66,50,-52,20,84,-76,84,-90,-62,44,-26,-44,-12,-14,38,44,76,-60,98,-88,38,48,84,-76,-70,34};
int param1_2[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_3[] = {68,59,97,56,66,12,22,62,26,14,9,74,7,47,58,20,79,56,43,98,60,52,88,66,20,13,25,36,3};
int param1_4[] = {-82,-66,-56,-54,-36,-20,0,8,18,20,22,56,56,66,76,82,90,98};
int param1_5[] = {0,0,1,1,0,0,0,1,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,1,1,1,0,1,0,0,0};
int param1_6[] = {3,6,6,7,9,10,11,13,14,17,17,20,20,22,31,34,38,39,51,55,58,59,59,61,62,71,75,75,77,79,79,81,87,90,92,92,92,94,95,96};
int param1_7[] = {-60,6,-66,-84,-86,-26,-2,36,-40,4,8,4,70,-16,-46,-94,90,-68,54,42,50,96,-16,50,92,12,-34,-42,90,82,24,32,-84,-14,-6,-76,68,-20,-90,12,14,54,-98,-34,20,46,-32,44,-34};
int param1_8[] = {0,0,0,0,1,1,1};
int param1_9[] = {58,81,35,53,29,76,58,77,21,39,1,49,77,43,88};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2_0[] = {15,83};
int param2_1[] = {74,26,-28,-86,-98,44,82,-2,-56,4,90,-14,-22,50,-14,8,-58,-70,84,-24,-54,82,66,60,52,2,-54,2,42,-8,88,22,-68,20};
int param2_2[] = {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param2_3[] = {47,12,60,97,28,75,81,14,31,69,66,60,77,20,11,78,4,52,47,67,11,50,89,23,81,62,53,95,14};
int param2_4[] = {-88,-72,-56,-44,-44,-30,-24,-12,-10,-4,4,6,8,34,56,72,74,94};
int param2_5[] = {0,1,0,1,0,0,1,1,1,0,1,0,0,0,0,1,1,0,1,1,1,1,0,0,1,0,1,0,0,0,1,1,0,0,0,1};
int param2_6[] = {2,3,5,11,13,14,16,17,17,17,18,18,23,24,27,33,37,41,42,45,47,47,56,58,61,65,67,68,71,72,75,76,78,83,86,92,93,94,96,96};
int param2_7[] = {12,52,66,-58,94,36,-92,-2,-78,80,-90,20,-40,32,76,-68,64,52,80,-76,-48,36,-46,6,74,70,-4,-26,96,-10,50,-94,-88,56,-88,54,-42,-34,-66,14,-78,32,-32,90,-68,-18,-26,-56,-8};
int param2_8[] = {0,1,1,1,1,1,1};
int param2_9[] = {88,77,5,55,78,80,70,2,68,63,80,85,81,67,88};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {1,25,17,28,14,25,33,26,3,12};
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;
} | n, | [
"a) if",
"b) i",
"c) }",
"d) [",
"e) n,"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int W, int wt [ ], int val [ ], int n ) {
if ( n == 0 || W == 0 ) return 0;
if ( wt [ n - 1 ] > W ) return f_gold ( W, wt, val, n - 1 );
else return max ( val [ n - 1 ] + f_gold ( W - wt [ n - 1 ], wt, val, n - 1 ), f_gold ( W, wt, val, n - 1 ) );
}
int f_filled ( int W, int wt [ ], int val [ ], int n ) {}
( W, wt, val, n - 1 );
else return max ( val [ n - 1 ] + f_gold ( W - wt [ n - 1 ], wt, val, n - 1 ), f_gold ( W, wt, val, n - 1 ) );
}
int f_filled ( int W, int wt [ ], int val [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {5,9,26,7,46,28,25,9,13,4};
int param1_0[] = {6,14,18,36,40,47,54,58};
int param1_1[] = {42,60,-4,24,54,42,-72,-92,48,-94,-36,18};
int param1_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};
int param1_3[] = {56,53,85,73,93,75,21,22,39,13,92};
int param1_4[] = {-96,-96,-94,-84,-78,-76,-74,-74,-72,-70,-70,-50,-48,-38,-30,-28,-28,-24,-14,-10,-4,-2,6,6,18,28,30,30,34,36,42,48,50,52,54,58,58,60,62,74,74,86,86,88,88,94,96,96,98};
int param1_5[] = {1,1,0,1,0,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,0};
int param1_6[] = {7,16,18,21,22,26,30,32,34,37,37,38,39,40,44,54,55,56,56,58,59,60,62,62,64,66,75,80,82,83,84,85,88,89,89,90,93,96,97};
int param1_7[] = {64,-38,76,-24,-10,78,-76,78,-32,20};
int param1_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param1_9[] = {10,87,55,78,11};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2_0[] = {9,15,23,24,41,45,50,92};
int param2_1[] = {-20,56,20,-82,84,-90,54,50,82,92,-32,6};
int param2_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};
int param2_3[] = {17,27,34,86,49,89,79,70,32,23,64};
int param2_4[] = {-92,-72,-72,-68,-60,-58,-52,-48,-46,-46,-44,-44,-42,-36,-32,-30,-30,-24,-22,-18,-16,-8,-6,-6,-4,-2,6,8,16,20,20,30,32,32,36,40,42,44,44,46,54,56,56,58,82,82,86,90,90};
int param2_5[] = {1,0,0,1,1,1,0,1,0,1,1,0,1,0,1,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0};
int param2_6[] = {1,7,9,10,11,21,23,25,29,32,35,35,35,36,37,38,42,47,47,48,51,52,55,58,64,70,72,73,74,76,77,80,86,91,92,92,92,92,96};
int param2_7[] = {64,50,-78,78,78,44,-14,-70,-76,90};
int param2_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param2_9[] = {29,43,93,2,42};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {7,7,15,9,28,21,31,6,14,2};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i]) == f_gold(param0[i],param1[i],param2[i],param3[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int [MASK] [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int W, int wt [ ], int val [ ], int n ) { if ( n == 0 || W == 0 ) return 0; if ( wt [ n - 1 ] > W ) return f_gold ( W, wt, val, n - 1 ); else return max ( val [ n - 1 ] + f_gold ( W - wt [ n - 1 ], wt, val, n - 1 ), f_gold ( W, wt, val, n - 1 ) ); } int f_filled ( int W, int wt [ ], int val [ ], int n ) {}( W, wt, val, n - 1 );
else return max ( val [ n - 1 ] + f_gold ( W - wt [ n - 1 ], wt, val, n - 1 ), f_gold ( W, wt, val, n - 1 ) );
}
int f_filled ( int W, int wt [ ], int val [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0[] = {5,9,26,7,46,28,25,9,13,4};
int param1_0[] = {6,14,18,36,40,47,54,58};
int param1_1[] = {42,60,-4,24,54,42,-72,-92,48,-94,-36,18};
int param1_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};
int param1_3[] = {56,53,85,73,93,75,21,22,39,13,92};
int param1_4[] = {-96,-96,-94,-84,-78,-76,-74,-74,-72,-70,-70,-50,-48,-38,-30,-28,-28,-24,-14,-10,-4,-2,6,6,18,28,30,30,34,36,42,48,50,52,54,58,58,60,62,74,74,86,86,88,88,94,96,96,98};
int param1_5[] = {1,1,0,1,0,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,0};
int param1_6[] = {7,16,18,21,22,26,30,32,34,37,37,38,39,40,44,54,55,56,56,58,59,60,62,62,64,66,75,80,82,83,84,85,88,89,89,90,93,96,97};
int param1_7[] = {64,-38,76,-24,-10,78,-76,78,-32,20};
int param1_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param1_9[] = {10,87,55,78,11};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2_0[] = {9,15,23,24,41,45,50,92};
int param2_1[] = {-20,56,20,-82,84,-90,54,50,82,92,-32,6};
int param2_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};
int param2_3[] = {17,27,34,86,49,89,79,70,32,23,64};
int param2_4[] = {-92,-72,-72,-68,-60,-58,-52,-48,-46,-46,-44,-44,-42,-36,-32,-30,-30,-24,-22,-18,-16,-8,-6,-6,-4,-2,6,8,16,20,20,30,32,32,36,40,42,44,44,46,54,56,56,58,82,82,86,90,90};
int param2_5[] = {1,0,0,1,1,1,0,1,0,1,1,0,1,0,1,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0};
int param2_6[] = {1,7,9,10,11,21,23,25,29,32,35,35,35,36,37,38,42,47,47,48,51,52,55,58,64,70,72,73,74,76,77,80,86,91,92,92,92,92,96};
int param2_7[] = {64,50,-78,78,78,44,-14,-70,-76,90};
int param2_8[] = {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1};
int param2_9[] = {29,43,93,2,42};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {7,7,15,9,28,21,31,6,14,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;
} | arr | [
"a) import",
"b) <",
"c) ]",
"d) if",
"e) arr"
] | 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 idx ) {
int result = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] < arr [ idx ] ) result ++;
if ( arr [ i ] == arr [ idx ] && i < idx ) result ++;
}
return result;
}
int f_filled ( int arr [ ], int n, int idx ) {}
i < n;
i ++ ) {
if ( arr [ i ] < arr [ idx ] ) result ++;
if ( arr [ i ] == arr [ idx ] && i < idx ) result ++;
}
return result;
}
int f_filled ( int arr [ ], int n, int idx ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,8,9,12,15,16,18,28,28,31,33,36,36,37,40,41,44,44,46,50,50,50,52,52,54,55,60,61,65,68,71,75,75,78,81,84,87,89,90,92,94,97,97,98,98,99};
int param0_1[] = {-16,86,94,-86,-38,64,96,-64,94,10,-10,-62,-50,-46,-62,-32,-4,72,14,36,74,-66,46,82,-44,-22,-26,16,-8,0,-90,94,-50,22,-82,8,92,-84,-34,-36,-66};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {66,8,30,84,36,96,45,63,23,23,14,34,86,51,18,97,21,39,96,70,28,96,78,68,88,66,13,24,74,94};
int param0_4[] = {-94,-90,-86,-86,-72,-72,-58,-50,-32,-22,-18,-10,-4,-2,-2,0,0,6,14,22,22,36,36,40,44,58,60,70,70,76,82,82,84,88,96};
int param0_5[] = {1,1,1,0,0,1,0,1,0,0,0,0,1,0,1,1,0,1,0,1,0,0,1,0,0,1,1,1,1,1,1,1,0,1,1,1,0,1,1};
int param0_6[] = {3,5,6,7,8,10,17,20,20,26,27,27,27,32,32,38,40,44,45,45,45,45,47,50,57,57,57,58,62,63,63,67,68,73,75,76,77,79,79,80,85,88,89,89,89,94,96,98};
int param0_7[] = {98,-92,18,-18,44,-88,-90,-66,-38,78,-22,-46,-20,64,-10,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,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {14,17};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {37,31,30,26,17,30,42,14,19,1};
int param2[] = {32,27,34,21,31,36,35,12,31,1};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int [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 arr [ ], int n, int idx ) { int result = 0; for ( int i = 0; i < n; i ++ ) { if ( arr [ i ] < arr [ idx ] ) result ++; if ( arr [ i ] == arr [ idx ] && i < idx ) result ++; } return result; } int f_filled ( int arr [ ], int n, int idx ) {}
i < n;
i ++ ) {
if ( arr [ i ] < arr [ idx ] ) result ++;
if ( arr [ i ] == arr [ idx ] && i < idx ) result ++;
}
return result;
}
int f_filled ( int arr [ ], int n, int idx ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,8,9,12,15,16,18,28,28,31,33,36,36,37,40,41,44,44,46,50,50,50,52,52,54,55,60,61,65,68,71,75,75,78,81,84,87,89,90,92,94,97,97,98,98,99};
int param0_1[] = {-16,86,94,-86,-38,64,96,-64,94,10,-10,-62,-50,-46,-62,-32,-4,72,14,36,74,-66,46,82,-44,-22,-26,16,-8,0,-90,94,-50,22,-82,8,92,-84,-34,-36,-66};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {66,8,30,84,36,96,45,63,23,23,14,34,86,51,18,97,21,39,96,70,28,96,78,68,88,66,13,24,74,94};
int param0_4[] = {-94,-90,-86,-86,-72,-72,-58,-50,-32,-22,-18,-10,-4,-2,-2,0,0,6,14,22,22,36,36,40,44,58,60,70,70,76,82,82,84,88,96};
int param0_5[] = {1,1,1,0,0,1,0,1,0,0,0,0,1,0,1,1,0,1,0,1,0,0,1,0,0,1,1,1,1,1,1,1,0,1,1,1,0,1,1};
int param0_6[] = {3,5,6,7,8,10,17,20,20,26,27,27,27,32,32,38,40,44,45,45,45,45,47,50,57,57,57,58,62,63,63,67,68,73,75,76,77,79,79,80,85,88,89,89,89,94,96,98};
int param0_7[] = {98,-92,18,-18,44,-88,-90,-66,-38,78,-22,-46,-20,64,-10,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,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {14,17};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {37,31,30,26,17,30,42,14,19,1};
int param2[] = {32,27,34,21,31,36,35,12,31,1};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | y) | [
"a) longest_start",
"b) class",
"c) ],",
"d) y)",
"e) arr"
] | 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 msis [ n ], msds [ n ];
int max_sum = INT_MIN;
msis [ 0 ] = arr [ 0 ];
for ( int i = 1;
i < n;
i ++ ) if ( arr [ i ] > arr [ i - 1 ] ) msis [ i ] = msis [ i - 1 ] + arr [ i ];
else msis [ i ] = arr [ i ];
msds [ n - 1 ] = arr [ n - 1 ];
for ( int i = n - 2;
i >= 0;
i -- ) if ( arr [ i ] > arr [ i + 1 ] ) msds [ i ] = msds [ i + 1 ] + arr [ i ];
else msds [ i ] = arr [ i ];
for ( int i = 0;
i < n;
i ++ ) if ( max_sum < ( msis [ i ] + msds [ i ] - arr [ i ] ) ) max_sum = msis [ i ] + msds [ i ] - arr [ i ];
return max_sum;
}
int f_filled ( int arr [ ], int n ) {}
r ( int i = 0;
i < n;
i ++ ) if ( max_sum < ( msis [ i ] + msds [ i ] - arr [ i ] ) ) max_sum = msis [ i ] + msds [ i ] - arr [ i ];
return max_sum;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,12,16,23,26,27,39,39,40,44,57,58,77,78,81,82,84,86,91,94,94,95,97};
int param0_1[] = {72,38,-60,98,-52,-38,-2,94,34,56,90,46,6,-2,30,-96,-76,-96,-76,32,68,64,-32,-4,72,-62,58,20,-84,0,-96,70,-22,-56,70,-74,-90,-86,-14,82,-90,40,-64,94};
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};
int param0_3[] = {69,31,85,84,28,28};
int param0_4[] = {-80,-74,-24,-22,-22,4,20,28,30,32,36,58,58,68,92,94,98};
int param0_5[] = {1,1,0,0,0,1,0,1,1,1,1};
int param0_6[] = {2,2,2,4,6,7,8,10,15,17,19,20,21,27,28,29,32,32,40,44,46,47,49,50,50,52,55,56,58,59,64,69,73,74,74,77,80,80,84,89,91,95,96,96,97,98,98,99};
int param0_7[] = {26,-86,8,64,-40,64,60,-16,54,-42,-86,14,-48,-20,-42,-4,-34,-52,-74,22,10};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {8,5,5,56,5,38};
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,37,33,5,16,10,46,18,27,3};
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 msis [ n ], msds [ n ]; int max_sum = INT_MIN; msis [ 0 ] = arr [ 0 ]; for ( int i = 1; i < n; i ++ ) if ( arr [ i ] > arr [ i - 1 ] ) msis [ i ] = msis [ i - 1 ] + arr [ i ]; else msis [ i ] = arr [ i ]; msds [ n - 1 ] = arr [ n - 1 ]; for ( int i = n - 2; i >= 0; i -- ) if ( arr [ i ] > arr [ i + 1 ] ) msds [ i ] = msds [ i + 1 ] + arr [ i ]; else msds [ i ] = arr [ i ]; for ( int i = 0; i < n; i ++ ) if ( max_sum < ( msis [ i ] + msds [ i ] - arr [ i ] ) ) max_sum = msis [ i ] + msds [ i ] - arr [ [MASK] ]; return max_sum; } int f_filled ( int arr [ ], int n ) {}r ( int i = 0;
i < n;
i ++ ) if ( max_sum < ( msis [ i ] + msds [ i ] - arr [ i ] ) ) max_sum = msis [ i ] + msds [ i ] - arr [ i ];
return max_sum;
}
int f_filled ( int arr [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {7,12,16,23,26,27,39,39,40,44,57,58,77,78,81,82,84,86,91,94,94,95,97};
int param0_1[] = {72,38,-60,98,-52,-38,-2,94,34,56,90,46,6,-2,30,-96,-76,-96,-76,32,68,64,-32,-4,72,-62,58,20,-84,0,-96,70,-22,-56,70,-74,-90,-86,-14,82,-90,40,-64,94};
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};
int param0_3[] = {69,31,85,84,28,28};
int param0_4[] = {-80,-74,-24,-22,-22,4,20,28,30,32,36,58,58,68,92,94,98};
int param0_5[] = {1,1,0,0,0,1,0,1,1,1,1};
int param0_6[] = {2,2,2,4,6,7,8,10,15,17,19,20,21,27,28,29,32,32,40,44,46,47,49,50,50,52,55,56,58,59,64,69,73,74,74,77,80,80,84,89,91,95,96,96,97,98,98,99};
int param0_7[] = {26,-86,8,64,-40,64,60,-16,54,-42,-86,14,-48,-20,-42,-4,-34,-52,-74,22,10};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_9[] = {8,5,5,56,5,38};
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,37,33,5,16,10,46,18,27,3};
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) 1",
"b) i",
"c) int",
"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 a [ ], int n ) {
unordered_map < int, int > mp;
for ( int i = 0;
i < n;
i ++ ) mp [ a [ i ] ] ++;
for ( auto x : mp ) if ( x . second >= n / 2 ) return true;
return false;
}
bool f_filled ( int a [ ], int n ) {}
_map < int, int > mp;
for ( int i = 0;
i < n;
i ++ ) mp [ a [ i ] ] ++;
for ( auto x : mp ) if ( x . second >= n / 2 ) return true;
return false;
}
bool f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {6,14,20,26,32,33,34,35,35,49,51,55,57,64,64,68,70,72,74,77,78,78,78,80,91,91,94};
int param0_1[] = {-14,-98,-36,68,-20,18,16,-50,66,98,12,-2,-68};
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};
int param0_3[] = {29,96,94,67,87,65,27,21,60,49,73,85,9,17,72,3,73,69,95,3,30,88,54,94,40};
int param0_4[] = {-86,-80,-76,-76,-74,-62,-62,-56,-48,-36,-28,-22,-18,-18,-18,-16,-14,-12,-6,-2,10,14,18,24,32,32,40,40,40,42,46,48,50,56,56,56,68,76,84,94,96,96};
int param0_5[] = {0,1,1,1,0};
int param0_6[] = {5,8,9,12,14,16,19,29,32,32,37,38,38,39,40,41,43,45,47,51,53,58,58,63,64,65,69,83,84,86,92,93,96,98};
int param0_7[] = {-68,-50,-20,22,90,86,4,60,-88,82,-4,-54,36,-44,86};
int param0_8[] = {0,0,0,0,1,1,1,1};
int param0_9[] = {85,64,25,64,46,35,31,45,93,81,49,33,96,48,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[] = {15,11,22,15,23,3,17,13,6,13};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) [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);} bool f_gold ( int a [ ], int n ) { unordered_map < int, int > mp; for ( int i = 0; i < n; i ++ ) mp [ a [ i ] ] ++; for ( auto x : mp ) if ( x . second >= n / 2 ) return true; return false; } bool f_filled ( int a [ ], int n ) {}_map < int, int > mp;
for ( int i = 0;
i < n;
i ++ ) mp [ a [ i ] ] ++;
for ( auto x : mp ) if ( x . second >= n / 2 ) return true;
return false;
}
bool f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {6,14,20,26,32,33,34,35,35,49,51,55,57,64,64,68,70,72,74,77,78,78,78,80,91,91,94};
int param0_1[] = {-14,-98,-36,68,-20,18,16,-50,66,98,12,-2,-68};
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};
int param0_3[] = {29,96,94,67,87,65,27,21,60,49,73,85,9,17,72,3,73,69,95,3,30,88,54,94,40};
int param0_4[] = {-86,-80,-76,-76,-74,-62,-62,-56,-48,-36,-28,-22,-18,-18,-18,-16,-14,-12,-6,-2,10,14,18,24,32,32,40,40,40,42,46,48,50,56,56,56,68,76,84,94,96,96};
int param0_5[] = {0,1,1,1,0};
int param0_6[] = {5,8,9,12,14,16,19,29,32,32,37,38,38,39,40,41,43,45,47,51,53,58,58,63,64,65,69,83,84,86,92,93,96,98};
int param0_7[] = {-68,-50,-20,22,90,86,4,60,-88,82,-4,-54,36,-44,86};
int param0_8[] = {0,0,0,0,1,1,1,1};
int param0_9[] = {85,64,25,64,46,35,31,45,93,81,49,33,96,48,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[] = {15,11,22,15,23,3,17,13,6,13};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | { | [
"a) return",
"b) i",
"c) {",
"d) return",
"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 x ) {
return ( x << 1 ) + x + ( x >> 1 );
}
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 ( x << 1 ) + x + ( x >> 1 );
}
int f_filled ( int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {58,16,82,33,88,51,81,38,79,89};
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 x ) { return ( x << 1 ) + x + ( [MASK] >> 1 ); } 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 ( x << 1 ) + x + ( x >> 1 );
}
int f_filled ( int x ) {}
int main(void) {
int n_success = 0;
int param0[] = {58,16,82,33,88,51,81,38,79,89};
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) int",
"b) int",
"c) {",
"d) (",
"e) x"
] | e |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
char f_gold [] ( char str [], int k ) {
char palin [] = str;
int l = 0;
int r = strlen(str) - 1;
while ( l < r ) {
if ( str [ l ] != str [ r ] ) {
palin [ l ] = palin [ r ] = max ( str [ l ], str [ r ] );
k --;
}
l ++;
r --;
}
if ( k < 0 ) return "Not possible";
l = 0;
r = strlen(str) - 1;
while ( l <= r ) {
if ( l == r ) {
if ( k > 0 ) palin [ l ] = '9';
}
if ( palin [ l ] < '9' ) {
if ( k >= 2 && palin [ l ] == str [ l ] && palin [ r ] == str [ r ] ) {
k -= 2;
palin [ l ] = palin [ r ] = '9';
}
else if ( k >= 1 && ( palin [ l ] != str [ l ] || palin [ r ] != str [ r ] ) ) {
k --;
palin [ l ] = palin [ r ] = '9';
}
}
l ++;
r --;
}
return palin;
}
char f_filled [] ( char str [], int k ) {}
r [ l ] || palin [ r ] != str [ r ] ) ) {
k --;
palin [ l ] = palin [ r ] = '9';
}
}
l ++;
r --;
}
return palin;
}
char f_filled [] ( char str [], int k ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"wUJmbRlwogtFv","43435","43435","12345","5032","0100000001101","sBrbNQiRwQd","7549384614","10000001","VqrTsaoD"};
int param1[] = {5,3,1,1,3,5,4,3,4,4};
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 str [], int k ) { char palin [] = str; int l = 0; int r = strlen(str) - 1; while ( l < r ) { if ( str [ l ] != str [ r ] ) { palin [ l ] = palin [ r ] = max ( str [ l ], str [ r ] ); k --; } l ++; r --; } if ( k < 0 ) return [MASK] possible"; l = 0; r = strlen(str) - 1; while ( l <= r ) { if ( l == r ) { if ( k > 0 ) palin [ l ] = '9'; } if ( palin [ l ] < '9' ) { if ( k >= 2 && palin [ l ] == str [ l ] && palin [ r ] == str [ r ] ) { k -= 2; palin [ l ] = palin [ r ] = '9'; } else if ( k >= 1 && ( palin [ l ] != str [ l ] || palin [ r ] != str [ r ] ) ) { k --; palin [ l ] = palin [ r ] = '9'; } } l ++; r --; } return palin; } char f_filled [] ( char str [], int k ) {}r [ l ] || palin [ r ] != str [ r ] ) ) {
k --;
palin [ l ] = palin [ r ] = '9';
}
}
l ++;
r --;
}
return palin;
}
char f_filled [] ( char str [], int k ) {}
int main(void) {
int n_success = 0;
char param0[][100] = {"wUJmbRlwogtFv","43435","43435","12345","5032","0100000001101","sBrbNQiRwQd","7549384614","10000001","VqrTsaoD"};
int param1[] = {5,3,1,1,3,5,4,3,4,4};
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;
} | "Not | [
"a) 0",
"b) +",
"c) =",
"d) \"Not",
"e) arr"
] | 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 stack1 [ ], int stack2 [ ], int stack3 [ ], int n1, int n2, int n3 ) {
int sum1 = 0, sum2 = 0, sum3 = 0;
for ( int i = 0;
i < n1;
i ++ ) sum1 += stack1 [ i ];
for ( int i = 0;
i < n2;
i ++ ) sum2 += stack2 [ i ];
for ( int i = 0;
i < n3;
i ++ ) sum3 += stack3 [ i ];
int top1 = 0, top2 = 0, top3 = 0;
int ans = 0;
while ( 1 ) {
if ( top1 == n1 || top2 == n2 || top3 == n3 ) return 0;
if ( sum1 == sum2 && sum2 == sum3 ) return sum1;
if ( sum1 >= sum2 && sum1 >= sum3 ) sum1 -= stack1 [ top1 ++ ];
else if ( sum2 >= sum3 && sum2 >= sum3 ) sum2 -= stack2 [ top2 ++ ];
else if ( sum3 >= sum2 && sum3 >= sum1 ) sum3 -= stack3 [ top3 ++ ];
}
}
int f_filled ( int stack1 [ ], int stack2 [ ], int stack3 [ ], int n1, int n2, int n3 ) {}
m2 -= stack2 [ top2 ++ ];
else if ( sum3 >= sum2 && sum3 >= sum1 ) sum3 -= stack3 [ top3 ++ ];
}
}
int f_filled ( int stack1 [ ], int stack2 [ ], int stack3 [ ], int n1, int n2, int n3 ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,10,11,24,27,33,34,36,36,40,42,43,52,58,67,69,77,86,86,88};
int param0_1[] = {40,54,14,58,-64,-60,-98,-64,-52,30,0,-42,74,46,-14,76,84,74,-24,30,96,88,-98,82,44,-86,-92,-52,28,62};
int param0_2[] = {0,0};
int param0_3[] = {64,40,45,93,30,79,24,95,1,84,74,5,9,6,22,33,10,53,33,9,31,21,22,77,21,93,86,68,92,57,27,82,87,11,51,2,27,2,24,57,20,2,32,43};
int param0_4[] = {-94,-50,-24,-12,-6,-6,8,26,28,44};
int param0_5[] = {1,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,0,1,0,0,1,1,0,1,0,0,1,1,1,1,0,1,1,0,1,0,1,1,1,0,1};
int param0_6[] = {3,3,4,5,9,18,21,22,25,27,28,33,35,39,39,43,57,58,59,63,65,65,72,77,78,78,80,80,88,92,99};
int param0_7[] = {40,28,-84,-38,82,2,38,10,-10,20,-54,48,56,38,-98,68,-8,-30,-96,-16,28,94,-52,28,34,68,-46,44,-28,-52,-48,-14,-30,24,56,8,-30,-46,18,-68,86,-12};
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};
int param0_9[] = {22,31,75,48,30,39,82,93,26,87,77,87,67,88,19,51,54,48,6,37,38,27};
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,13,34,40,41,47,47,52,55,62,66,66,69,70,73,74,75,76,85,98};
int param1_1[] = {24,34,-52,50,-8,-48,-28,68,-12,-26,0,6,-76,-94,-12,8,38,-88,30,98,-78,-54,-48,42,26,-76,4,46,26,60};
int param1_2[] = {1,1};
int param1_3[] = {48,85,55,12,24,26,88,76,15,34,23,61,2,99,11,37,65,74,92,96,68,50,67,98,89,17,62,18,51,61,41,41,90,64,89,51,48,95,9,86,28,54,64,35};
int param1_4[] = {-96,-94,-86,-70,-52,-18,-6,20,52,52};
int param1_5[] = {1,0,0,0,0,0,1,0,0,0,1,1,0,1,0,0,1,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1,0,1,0,1,1};
int param1_6[] = {3,17,18,23,24,24,26,28,34,48,53,54,56,61,64,67,69,74,77,79,79,81,81,82,84,84,85,86,88,92,96};
int param1_7[] = {26,24,-50,18,78,-90,62,88,-36,-96,78,6,-94,-2,-28,-38,66,72,-36,14,-48,-64,-24,82,92,-16,-26,-12,6,34,30,-46,48,-22,34,-64,4,-32,84,-20,32,-22};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {18,20,53,87,85,63,6,81,89,82,43,76,59,60,79,96,29,65,5,56,96,95};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2_0[] = {6,8,10,12,14,29,41,52,53,54,55,66,69,73,77,77,78,80,90,99};
int param2_1[] = {-8,-24,54,28,92,94,0,62,28,80,82,2,88,-4,-28,80,44,34,-98,36,28,76,-48,40,98,4,22,-36,-20,-70};
int param2_2[] = {0,0};
int param2_3[] = {99,77,11,20,33,91,5,68,75,67,37,70,59,26,2,62,6,97,95,38,46,89,29,61,27,93,26,74,98,85,91,92,40,97,58,44,20,57,65,62,65,26,74,58};
int param2_4[] = {-70,-40,-22,4,12,12,38,54,72,74};
int param2_5[] = {0,0,1,1,0,0,0,0,1,0,0,0,0,0,1,1,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,0,1,1,1,0,0,1,0};
int param2_6[] = {1,3,5,8,15,16,27,27,27,28,29,30,32,35,36,37,44,47,57,65,69,70,70,76,76,83,85,87,88,90,92};
int param2_7[] = {66,26,-90,-40,-52,-98,84,88,40,-92,30,28,32,92,18,-34,-42,64,-34,70,-72,28,44,34,76,-78,46,-48,20,54,-2,66,6,56,52,-98,-48,-70,-60,94,90,10};
int param2_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};
int param2_9[] = {10,76,49,36,41,18,60,44,81,34,56,7,13,83,82,16,7,38,33,55,91,54};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {10,26,1,42,5,39,24,32,16,19};
int param4[] = {12,28,1,27,5,34,16,37,23,16};
int param5[] = {18,15,1,31,5,26,29,41,22,17};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i],param4[i],param5[i]) == f_gold(param0[i],param1[i],param2[i],param3[i],param4[i],param5[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | #include <stdio.h> #include <math.h> #include <stdlib.h> #include <limits.h> #include <stdbool.h> int min(int x, int y) { return (x < y)? x: y; } int max(int x, int y) { [MASK] (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );} int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));} void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);} int f_gold ( int stack1 [ ], int stack2 [ ], int stack3 [ ], int n1, int n2, int n3 ) { int sum1 = 0, sum2 = 0, sum3 = 0; for ( int i = 0; i < n1; i ++ ) sum1 += stack1 [ i ]; for ( int i = 0; i < n2; i ++ ) sum2 += stack2 [ i ]; for ( int i = 0; i < n3; i ++ ) sum3 += stack3 [ i ]; int top1 = 0, top2 = 0, top3 = 0; int ans = 0; while ( 1 ) { if ( top1 == n1 || top2 == n2 || top3 == n3 ) return 0; if ( sum1 == sum2 && sum2 == sum3 ) return sum1; if ( sum1 >= sum2 && sum1 >= sum3 ) sum1 -= stack1 [ top1 ++ ]; else if ( sum2 >= sum3 && sum2 >= sum3 ) sum2 -= stack2 [ top2 ++ ]; else if ( sum3 >= sum2 && sum3 >= sum1 ) sum3 -= stack3 [ top3 ++ ]; } } int f_filled ( int stack1 [ ], int stack2 [ ], int stack3 [ ], int n1, int n2, int n3 ) {}m2 -= stack2 [ top2 ++ ];
else if ( sum3 >= sum2 && sum3 >= sum1 ) sum3 -= stack3 [ top3 ++ ];
}
}
int f_filled ( int stack1 [ ], int stack2 [ ], int stack3 [ ], int n1, int n2, int n3 ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,10,11,24,27,33,34,36,36,40,42,43,52,58,67,69,77,86,86,88};
int param0_1[] = {40,54,14,58,-64,-60,-98,-64,-52,30,0,-42,74,46,-14,76,84,74,-24,30,96,88,-98,82,44,-86,-92,-52,28,62};
int param0_2[] = {0,0};
int param0_3[] = {64,40,45,93,30,79,24,95,1,84,74,5,9,6,22,33,10,53,33,9,31,21,22,77,21,93,86,68,92,57,27,82,87,11,51,2,27,2,24,57,20,2,32,43};
int param0_4[] = {-94,-50,-24,-12,-6,-6,8,26,28,44};
int param0_5[] = {1,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,0,1,0,0,1,1,0,1,0,0,1,1,1,1,0,1,1,0,1,0,1,1,1,0,1};
int param0_6[] = {3,3,4,5,9,18,21,22,25,27,28,33,35,39,39,43,57,58,59,63,65,65,72,77,78,78,80,80,88,92,99};
int param0_7[] = {40,28,-84,-38,82,2,38,10,-10,20,-54,48,56,38,-98,68,-8,-30,-96,-16,28,94,-52,28,34,68,-46,44,-28,-52,-48,-14,-30,24,56,8,-30,-46,18,-68,86,-12};
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};
int param0_9[] = {22,31,75,48,30,39,82,93,26,87,77,87,67,88,19,51,54,48,6,37,38,27};
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,13,34,40,41,47,47,52,55,62,66,66,69,70,73,74,75,76,85,98};
int param1_1[] = {24,34,-52,50,-8,-48,-28,68,-12,-26,0,6,-76,-94,-12,8,38,-88,30,98,-78,-54,-48,42,26,-76,4,46,26,60};
int param1_2[] = {1,1};
int param1_3[] = {48,85,55,12,24,26,88,76,15,34,23,61,2,99,11,37,65,74,92,96,68,50,67,98,89,17,62,18,51,61,41,41,90,64,89,51,48,95,9,86,28,54,64,35};
int param1_4[] = {-96,-94,-86,-70,-52,-18,-6,20,52,52};
int param1_5[] = {1,0,0,0,0,0,1,0,0,0,1,1,0,1,0,0,1,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1,0,1,0,1,1};
int param1_6[] = {3,17,18,23,24,24,26,28,34,48,53,54,56,61,64,67,69,74,77,79,79,81,81,82,84,84,85,86,88,92,96};
int param1_7[] = {26,24,-50,18,78,-90,62,88,-36,-96,78,6,-94,-2,-28,-38,66,72,-36,14,-48,-64,-24,82,92,-16,-26,-12,6,34,30,-46,48,-22,34,-64,4,-32,84,-20,32,-22};
int param1_8[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param1_9[] = {18,20,53,87,85,63,6,81,89,82,43,76,59,60,79,96,29,65,5,56,96,95};
int *param1[10] = {param1_0,param1_1,param1_2,param1_3,param1_4,param1_5,param1_6,param1_7,param1_8,param1_9};
int param2_0[] = {6,8,10,12,14,29,41,52,53,54,55,66,69,73,77,77,78,80,90,99};
int param2_1[] = {-8,-24,54,28,92,94,0,62,28,80,82,2,88,-4,-28,80,44,34,-98,36,28,76,-48,40,98,4,22,-36,-20,-70};
int param2_2[] = {0,0};
int param2_3[] = {99,77,11,20,33,91,5,68,75,67,37,70,59,26,2,62,6,97,95,38,46,89,29,61,27,93,26,74,98,85,91,92,40,97,58,44,20,57,65,62,65,26,74,58};
int param2_4[] = {-70,-40,-22,4,12,12,38,54,72,74};
int param2_5[] = {0,0,1,1,0,0,0,0,1,0,0,0,0,0,1,1,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,0,1,1,1,0,0,1,0};
int param2_6[] = {1,3,5,8,15,16,27,27,27,28,29,30,32,35,36,37,44,47,57,65,69,70,70,76,76,83,85,87,88,90,92};
int param2_7[] = {66,26,-90,-40,-52,-98,84,88,40,-92,30,28,32,92,18,-34,-42,64,-34,70,-72,28,44,34,76,-78,46,-48,20,54,-2,66,6,56,52,-98,-48,-70,-60,94,90,10};
int param2_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};
int param2_9[] = {10,76,49,36,41,18,60,44,81,34,56,7,13,83,82,16,7,38,33,55,91,54};
int *param2[10] = {param2_0,param2_1,param2_2,param2_3,param2_4,param2_5,param2_6,param2_7,param2_8,param2_9};
int param3[] = {10,26,1,42,5,39,24,32,16,19};
int param4[] = {12,28,1,27,5,34,16,37,23,16};
int param5[] = {18,15,1,31,5,26,29,41,22,17};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i],param3[i],param4[i],param5[i]) == f_gold(param0[i],param1[i],param2[i],param3[i],param4[i],param5[i]))
{
n_success+=1;
}
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | return | [
"a) return",
"b) unsigned",
"c) else",
"d) 2",
"e) 1"
] | a |
c |
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
int min(int x, int y) { return (x < y)? x: y; }
int max(int x, int y) { return (x > y)? x: y; }
int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
int f_gold ( int a [ ], int n ) {
sort ( a, a + n );
int count = 1;
int answer = 0;
for ( int i = 1;
i < n;
i ++ ) {
if ( a [ i ] == a [ i - 1 ] ) {
count += 1;
}
else {
answer = answer + ( count * ( count - 1 ) ) / 2;
count = 1;
}
}
answer = answer + ( count * ( count - 1 ) ) / 2;
return answer;
}
int f_filled ( int a [ ], int n ) {}
else {
answer = answer + ( count * ( count - 1 ) ) / 2;
count = 1;
}
}
answer = answer + ( count * ( count - 1 ) ) / 2;
return answer;
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,7,9,12,13,13,14,16,19,23,24,25,28,29,38,38,41,42,44,51,55,56,58,59,61,62,62,63,63,64,67,68,69,71,78,78,80,82,82,82,83,85,86,92,94,98};
int param0_1[] = {42,-20,52,34,58,62,-60,70,36,-8,-26,68,34,-92,42,94,56,84,-70,70};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {31,87,75,69,11,65,25,27};
int param0_4[] = {-92,-88,-86,-74,-72,-70,-70,-66,-62,-60,-52,-42,-42,8,14,30,36,84,88};
int param0_5[] = {1,0,0,0};
int param0_6[] = {2,8,9,12,21,23,30,31,33,34,34,41,43,45,52,53,53,55,56,61,73,73,73,74,76,79,81,81,81,90,91,92,92,97,99,99};
int param0_7[] = {84,6,-36,62,-2,-32,-82,-78,20,8,-50,-70,20,-58,94,-28,-84,-22,-44,-84,2,-68,-34,58,-64,-86,-40,-80,74,-26,12,2,-20,20,76,-14,-40,56,24,-16,-66,14,-42,0,72,82,-70};
int param0_8[] = {0,0,0,0,0,0,0,1,1};
int param0_9[] = {67,93,54,91,74,88,48,68,17,6,15,25};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {24,17,37,5,13,3,30,31,8,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 [MASK] int y) { return (x < y)? x: y; } int max(int x, int y) { return (x > y)? x: y; } int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)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 ) { sort ( a, a + n ); int count = 1; int answer = 0; for ( int i = 1; i < n; i ++ ) { if ( a [ i ] == a [ i - 1 ] ) { count += 1; } else { answer = answer + ( count * ( count - 1 ) ) / 2; count = 1; } } answer = answer + ( count * ( count - 1 ) ) / 2; return answer; } int f_filled ( int a [ ], int n ) {}else {
answer = answer + ( count * ( count - 1 ) ) / 2;
count = 1;
}
}
answer = answer + ( count * ( count - 1 ) ) / 2;
return answer;
}
int f_filled ( int a [ ], int n ) {}
int main(void) {
int n_success = 0;
int param0_0[] = {4,7,9,12,13,13,14,16,19,23,24,25,28,29,38,38,41,42,44,51,55,56,58,59,61,62,62,63,63,64,67,68,69,71,78,78,80,82,82,82,83,85,86,92,94,98};
int param0_1[] = {42,-20,52,34,58,62,-60,70,36,-8,-26,68,34,-92,42,94,56,84,-70,70};
int param0_2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
int param0_3[] = {31,87,75,69,11,65,25,27};
int param0_4[] = {-92,-88,-86,-74,-72,-70,-70,-66,-62,-60,-52,-42,-42,8,14,30,36,84,88};
int param0_5[] = {1,0,0,0};
int param0_6[] = {2,8,9,12,21,23,30,31,33,34,34,41,43,45,52,53,53,55,56,61,73,73,73,74,76,79,81,81,81,90,91,92,92,97,99,99};
int param0_7[] = {84,6,-36,62,-2,-32,-82,-78,20,8,-50,-70,20,-58,94,-28,-84,-22,-44,-84,2,-68,-34,58,-64,-86,-40,-80,74,-26,12,2,-20,20,76,-14,-40,56,24,-16,-66,14,-42,0,72,82,-70};
int param0_8[] = {0,0,0,0,0,0,0,1,1};
int param0_9[] = {67,93,54,91,74,88,48,68,17,6,15,25};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {24,17,37,5,13,3,30,31,8,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;
} | x, | [
"a) int",
"b) ,",
"c) x,",
"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);}
bool f_gold ( const vector < vector < int > > & m ) {
int rows = len(m);
if ( rows == 0 ) return false;
int columns = m [ 0 ] . size ( );
for ( int y1 = 0;
y1 < rows;
y1 ++ ) for ( int x1 = 0;
x1 < columns;
x1 ++ ) if ( m [ y1 ] [ x1 ] == 1 ) for ( int y2 = y1 + 1;
y2 < rows;
y2 ++ ) for ( int x2 = x1 + 1;
x2 < columns;
x2 ++ ) if ( m [ y1 ] [ x2 ] == 1 && m [ y2 ] [ x1 ] == 1 && m [ y2 ] [ x2 ] == 1 ) return true;
return false;
}
bool f_filled ( const vector < vector < int > > & m ) {}
+ 1;
x2 < columns;
x2 ++ ) if ( m [ y1 ] [ x2 ] == 1 && m [ y2 ] [ x1 ] == 1 && m [ y2 ] [ x2 ] == 1 ) return true;
return false;
}
bool f_filled ( const vector < vector < int > > & m ) {}
int main(void) {
int n_success = 0;
vector<vector<vector<int>>> param0 {{{33,27,56,17,90,10,92},{20,12,1,45,94,64,42,91,5,51},{60,52},{48,98,56,44,78,88},{30,8,22,41,6,79,15,48,92,2,70,66,88,85,42,30},{19,42,69,71,6,97,48,51,68,65,90,99,29,56,53,67,86,38,88,21,33,79,34,12,92,27,44,13,46,70,54,87,57},{60,87,77,22,9,81,52,91,48,25,16,34,64,50,38,30,5,2,52,93,31,62},{75,98,28,32,33,87,3,38,57,38,9,88,68,61,18,34,36,71,44,99,43,25,92,30,20,85,99,78,22,38,25,44,20,50,48,54,63,23},{28,59,16,49,73,43,13,55,80,47,27,5,61,92,86,70,34,26,29,1,75,94,78,41,91,14,74,11,19,35,87,17,89,53,51,83,58,20,77,33,60,46},{47,2,17,93,96,18,41,19,21,94,67,75,15,15,49,24,66,55,71,43,55,13,6,67,23,69,82},{16,43,86,98,37,88,84,29,4,30,46,27,69,96},{82,12,57,2,83,23,57,56,58,23,64,1,19,52,76,78,95},{67,62,56,93,92,72,18,35,16,22,17,36,91,30,91,4,60,41,89,36},{31,19,74,59,39,36,76},{53,5,82,26,51,8,38,42,29,7,1,62,56,51,24,77},{85,53,29,56,58,57,47,49,97,89,13,5},{58,14,40,27,72,44,18,18,10,44,2,19,10,25,6,77,97,47,18,9,39,39,75},{21,67,71,57,23,8,41,82,91,20,9,19,2,17,63,43,28,62,25},{55,16,43,76,15,10,21,14,98,70,48,30,39,18,45,30,58,24,77,76,86,2,78,31},{30,18,24,92,77,2,14,90,13,47,39,3,21,19,16,64},{2,37,34,44,31,30,2,24,1,1,44,81,74,60,50,84,75,86,80,3,1,80,38,14,5,75,79,85,52,49,13,37,57,84,63,37,62,41,96,65,1,50,57,64,20,4,37,82},{42,7,11,6,6,52,84,59,34,24,94,93,15,5,39,51,69,12,54,69,92},{79,31,22,78,67,20,36,9,82,67,80,94,13,26,6,22,1,77,21,89,77,55,27,45,4,30,59,80,98,61,25,13},{1,61,32,35,9,71,95,64,86,22,85,94},{34,80,27,19,82,78,31,40},{20,19,64,24,20,62,76,77,57,39,4},{7,95,29,19,84,97,55,51,62,6,44,19},{22,22,16,81,17,30,59,45,29,17,87,74,45,37,87,91,79,91,46,58},{86,44},{35,80,7,10,80,62,79,81,68,75,30,52,23,45,43,30,81,8},{80,11,14,94,81,44,23,9,54,91,29,85,8,70,69,52},{90,23,44,91,46,50,92,67,80,96,86,12,78,72,5,39,15,11,47,6,53,74,49,2,55,77,51,42,2,43,9,40,8,72,28,55,47,75,39,95,24,71,17},{35,50,89,64,25,88,7,57,49,42,32,97,13,68,47,91,58,78,60,38,28,9,62,11,16,69,67,28,68,19,42,19,98,94,97,34,31,26,61,62,24,20,38,9},{50,74,79,63,28,28,89,10,32,11},{15,59,63,45,86,21,51,55,94,84,6,45,11,49,99,82,80,81,19,32,78,74,4,24,70,21,36,23,70,87,71,75,28,49,30,93,56,23,44,27,49}},{{11,70,30,12,22,41,7,64,33,26,30,14,88,33,23,1,43},{87,64,19,26,58,61,27,52,34,24,81,99,37,43,23,36,20,66,88,49,60,45,96,26,34,88,97,79},{21,75,5,51,12,77,65,3,63,95,50,62,38,73,63,4,25,96,17,22,8,99,33,35,9,67,68,77,60,99,86,54,23,61,25,30,97,70,49,72},{38,97,53,66,52,27,35,1,87,24,59,66,27,31,33,32,63,79,61,30,75,33,19,99,66,93,18,26,81,56,61,68,21,94,37,34,27,12,78,1,49,33,31},{19,83,1,12,42,64,28,87,86,60,98,50,17,13,42,75,38,14,94,7,83,48,52,10,22,99,21,34,97,22,80,4,14,49,7,24,46,86,18,31,69,72,7,68},{68},{32,82,40,71,54,62,66,31,51,47,89,47,38,93,51,51,68,86,63,53,91,26,46,56,59,17,81,54,31,29,86,36,83,20,50,60,48,19,86,18,28,67,70,8},{39,81,48,34,15,68,39,74,40,34,17,32,45,75,25,74,15,43,53,32,1,52,31,13,41,40,45,93,9,15,58,25,34,37,1,52,79,38,96,47,65,87,74,72,78},{33,74,44,12,34,25,32,36,79,54,81,40,55,11,10,55,60,67,21,11,90,13,71,45,71,7,27,97,63,77,59,50,96,70,77,16,95},{18,90,66,27,26,81,78,67,15,82,14},{96,65,67,31,72,58,5,48,56,98,82,53},{61,67,11,63,46,8,93,96,75,79,51,45,78,24},{38,9,58,7,83,62,37,37,10,34},{58,44,72,71,21,24,30,46},{79,31,85,77,58,74,68,66,53,96,53,98,56},{17,69,4,41,83,86,25,97,9,27,71,32,85,78,44,61,3,9,85,87},{24,33,5,13,2,9,76,62,72,46,78,66,36,74,78,21,69,32,52,45,24,70,42,57,99,25,81,37,88,37,33,89,12,82,3,33,40},{9,21},{67,88,29,90,37,28,43,10,48,68,74,23,25,69,22,23,27,85,9,44,48,33,26,42,29,74,85,1,64,56,16},{18,52,35,78,93,48,8,33,61,16,56,98,69,79,50,25,11,8,13,20,96,14,93,10,99,74,28,31},{99,89,29,70,27,71,64,62,35,55,74,59,24,88,91,28,71,53,69,9,56,73,98,62,12,48,52,6,79,19,82,23,15,26,58,12},{12,90,73,78,85,31},{12,63,16,21,18,73,36,81,65,39,11,38,16,85,66,67,7,34,39,91,39,9,11,53},{12,27,23,32,97,4,90,87,68,76,62,73,53,52,72,13,94,83,29,4,61,7,97,72,87,93,17,24,78,56,54,45,61,3,84,69,15},{49,4,97,7,82,25,45,62,44,25,30,99,76,9,49},{31,56,52,48,85,93,40,34,10,77,17,35,16,33,13,81,50,4,57,7,18,25},{20,49,46,44,39,3,9,20,36,28,73,43,96,96,39,81,13,8,11,31,36,93,47,1,89,2,58,76,32,17,15,27},{57,55,81,6,76,78,8,42},{59,1,14,67,27,21,26,88,41,29,62,1,78,3,78,17,26,39,87,23,8,66,72,32,17,67,2,36,45,81,66,90},{96,64,39,49,53,82,88,76,39,26,78,30,99,80,6,45,26,14},{73,92,24,60,43,90,50,40},{77,11,86,37,84},{38,22,88,69,54,28,3,18,89,63,59,73,11,50,65,35,38,73,44,4,49,12,66,63,6,21,20,51,52,57,13,59,56,17,83},{64,71,5,44,58,36,40,82,39,12,63,54,83,27,28,10,3,95,60,39},{26,40,14,91,24,99,1,35,34,8,20,40,64,9,85,66},{92,82,19,88,78,31,92,6,33,81,34,60,55,77,88,79,73,71,44,18,87,39,78,10,36,95,20,97,46},{59,73,4,37,80,51,12,8,46,73,8,42,32,75,54,73,84,73,73,97,83,57,57,19,13,82,36},{50,71,88,31,48,7,72,19,68,2,47,18,87,37,68,97,4,3,63,41,10,70,97,1,9,51,96,99,57,69,74,92,80,38,57},{62,76,16,47,19,77,87,36,40,94,42,22,93,81},{48,10,34,52,24,21,53,26,98,46,37,10,84,13,37,31,51,82,98,13,54,49,83,51,48},{78,88,6,53,91,29,3,50,10,61,64,48,70,3,79,8,82,30,34,48,74,23,42,6,8,49,56,88,22,33,31,49,65,93,18,90,24,75,73,54,63,89,27,36,45}},{{19,66,29,41,66,76,21,58,50,69,77,4,71,60,48,11,43,15,20,54,13,81,55,12,89,66,60,75,95,49,89,43,46,72,33,47,14,60,81,3,4,27},{44},{88,54,94,24,38,7,98,37,64,92,67,28,38,31,5,7,46,52,84,22,95,67,41,91,75,32,31},{30,88,47,79,92,83,11,51,55,83,31,40,28,46,13,91,25,2,96,23,48,40,48,23,6,58,22,56,28,46,24,34,25,99,32,95,59,49,75,31,2,87,6,17},{72,33,96,20,54,9,50,44,13,80,14,15,92,38,10,61,74,36,26,89,92,90,7,81,98,61,97,49,92,30,99,94,27,55,62,57,65,68,41,5,64,8,21},{99,86,38,3,77,73,17,26,98,75,74,28,75,97,34,19,89},{30,13,68,27,79,40,2,72,20,37,94,92,20,15,78,49,21,78,42,16,27,77,52}},{{95,26,62,49,1,3,4,80,39,89,1,81,51,44,58},{30,74,80,21,35,93,35,85,54,2,57,72,25,74,99,20,95,12,77,44,49,40},{14,85,9,46,55,44,52,72,79,25,94,67,34,53,18,88,36,38,48,12,61,38,46,65,31,50,70,49,94,66,83,45,7},{69,92}},{{7,13,48,32,22,86,84,21,41,47,14,68,60,21,75,93,85,79,55,68,75,41,65,91,87,35,14,19,58,65,39,8,72,30,68,54,40,16},{14,55,36,17,17,25,29,57,66,29,79,26},{65,13,10,98,49,65,95,66,34,8,89,84,82,12,27,39,77,50,52,29,72,94,99,4},{31,49,84,24,51,9,49,16,94,37,56,31,94,55,66,31},{83,34,96,28,43,55,30,92,44,47,33,96,56,43,76,49,21,8,35,27,26,46,51,93,24,1,64,26,96,58,61,5,4,31,17},{96,50,67,33,52,15,37,87,80,53,48,19,48,7,20,31,45,75},{16,68,99,53,61,34,32,41,56,30,24,34,97,86,69,50,59,73,74,69,10,95,34,58,48,72,84,9,47,89,72,78,35,41,56,80,16,14,65,65,42,24,19,75,86,63,37,1,56},{41,99},{53,98,10,55,55,74,62,49,23}},{{36,25,6,99,30,98,86,41,36,15,59,42,46,93,32,96,15,29,82,37,21,11,71,95},{97,70,80,9,66,26,54,38,49},{32,85,11,16,9,2,21,47,51,62,7,83,54,92,99},{19,49,52},{42,26,11,8,11,82,33,67,6,58,98,52,79,63,57},{45,44,62,78,72,94,61,66,1,32,43,25,48,73,72,45,33,61,95,72,15,94,40,27,77,59,11,35,55,74,75,6,96,65,93,80,45,29,75,68,49,60,39,12,66,40,42},{88,41,78,96,40,25,60,42,85,95,86,13,13,36,13,80,30,99,36,89,45,20,93,26,94,95,36,74,62,93},{1,84,16,27,20,3,96,6,84,35,88,87,96,28,40,15},{63,60,38,11,62,87,8,9,57,29,66,97,42,10,66,94,79,99,36,61,47,90,2,12,69,89,63,83,96,67,4,95},{88,12,39,91,62,89,69,31,29,59,12,28,38,11,46,95},{1},{23,26,8,83,78,8,59,93,38,70,8,53,71,17,67,37,99,96,82,88,83,96,59,89,35,99,5,32,13,2,70,41,44,25,37,61,35,46,1,84,78,1,93,6,28,51,49,79,41},{88},{94,90,57,31,11,93,92,72,78,7,70,70,16,78,14,5,93,80,7,6,8,98,90,39,10,27,59,79,99,9,27,92,22,29,72,32,14,42,61,95,95,20},{47,78,29,28,95,78,13,48,39,20,15,94,24,21,85,15,5,78,38,57,13,50,51,94,98,34,73,23,6,98,88,4,82,95,44,59,21,8,71,30,44,2,42,37,49,93,43,13},{58,43,75,30,27,69,1,6,95,67,54,7,54,8,47,76,59,75,90,69,33,75,85,3,15,38,93,32,72,35,26,43,12},{46,83,6,14,71,94,4,82,62,60,91,16,56,54,79,82,21,2,36,50,87,3,77},{46,92,33,68,88,34,19,3,84,56,54,95,14,77,92,69,45,21,28,57,31,5,99,17,57,22,75,65,58,96,91,97,56,4,26,48,92,90,32,74,45,41},{76,18,56,96,24,77,50,56,82,81,21,44,9,23,79},{65,10,78,19,37,77,26,12,11,87,33,11,33,4,70,55,45,5,89,36,82,52,71,8,8,99,49,79,81,63,81,40,1},{33,39,45,37,35,30,77,35,82,3,95,95,92,47,17,80,85,5,98,94,58,50,67,69,49,75,6,33,87,1,8,34,67,47,77,16,31,1,85,36,10,69,38,85,74,27,68,89,81},{84,65,8,68,67,50,95,63,82,74,15,23},{83,80,38,10,81,7,98,74,99,28,83,28,32,73,57,3,58,99,91,87,4,77,29,70,67,68,58,34,65,5,40,77,68,68,97,4,44},{21,9,42,33,60,19,12,34,2,86,17,71,69,21,70,74,82,82,56,23,67},{40,35,52,70,26,77,34,73,94,38,73,17,11,20},{25,63,66,86,25,5,3,65,14,46,42},{43,33,99,51,18,69,11},{96,26,41,60,74,6,2,8,58,98,34,75,78,43,42,65,65,55,97,91,38,9,43,12,46,32,14,86,69,48},{72,30,96,85,98,65,18,56,87,30,25,33,95,10,61,30,60,23,60,16,47,87,37,88,21,19},{50,40,70,94,42,49,87,37,74,43,51,77,27,4,52,73,1,68,78,67,90,6,71,63,90,35,86,76,68,79,57,45,27,29,1,75,60,29,1,66,74},{79,49,53,14,41,85,96,98,32,94,50,74,11,32,37,58,32,79,24,55,29,54,90,78,76,11,4,94,68},{76,58,2,68,78,6,13,58,6,48}},{{57,64,14,43,52,77,97,18,3,79,44,66,11,35,18,48,57},{86,90,14,56,73,83,6,42,30,37,50,48,18,35,86,29,72,57,23,65,69,14,57,54,40,54,26,92,66,85,87,10,55,30,54,43,5,46,63,64},{22,4,3,49,18,86,34,79,89,5,72,8,33,25,89,2,91,61,18,2,33,40,31,40,40,39,53,81,12,59,85,43,35},{59,9,89,87,75,3,25,94},{12,24,74,40,84,44,23,24,76,63,11,23,46,70,55,74,60,61,70,28,4,7,80,84,33,99,55,6,88,63,19,54,23,32,15,7,74,36,21,85,88,30},{27,92,34,86,22,20,3,1,90,78,69,7,45,13,63,40,94,54,3,41,74,47,65,15,2,76,29,52,46,94,21,69,11,24},{98,83,78,29,95,2,75,70,89,11,35,89,7,64,6,80,21,79,62,8,44,24,46,30,52,56,31,36,23,88,14,3,2,16,12,90},{96,81,1,36,86,5,88,13,32,50,22,7,46,8,34,46,92,46,95,6,17,35},{69,41,27,54,96},{59},{2,78,98,45,39,88,2,41,92,83,32,81,57,49,24,22},{64,13,96,53,72,82,4,57,37,89,16,96,9,83,87,52,9,7,86},{63,17,29},{79,30,42,4,41,31,69,2,13,38},{40,81,16,26,91,29,37,75,99,81,47,55,63,96,98,15,4,90,53,65,79,53,68,36,21,52,80,30},{5,60,40,57,16,25,95,59,68,37,58,82,28,79,16,4,12},{38,82,85,42,23,36,63,80,84,3,65,16},{20,45,4,47,88,66,62,84,69,77,34,95,7,79,4,12,9,8,28,55,36,42,96,23,35,92,49,71,33,19,46,91},{94,29,68,9,55,89,85,4,64,69,18,21,30,97,39,61,69,85,53,45,52,62,56,58,22,70,39,95,32,68,81,42,90,50,89,18,45,78,78,3,74,50,20,11},{66,11,7,37,6,57,16,50,58,9,21,14,73,73,90,6,7,88,3,4,96,11,54,84,38,28,41},{1},{6,28,27,52,59,13,62,14,31,32},{59,68,76,71,24,89,30,26,66,45,88,52,72,7,52,66,79,26,96,59,52},{54,41,50,4},{80,98,4,65,77,86,43,27,13,39,4,94,96,92,13,51,24,19,6,6,85,89,62,44,11,59,55,52,60,37,15,61,59,51,21,86,93,48,68,21,62,35,80,85,35,23},{7,34,53,84,9,35,55,79,15,38,85,43,50,80,29,48,87,67,8,2,96,19,11,75,26,13,91,34,37,68,67,18,24,43,5,41},{35,53,64,42,80,51,83,91,75,40,31,25,67,71,25,61,63,60,55,75,33,64,66,41,93,22,35,60,63,59,82,20,60,57,5,4,7,43,14,50,73,94,63,52,29,48,9,19},{7,13,41,22,63,48,32,49,8,25,15,37,56,24,78},{58,45,33,18,33,48,50,64,65,74,98,78,9,48,70,5,71,63,89,38,57,84,94,40,23,34,34,98,85,61,13,38,92,98,15,64,56,23,91,9,50,18,18,83,72,94,10,71,9},{13,39,36,80,40,81,12,27,85,91,5,51,90,65,2,72,5,85,29,55,91,75,8,91,81,10,15,31,3,73,23,88,18},{46,65,69,68,42,57,88,3,7,17,66,83,46},{99,15,31,56,63,6},{96,39,93,78,2,12,66,76,5,16,56,63,55,74,54,98,7,45,53,4,6,66,6,68,14,2,87,50,94,43,39,58,21,4,55,14,49,59,62},{19,96,21,54,61,88,11,79,75,71,56,57,12,36,44,43,84,95,92,80,51,9,36,6,11,78,63,94,75,80,5,84,14,44,86,82,69,23,47},{34,45,44,41},{39,23,58,48,32,92,36,32,24,18,22,1,9,2,83,37,19,91,60,81,79,25,68,9,12,26},{44,92,92,12,71,22,94,98,34,62,7,97,97,97,60,51,13,41,35,75,97,21,30,61,41,70,82,7,31,66,5,40,62,25,69,31},{96,1},{1,65},{30,59,74,49,14,90,88,38,91,36,4,44,28,71,59,25,97,79,93,10,7,73,73,37,37,57,71,61,79,62,84,57,39,53,36,49,7,77,47,54,92,53,96,46,69,39,45,94,67},{19,93,99,75,96,15},{86,97,1,75,11,45,22,59,96,14,62,39,33,3,62,41,39,18,24,3,34,50,81,39,73,81,37,53,54,94,26,94,6,2,96,19,7,48,58,53,3,24,40,60,76},{73,4,8,42,10,24,84,69},{42,2,49,32,11,68,26,90,23,2,62,49},{98,3,84,46,32,87,25,52,79,56,9,9,72,50,23,50},{92,71,50,10,78,29,48,9,16,54,12,87,50,80,27,36,7,69,56,45,72,27,77,95,96,49}},{{84,47,93,51},{97,74,57,83,5,70,92,1,11,2,8,57,81},{76,66,34,36,74,51,30,35,76,48,3,88,26,27,37,86,2,53,26,52,65,99,23,77,13,58,6,40,26,62,83,59,24,95,54,24,63,58,32,71,60,15,75,29,37,29,4},{71,18,87,98,77,23,80,15},{28,42,8,9,21,65,70,98,10,16,1,77,5,70,57,90,92,43,94,12,93,8,97,6,84,32,59,92,4,34,45,40,25,73,25,92,72,71,87,92,88,44,30,38,78},{93,6,77,55},{29,89,30,59,86,80,20},{6,31,25,81,75,64,79,37,56,30,71,4,86,53,31,81,56,86,36,76,30,96,19,99,3,15,4,82,87,7,35,55,10,3,52,19,2,1,4,80,32},{31,43,73,35,53},{77,93,1,13,82,55,74,3,77,19,23,30,73,24,74,68,99,60,5,65,53,9,33,73,73,76,62,40,28,44,14,25,38,97,99,37,90,48,41,99,70,77},{70,6,5,28,81,26,11,36,26,1,65,51,56,62,35,14,80,19,58,86,48,48,90,71,38,3,40,42,26},{8,13,98,48,25,57,55,61,44,83,6,86,22,88},{23,83,44,7,90,99,7,21,47,55},{47,92,94,44,92,99,28,96,94,51,23,33,27,7,99,30,49,87,31,79,95,13,7,22,93,60,96,61,90,57,23,84,69,60,17,29,77},{26,62,80,46,59,9,81,99,21,68,12,1,73,40,35,87,64,94,31,51,88,26},{9,95,69,50,63,28,83,12,81,57,16,22,23,97,36,78,91,5,50,21,1,14,92,10,62,19,30,82,81,84,41,40,78,88,68,27,4,78,61,99,8,67,82,58,38,42,64,43,29},{22,93,76,24,74,65,56,33,91,89,16,70,33,7,98,46,82,32,26,2,34,27,67,85,66,82,20,8},{63,98,27,78,7,32,13,25,58,5,46,10,30,47,79,65,33,84,60,95,18,79,69,20,36,43,13,20,72,30,32,94,59,8,70,7,54,18,50,56,65,61,70,3},{23,26,33,14,79,93,32,58,80,76,40,2,55},{48,40,9,29},{89,96,17,74,98,15,1,46,38,55,90,20,85,93,91,22,54},{72,14,76,72,64,61,27,93,87,63,55,95,32,66,19,74,34},{52,25,67,46,11,1,47,54,86,72,24,46,92,17,23,31,46,53,63,74,22,8,64,54,88,4,9,39,3,56,17,15,13,41,44,49,64},{53,42,4,10},{29,46,14,53,84,80,65,84,79,74,54,18,1,95,48,36,2,44,84,76,22,33,60,20,6,14,42,26,60,42,89,62,76,20,40,66,2,81,92,29,27,6,9,63,96,31,14},{18,81,90,96,76,61,26,17,22,24,42,66,98,17,65,80,23,65,77,90,47,56,17,3,15,51,14},{39,13,16,88,62,59,78}},{{94,44,83,3,47,11,36,61,29,34,43,94,79,3},{35,91,27,32,31,95,89,92,86,26,9,30,64,56,73,85,39,14,97,77,29,89,59,16,20,53,89,87,3,77,77,69,36,24,52,52,65,41,94,4,85,38,70,76,26,92,92,23,34},{80,40,74,57,81,40,53,27,82,44,51,91,42,31,55,79,52,66,53,27,23,24,53,72,58,11,23,82,67,41,88,84,95,78,76,73},{72,93,81,5,86,85,55,44,69,70,60,61,52,1,95,4,70,44,68,93,64,12,95,21,4,54,19,74,39,36,74,4,82,33,30,76,32,59,78,56,56,96,44,7,64,83,95},{36,69,97,32,86,60,10,45,74,25,74,72,73,56,46,71,51,95,31,95,97,95,40,64,15,63,78,63,72,23,71,19,57,51,7,27,50,58,31,6,90,41,70},{83,15,4,37,90,29,28,42,8,85,91,2,16,4,76,34,67,67,11,6,28,40,73,32,53,35,52,92,34,15,71,4,86,27,95,15,74,85,74,25,9,72,80,74,45,81,62},{90,54,30,4,42,25,99,8,74,27,77,35,91,8,17,28,39,83,62,90,49,18,94,38},{99,81,47,87,32,25,26,32,93,93,20,74,5,43,8,41,40,9,6,36,63,26,77},{3,73,96,98,94,41,51,93,75,93,93,31,26,11,26,29,83,77,23,84,13,58,62,31,22,83,14,70,45,89,63,82,74,80,73,58},{11,52},{52,49,6,36,12,79,79,89,58,21,43,21,32,15,68,46,43,11,37,71,58,59,50,28,66},{11,79,89,58,33,23,75,50,73,44,76},{89,9,37,14,7,43,93,70,46,79,58,85,22},{4,10,22,46,13,41,56,37,39,58,87,19,15,88,33,46,13,67,84,9,13,16,58,82,79,77,84,79,39,98,53,84,19,9,93,30,6,82,8,43,17},{62,21,34,86,98,44,81,14,82,54,44,53,36,33,2,68,19,37,60,68,6,31,44,52,95,78,24,20,56,58,11,31,61,79,84,20,35,53,79,60,18,30,43,90},{6,16,42,48,89,31,13,89,14,73,44,91,12,1,36,34,94,86,86,82,45,99,38,2,1,76,26,90,30,61,21,43,26,6,44,98,69,41,48,40,90,76,61,17,81,74,92,54,16},{15,8,16,84,86,34,34,75,92,67,54},{19,31,62,89,26,96,91,32,78,42,84,66,79,29,48,49,5,70,2,71,36,90,70,86,80,28,71,77,3},{17,5,88,70,37},{17,76,71,38,5,87,77,36,76,29,14,36,18,80,23,39},{21,37,68,55,90,49,24,88,13,97,97,61,71,29,89,75,98},{73,87,99,92,49,12,74,59,64,19,89,53,12,44,73,81,57,88,72,37,4,56,81,14,29,81,84,98,98,60,75,98,86,51,88},{35,7,98,35,89,39,27,69,30},{23},{91,65,2,73,12,91,47,14,48,1,69,95,81,59,36,79,35,9},{54,25,8,41,64,96,84,47,85},{68,54,56,89,25,27,83,2,24,87,86,4,96,29,69,93,32,2,22,75,28,44,81,49,13,26,67,78,55,39,33,5,62,95,80,95,78,34,36,30,98,99},{96,64,38,15,13,52,35,51,58,8,62,66,33,36,70,75,5,34,54,8,27,99,3,26,47,1,61,75},{85,51,48,48,79,4,61,32,30,94,40,65,7,86,75,27,89,47,19,99,55,96,24,70,37,27,26,47,33,81,36,13,14,39,90,92,54,93,83,93,67,35,47,75,54},{17,66,58,44,36,32,93,79,30,62,88,4,94,41,56,74,27,11,91,2,95,11,44,93,51,31,68,95,71,44,41,81,69,38,28,13,73,7,63,8,89,14,35},{82,91,99,3,24,5,56,84,15,51,33,55,78,52,19,32,36,81,73,34,57,45,79,36,13,73,39,79,43,50,3,73,70,30,3,88},{2,3,98,55,1,88,84,56,66,26,36,29,51,1,35,48,93,99,73,93,68,89,97,51,35,6,38,30,84,9,1,92,10,67,42,99},{92},{50,66,97,64,10,81,14,33,2,75,7,68,82,82,40,2,45,70,6,92,74,58,53,51,73,22,99,5,7,68,2,26,95,4,47,27,18,90,89,14,9},{80,61,92,13,68,82,89,28,7,35},{69,15,28,27,60,79,20},{38,31,3,33,58,82,75,73,67,42,42,76,23,15,81,82,16,63,71,68,44,26,78,31,48,15,65,65,51,37,49,16,68,61,93,13,59,23,34,84},{62,63,60,5,95,90,78,58,87,37,26,13,55,81,30,19,80,82,4,24},{8,11,45},{64,21,66,1,72,10,36,85,24,90,27,68,81,63,46,91,3,81,83,44,33,67,72,31,96},{12,84,24,51,57,17,46,58,74,28,82,85,64,23,31,77,23,97,34,56,90,47,36},{76,18,75,5,93,67,79,43,73,16,46,19,19,54,38,56,99,60,88,31,48},{88,10,77,8,66,37,46,51,95,71,43,78,24,14,78,9,88,76,33,27,58},{37,14,60,29,82,67,7,19,7,47,33,87,69,21,77,82,55,73,68,43,89,97,50,92,91,33,31,96,13,84,18,86,96,61,74,22,51,4,76,23,97,63,66},{93,33,45,89,72,53,28,7,43,51,64,71,29,49,7,49,65,99,60,75,12,72,97,4,41,41,68,44,47,26,66},{6,37,42,78,68,92}},{{73,76,46,23,86,18,9,70,59,62,16,29,73},{61,96,64,50,73,94,12,57,61},{94,91,84,25,31,11,12,3,44,40,49,47,25,34,98,31},{52,39,9,83,41,89,28,13,32,34,4,24,92,74,70,24,59,42,84,98,35,77,38,58,3,80,35,21,80},{86,91,2,3,3,90,9,69,43,69,63,3,64,81,37,50,57,58},{55,86,11,29,5,8,54,40,67,51,99,37,65,70,6,89,77,95,44,64,27,91,16,12,73,51,43,15,51,44,21,44,4,84},{59,63,28,26,57,36,55,65,66,74,61,39,94,55,37,4,36,36,39,51,92,11,50,87,37,51,53,77,24,77,22,45,92,31,21,99,73,18,72,55,59,76},{63,51,4,58,65,63,19,79,25,31,9,79,67,32,37,34,19,65,24,36,48,75},{12,97,13,26,16,69,64,92,90,72,61,1,40,13,59,1,44,44,70,50},{62,3,60,24,42,25,91,49,8,73,93,22,4,22,67,30,6,58,85,14,63,74,11,12,8,11,95,2,88,98,37,41,87,82,62,62,51},{52,74,28,24,98,78,22,44,90,79,47,99,22,30,28,37,39,91,35,7,57,99},{40,79,99,66,98,1,47,99,10,54,28,79,43,1,74,28,93,95,85,36,44,52,70,58,83,77,29,68,31,77,31,75,69,12,76},{17,55,59,48,74,43,12,36,24,73,94,69,22,20,34,66,44,9,84},{71,66,21,8,26,93,80,30,3,80,35,63,61,43,12,81,79,53,83,5,15,69,26,46,17,4,89,86,68,97,33,48,47},{47,27,37,82,69,28,65,13,74,14,67,81,43,61,75,95,54,45,98,87,5,27,69,6,99,82,55,45,26,58,52,19,97,22,41,24,74,9,27,11,87},{53,94,37,35,74,93,43,72,98,29,72,82,89,92,7,20,70,38,90,55,51,5,72,48,14,98,95,93,65,79,60,31,42,55,51,4},{24,57,83,16,92,22,33,51,80,19,78,68,29,67,99},{80,76,99,52,90,30,67,49,13,57,93,90,44,68,44,48,72,54,98,15,17,34,40,69,1},{67,81,18,33,82,69,42,42,57,88,82,9,9,75,83,87,37,81,15,86,52,24,7,44,58,90,21,70,29,81,82,88,23,2,33,39,5,76,98,85,93,74,11,79,52},{51,76,56,56,63,69,51,29,29,88,33,13,58,52,94,15,6,3,38,52,43,22,78,41,92,50,26,3,86,71,68,76,87,8,25},{98},{6,60,39,44,3,58,75,97,29,49,88,44,92,43,12,5,38,75,57,3,85,16,86,62,16,40,76,37,5,69,16,63,84,78,74,18,4,89,73,67,60,56,10,3,61,64,24}}};
for (int i =0; i < len(param0); i+=2 )
for (int j =0; j < param0[i].size(); ++j )
for (int k =0; k < param0[i][j].size(); ++k )
param0[i][j][k]= param0[i][j][k] %2;
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
for (int i =0; i < len(param0); ++i )
for (int j =0; j < param0[i].size(); ++j )
for (int k =0; k < param0[i][j].size(); ++k )
param0[i][j][k] %=2;
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 ( const vector < vector < int > > & m ) { int rows = len(m); if ( rows == 0 ) return false; int columns = m [ 0 ] . size ( ); for ( int y1 = 0; y1 < rows; y1 ++ ) for ( int x1 = 0; x1 < columns; x1 ++ ) if ( m [ y1 ] [ x1 ] [MASK] 1 ) for ( int y2 = y1 + 1; y2 < rows; y2 ++ ) for ( int x2 = x1 + 1; x2 < columns; x2 ++ ) if ( m [ y1 ] [ x2 ] == 1 && m [ y2 ] [ x1 ] == 1 && m [ y2 ] [ x2 ] == 1 ) return true; return false; } bool f_filled ( const vector < vector < int > > & m ) {} + 1;
x2 < columns;
x2 ++ ) if ( m [ y1 ] [ x2 ] == 1 && m [ y2 ] [ x1 ] == 1 && m [ y2 ] [ x2 ] == 1 ) return true;
return false;
}
bool f_filled ( const vector < vector < int > > & m ) {}
int main(void) {
int n_success = 0;
vector<vector<vector<int>>> param0 {{{33,27,56,17,90,10,92},{20,12,1,45,94,64,42,91,5,51},{60,52},{48,98,56,44,78,88},{30,8,22,41,6,79,15,48,92,2,70,66,88,85,42,30},{19,42,69,71,6,97,48,51,68,65,90,99,29,56,53,67,86,38,88,21,33,79,34,12,92,27,44,13,46,70,54,87,57},{60,87,77,22,9,81,52,91,48,25,16,34,64,50,38,30,5,2,52,93,31,62},{75,98,28,32,33,87,3,38,57,38,9,88,68,61,18,34,36,71,44,99,43,25,92,30,20,85,99,78,22,38,25,44,20,50,48,54,63,23},{28,59,16,49,73,43,13,55,80,47,27,5,61,92,86,70,34,26,29,1,75,94,78,41,91,14,74,11,19,35,87,17,89,53,51,83,58,20,77,33,60,46},{47,2,17,93,96,18,41,19,21,94,67,75,15,15,49,24,66,55,71,43,55,13,6,67,23,69,82},{16,43,86,98,37,88,84,29,4,30,46,27,69,96},{82,12,57,2,83,23,57,56,58,23,64,1,19,52,76,78,95},{67,62,56,93,92,72,18,35,16,22,17,36,91,30,91,4,60,41,89,36},{31,19,74,59,39,36,76},{53,5,82,26,51,8,38,42,29,7,1,62,56,51,24,77},{85,53,29,56,58,57,47,49,97,89,13,5},{58,14,40,27,72,44,18,18,10,44,2,19,10,25,6,77,97,47,18,9,39,39,75},{21,67,71,57,23,8,41,82,91,20,9,19,2,17,63,43,28,62,25},{55,16,43,76,15,10,21,14,98,70,48,30,39,18,45,30,58,24,77,76,86,2,78,31},{30,18,24,92,77,2,14,90,13,47,39,3,21,19,16,64},{2,37,34,44,31,30,2,24,1,1,44,81,74,60,50,84,75,86,80,3,1,80,38,14,5,75,79,85,52,49,13,37,57,84,63,37,62,41,96,65,1,50,57,64,20,4,37,82},{42,7,11,6,6,52,84,59,34,24,94,93,15,5,39,51,69,12,54,69,92},{79,31,22,78,67,20,36,9,82,67,80,94,13,26,6,22,1,77,21,89,77,55,27,45,4,30,59,80,98,61,25,13},{1,61,32,35,9,71,95,64,86,22,85,94},{34,80,27,19,82,78,31,40},{20,19,64,24,20,62,76,77,57,39,4},{7,95,29,19,84,97,55,51,62,6,44,19},{22,22,16,81,17,30,59,45,29,17,87,74,45,37,87,91,79,91,46,58},{86,44},{35,80,7,10,80,62,79,81,68,75,30,52,23,45,43,30,81,8},{80,11,14,94,81,44,23,9,54,91,29,85,8,70,69,52},{90,23,44,91,46,50,92,67,80,96,86,12,78,72,5,39,15,11,47,6,53,74,49,2,55,77,51,42,2,43,9,40,8,72,28,55,47,75,39,95,24,71,17},{35,50,89,64,25,88,7,57,49,42,32,97,13,68,47,91,58,78,60,38,28,9,62,11,16,69,67,28,68,19,42,19,98,94,97,34,31,26,61,62,24,20,38,9},{50,74,79,63,28,28,89,10,32,11},{15,59,63,45,86,21,51,55,94,84,6,45,11,49,99,82,80,81,19,32,78,74,4,24,70,21,36,23,70,87,71,75,28,49,30,93,56,23,44,27,49}},{{11,70,30,12,22,41,7,64,33,26,30,14,88,33,23,1,43},{87,64,19,26,58,61,27,52,34,24,81,99,37,43,23,36,20,66,88,49,60,45,96,26,34,88,97,79},{21,75,5,51,12,77,65,3,63,95,50,62,38,73,63,4,25,96,17,22,8,99,33,35,9,67,68,77,60,99,86,54,23,61,25,30,97,70,49,72},{38,97,53,66,52,27,35,1,87,24,59,66,27,31,33,32,63,79,61,30,75,33,19,99,66,93,18,26,81,56,61,68,21,94,37,34,27,12,78,1,49,33,31},{19,83,1,12,42,64,28,87,86,60,98,50,17,13,42,75,38,14,94,7,83,48,52,10,22,99,21,34,97,22,80,4,14,49,7,24,46,86,18,31,69,72,7,68},{68},{32,82,40,71,54,62,66,31,51,47,89,47,38,93,51,51,68,86,63,53,91,26,46,56,59,17,81,54,31,29,86,36,83,20,50,60,48,19,86,18,28,67,70,8},{39,81,48,34,15,68,39,74,40,34,17,32,45,75,25,74,15,43,53,32,1,52,31,13,41,40,45,93,9,15,58,25,34,37,1,52,79,38,96,47,65,87,74,72,78},{33,74,44,12,34,25,32,36,79,54,81,40,55,11,10,55,60,67,21,11,90,13,71,45,71,7,27,97,63,77,59,50,96,70,77,16,95},{18,90,66,27,26,81,78,67,15,82,14},{96,65,67,31,72,58,5,48,56,98,82,53},{61,67,11,63,46,8,93,96,75,79,51,45,78,24},{38,9,58,7,83,62,37,37,10,34},{58,44,72,71,21,24,30,46},{79,31,85,77,58,74,68,66,53,96,53,98,56},{17,69,4,41,83,86,25,97,9,27,71,32,85,78,44,61,3,9,85,87},{24,33,5,13,2,9,76,62,72,46,78,66,36,74,78,21,69,32,52,45,24,70,42,57,99,25,81,37,88,37,33,89,12,82,3,33,40},{9,21},{67,88,29,90,37,28,43,10,48,68,74,23,25,69,22,23,27,85,9,44,48,33,26,42,29,74,85,1,64,56,16},{18,52,35,78,93,48,8,33,61,16,56,98,69,79,50,25,11,8,13,20,96,14,93,10,99,74,28,31},{99,89,29,70,27,71,64,62,35,55,74,59,24,88,91,28,71,53,69,9,56,73,98,62,12,48,52,6,79,19,82,23,15,26,58,12},{12,90,73,78,85,31},{12,63,16,21,18,73,36,81,65,39,11,38,16,85,66,67,7,34,39,91,39,9,11,53},{12,27,23,32,97,4,90,87,68,76,62,73,53,52,72,13,94,83,29,4,61,7,97,72,87,93,17,24,78,56,54,45,61,3,84,69,15},{49,4,97,7,82,25,45,62,44,25,30,99,76,9,49},{31,56,52,48,85,93,40,34,10,77,17,35,16,33,13,81,50,4,57,7,18,25},{20,49,46,44,39,3,9,20,36,28,73,43,96,96,39,81,13,8,11,31,36,93,47,1,89,2,58,76,32,17,15,27},{57,55,81,6,76,78,8,42},{59,1,14,67,27,21,26,88,41,29,62,1,78,3,78,17,26,39,87,23,8,66,72,32,17,67,2,36,45,81,66,90},{96,64,39,49,53,82,88,76,39,26,78,30,99,80,6,45,26,14},{73,92,24,60,43,90,50,40},{77,11,86,37,84},{38,22,88,69,54,28,3,18,89,63,59,73,11,50,65,35,38,73,44,4,49,12,66,63,6,21,20,51,52,57,13,59,56,17,83},{64,71,5,44,58,36,40,82,39,12,63,54,83,27,28,10,3,95,60,39},{26,40,14,91,24,99,1,35,34,8,20,40,64,9,85,66},{92,82,19,88,78,31,92,6,33,81,34,60,55,77,88,79,73,71,44,18,87,39,78,10,36,95,20,97,46},{59,73,4,37,80,51,12,8,46,73,8,42,32,75,54,73,84,73,73,97,83,57,57,19,13,82,36},{50,71,88,31,48,7,72,19,68,2,47,18,87,37,68,97,4,3,63,41,10,70,97,1,9,51,96,99,57,69,74,92,80,38,57},{62,76,16,47,19,77,87,36,40,94,42,22,93,81},{48,10,34,52,24,21,53,26,98,46,37,10,84,13,37,31,51,82,98,13,54,49,83,51,48},{78,88,6,53,91,29,3,50,10,61,64,48,70,3,79,8,82,30,34,48,74,23,42,6,8,49,56,88,22,33,31,49,65,93,18,90,24,75,73,54,63,89,27,36,45}},{{19,66,29,41,66,76,21,58,50,69,77,4,71,60,48,11,43,15,20,54,13,81,55,12,89,66,60,75,95,49,89,43,46,72,33,47,14,60,81,3,4,27},{44},{88,54,94,24,38,7,98,37,64,92,67,28,38,31,5,7,46,52,84,22,95,67,41,91,75,32,31},{30,88,47,79,92,83,11,51,55,83,31,40,28,46,13,91,25,2,96,23,48,40,48,23,6,58,22,56,28,46,24,34,25,99,32,95,59,49,75,31,2,87,6,17},{72,33,96,20,54,9,50,44,13,80,14,15,92,38,10,61,74,36,26,89,92,90,7,81,98,61,97,49,92,30,99,94,27,55,62,57,65,68,41,5,64,8,21},{99,86,38,3,77,73,17,26,98,75,74,28,75,97,34,19,89},{30,13,68,27,79,40,2,72,20,37,94,92,20,15,78,49,21,78,42,16,27,77,52}},{{95,26,62,49,1,3,4,80,39,89,1,81,51,44,58},{30,74,80,21,35,93,35,85,54,2,57,72,25,74,99,20,95,12,77,44,49,40},{14,85,9,46,55,44,52,72,79,25,94,67,34,53,18,88,36,38,48,12,61,38,46,65,31,50,70,49,94,66,83,45,7},{69,92}},{{7,13,48,32,22,86,84,21,41,47,14,68,60,21,75,93,85,79,55,68,75,41,65,91,87,35,14,19,58,65,39,8,72,30,68,54,40,16},{14,55,36,17,17,25,29,57,66,29,79,26},{65,13,10,98,49,65,95,66,34,8,89,84,82,12,27,39,77,50,52,29,72,94,99,4},{31,49,84,24,51,9,49,16,94,37,56,31,94,55,66,31},{83,34,96,28,43,55,30,92,44,47,33,96,56,43,76,49,21,8,35,27,26,46,51,93,24,1,64,26,96,58,61,5,4,31,17},{96,50,67,33,52,15,37,87,80,53,48,19,48,7,20,31,45,75},{16,68,99,53,61,34,32,41,56,30,24,34,97,86,69,50,59,73,74,69,10,95,34,58,48,72,84,9,47,89,72,78,35,41,56,80,16,14,65,65,42,24,19,75,86,63,37,1,56},{41,99},{53,98,10,55,55,74,62,49,23}},{{36,25,6,99,30,98,86,41,36,15,59,42,46,93,32,96,15,29,82,37,21,11,71,95},{97,70,80,9,66,26,54,38,49},{32,85,11,16,9,2,21,47,51,62,7,83,54,92,99},{19,49,52},{42,26,11,8,11,82,33,67,6,58,98,52,79,63,57},{45,44,62,78,72,94,61,66,1,32,43,25,48,73,72,45,33,61,95,72,15,94,40,27,77,59,11,35,55,74,75,6,96,65,93,80,45,29,75,68,49,60,39,12,66,40,42},{88,41,78,96,40,25,60,42,85,95,86,13,13,36,13,80,30,99,36,89,45,20,93,26,94,95,36,74,62,93},{1,84,16,27,20,3,96,6,84,35,88,87,96,28,40,15},{63,60,38,11,62,87,8,9,57,29,66,97,42,10,66,94,79,99,36,61,47,90,2,12,69,89,63,83,96,67,4,95},{88,12,39,91,62,89,69,31,29,59,12,28,38,11,46,95},{1},{23,26,8,83,78,8,59,93,38,70,8,53,71,17,67,37,99,96,82,88,83,96,59,89,35,99,5,32,13,2,70,41,44,25,37,61,35,46,1,84,78,1,93,6,28,51,49,79,41},{88},{94,90,57,31,11,93,92,72,78,7,70,70,16,78,14,5,93,80,7,6,8,98,90,39,10,27,59,79,99,9,27,92,22,29,72,32,14,42,61,95,95,20},{47,78,29,28,95,78,13,48,39,20,15,94,24,21,85,15,5,78,38,57,13,50,51,94,98,34,73,23,6,98,88,4,82,95,44,59,21,8,71,30,44,2,42,37,49,93,43,13},{58,43,75,30,27,69,1,6,95,67,54,7,54,8,47,76,59,75,90,69,33,75,85,3,15,38,93,32,72,35,26,43,12},{46,83,6,14,71,94,4,82,62,60,91,16,56,54,79,82,21,2,36,50,87,3,77},{46,92,33,68,88,34,19,3,84,56,54,95,14,77,92,69,45,21,28,57,31,5,99,17,57,22,75,65,58,96,91,97,56,4,26,48,92,90,32,74,45,41},{76,18,56,96,24,77,50,56,82,81,21,44,9,23,79},{65,10,78,19,37,77,26,12,11,87,33,11,33,4,70,55,45,5,89,36,82,52,71,8,8,99,49,79,81,63,81,40,1},{33,39,45,37,35,30,77,35,82,3,95,95,92,47,17,80,85,5,98,94,58,50,67,69,49,75,6,33,87,1,8,34,67,47,77,16,31,1,85,36,10,69,38,85,74,27,68,89,81},{84,65,8,68,67,50,95,63,82,74,15,23},{83,80,38,10,81,7,98,74,99,28,83,28,32,73,57,3,58,99,91,87,4,77,29,70,67,68,58,34,65,5,40,77,68,68,97,4,44},{21,9,42,33,60,19,12,34,2,86,17,71,69,21,70,74,82,82,56,23,67},{40,35,52,70,26,77,34,73,94,38,73,17,11,20},{25,63,66,86,25,5,3,65,14,46,42},{43,33,99,51,18,69,11},{96,26,41,60,74,6,2,8,58,98,34,75,78,43,42,65,65,55,97,91,38,9,43,12,46,32,14,86,69,48},{72,30,96,85,98,65,18,56,87,30,25,33,95,10,61,30,60,23,60,16,47,87,37,88,21,19},{50,40,70,94,42,49,87,37,74,43,51,77,27,4,52,73,1,68,78,67,90,6,71,63,90,35,86,76,68,79,57,45,27,29,1,75,60,29,1,66,74},{79,49,53,14,41,85,96,98,32,94,50,74,11,32,37,58,32,79,24,55,29,54,90,78,76,11,4,94,68},{76,58,2,68,78,6,13,58,6,48}},{{57,64,14,43,52,77,97,18,3,79,44,66,11,35,18,48,57},{86,90,14,56,73,83,6,42,30,37,50,48,18,35,86,29,72,57,23,65,69,14,57,54,40,54,26,92,66,85,87,10,55,30,54,43,5,46,63,64},{22,4,3,49,18,86,34,79,89,5,72,8,33,25,89,2,91,61,18,2,33,40,31,40,40,39,53,81,12,59,85,43,35},{59,9,89,87,75,3,25,94},{12,24,74,40,84,44,23,24,76,63,11,23,46,70,55,74,60,61,70,28,4,7,80,84,33,99,55,6,88,63,19,54,23,32,15,7,74,36,21,85,88,30},{27,92,34,86,22,20,3,1,90,78,69,7,45,13,63,40,94,54,3,41,74,47,65,15,2,76,29,52,46,94,21,69,11,24},{98,83,78,29,95,2,75,70,89,11,35,89,7,64,6,80,21,79,62,8,44,24,46,30,52,56,31,36,23,88,14,3,2,16,12,90},{96,81,1,36,86,5,88,13,32,50,22,7,46,8,34,46,92,46,95,6,17,35},{69,41,27,54,96},{59},{2,78,98,45,39,88,2,41,92,83,32,81,57,49,24,22},{64,13,96,53,72,82,4,57,37,89,16,96,9,83,87,52,9,7,86},{63,17,29},{79,30,42,4,41,31,69,2,13,38},{40,81,16,26,91,29,37,75,99,81,47,55,63,96,98,15,4,90,53,65,79,53,68,36,21,52,80,30},{5,60,40,57,16,25,95,59,68,37,58,82,28,79,16,4,12},{38,82,85,42,23,36,63,80,84,3,65,16},{20,45,4,47,88,66,62,84,69,77,34,95,7,79,4,12,9,8,28,55,36,42,96,23,35,92,49,71,33,19,46,91},{94,29,68,9,55,89,85,4,64,69,18,21,30,97,39,61,69,85,53,45,52,62,56,58,22,70,39,95,32,68,81,42,90,50,89,18,45,78,78,3,74,50,20,11},{66,11,7,37,6,57,16,50,58,9,21,14,73,73,90,6,7,88,3,4,96,11,54,84,38,28,41},{1},{6,28,27,52,59,13,62,14,31,32},{59,68,76,71,24,89,30,26,66,45,88,52,72,7,52,66,79,26,96,59,52},{54,41,50,4},{80,98,4,65,77,86,43,27,13,39,4,94,96,92,13,51,24,19,6,6,85,89,62,44,11,59,55,52,60,37,15,61,59,51,21,86,93,48,68,21,62,35,80,85,35,23},{7,34,53,84,9,35,55,79,15,38,85,43,50,80,29,48,87,67,8,2,96,19,11,75,26,13,91,34,37,68,67,18,24,43,5,41},{35,53,64,42,80,51,83,91,75,40,31,25,67,71,25,61,63,60,55,75,33,64,66,41,93,22,35,60,63,59,82,20,60,57,5,4,7,43,14,50,73,94,63,52,29,48,9,19},{7,13,41,22,63,48,32,49,8,25,15,37,56,24,78},{58,45,33,18,33,48,50,64,65,74,98,78,9,48,70,5,71,63,89,38,57,84,94,40,23,34,34,98,85,61,13,38,92,98,15,64,56,23,91,9,50,18,18,83,72,94,10,71,9},{13,39,36,80,40,81,12,27,85,91,5,51,90,65,2,72,5,85,29,55,91,75,8,91,81,10,15,31,3,73,23,88,18},{46,65,69,68,42,57,88,3,7,17,66,83,46},{99,15,31,56,63,6},{96,39,93,78,2,12,66,76,5,16,56,63,55,74,54,98,7,45,53,4,6,66,6,68,14,2,87,50,94,43,39,58,21,4,55,14,49,59,62},{19,96,21,54,61,88,11,79,75,71,56,57,12,36,44,43,84,95,92,80,51,9,36,6,11,78,63,94,75,80,5,84,14,44,86,82,69,23,47},{34,45,44,41},{39,23,58,48,32,92,36,32,24,18,22,1,9,2,83,37,19,91,60,81,79,25,68,9,12,26},{44,92,92,12,71,22,94,98,34,62,7,97,97,97,60,51,13,41,35,75,97,21,30,61,41,70,82,7,31,66,5,40,62,25,69,31},{96,1},{1,65},{30,59,74,49,14,90,88,38,91,36,4,44,28,71,59,25,97,79,93,10,7,73,73,37,37,57,71,61,79,62,84,57,39,53,36,49,7,77,47,54,92,53,96,46,69,39,45,94,67},{19,93,99,75,96,15},{86,97,1,75,11,45,22,59,96,14,62,39,33,3,62,41,39,18,24,3,34,50,81,39,73,81,37,53,54,94,26,94,6,2,96,19,7,48,58,53,3,24,40,60,76},{73,4,8,42,10,24,84,69},{42,2,49,32,11,68,26,90,23,2,62,49},{98,3,84,46,32,87,25,52,79,56,9,9,72,50,23,50},{92,71,50,10,78,29,48,9,16,54,12,87,50,80,27,36,7,69,56,45,72,27,77,95,96,49}},{{84,47,93,51},{97,74,57,83,5,70,92,1,11,2,8,57,81},{76,66,34,36,74,51,30,35,76,48,3,88,26,27,37,86,2,53,26,52,65,99,23,77,13,58,6,40,26,62,83,59,24,95,54,24,63,58,32,71,60,15,75,29,37,29,4},{71,18,87,98,77,23,80,15},{28,42,8,9,21,65,70,98,10,16,1,77,5,70,57,90,92,43,94,12,93,8,97,6,84,32,59,92,4,34,45,40,25,73,25,92,72,71,87,92,88,44,30,38,78},{93,6,77,55},{29,89,30,59,86,80,20},{6,31,25,81,75,64,79,37,56,30,71,4,86,53,31,81,56,86,36,76,30,96,19,99,3,15,4,82,87,7,35,55,10,3,52,19,2,1,4,80,32},{31,43,73,35,53},{77,93,1,13,82,55,74,3,77,19,23,30,73,24,74,68,99,60,5,65,53,9,33,73,73,76,62,40,28,44,14,25,38,97,99,37,90,48,41,99,70,77},{70,6,5,28,81,26,11,36,26,1,65,51,56,62,35,14,80,19,58,86,48,48,90,71,38,3,40,42,26},{8,13,98,48,25,57,55,61,44,83,6,86,22,88},{23,83,44,7,90,99,7,21,47,55},{47,92,94,44,92,99,28,96,94,51,23,33,27,7,99,30,49,87,31,79,95,13,7,22,93,60,96,61,90,57,23,84,69,60,17,29,77},{26,62,80,46,59,9,81,99,21,68,12,1,73,40,35,87,64,94,31,51,88,26},{9,95,69,50,63,28,83,12,81,57,16,22,23,97,36,78,91,5,50,21,1,14,92,10,62,19,30,82,81,84,41,40,78,88,68,27,4,78,61,99,8,67,82,58,38,42,64,43,29},{22,93,76,24,74,65,56,33,91,89,16,70,33,7,98,46,82,32,26,2,34,27,67,85,66,82,20,8},{63,98,27,78,7,32,13,25,58,5,46,10,30,47,79,65,33,84,60,95,18,79,69,20,36,43,13,20,72,30,32,94,59,8,70,7,54,18,50,56,65,61,70,3},{23,26,33,14,79,93,32,58,80,76,40,2,55},{48,40,9,29},{89,96,17,74,98,15,1,46,38,55,90,20,85,93,91,22,54},{72,14,76,72,64,61,27,93,87,63,55,95,32,66,19,74,34},{52,25,67,46,11,1,47,54,86,72,24,46,92,17,23,31,46,53,63,74,22,8,64,54,88,4,9,39,3,56,17,15,13,41,44,49,64},{53,42,4,10},{29,46,14,53,84,80,65,84,79,74,54,18,1,95,48,36,2,44,84,76,22,33,60,20,6,14,42,26,60,42,89,62,76,20,40,66,2,81,92,29,27,6,9,63,96,31,14},{18,81,90,96,76,61,26,17,22,24,42,66,98,17,65,80,23,65,77,90,47,56,17,3,15,51,14},{39,13,16,88,62,59,78}},{{94,44,83,3,47,11,36,61,29,34,43,94,79,3},{35,91,27,32,31,95,89,92,86,26,9,30,64,56,73,85,39,14,97,77,29,89,59,16,20,53,89,87,3,77,77,69,36,24,52,52,65,41,94,4,85,38,70,76,26,92,92,23,34},{80,40,74,57,81,40,53,27,82,44,51,91,42,31,55,79,52,66,53,27,23,24,53,72,58,11,23,82,67,41,88,84,95,78,76,73},{72,93,81,5,86,85,55,44,69,70,60,61,52,1,95,4,70,44,68,93,64,12,95,21,4,54,19,74,39,36,74,4,82,33,30,76,32,59,78,56,56,96,44,7,64,83,95},{36,69,97,32,86,60,10,45,74,25,74,72,73,56,46,71,51,95,31,95,97,95,40,64,15,63,78,63,72,23,71,19,57,51,7,27,50,58,31,6,90,41,70},{83,15,4,37,90,29,28,42,8,85,91,2,16,4,76,34,67,67,11,6,28,40,73,32,53,35,52,92,34,15,71,4,86,27,95,15,74,85,74,25,9,72,80,74,45,81,62},{90,54,30,4,42,25,99,8,74,27,77,35,91,8,17,28,39,83,62,90,49,18,94,38},{99,81,47,87,32,25,26,32,93,93,20,74,5,43,8,41,40,9,6,36,63,26,77},{3,73,96,98,94,41,51,93,75,93,93,31,26,11,26,29,83,77,23,84,13,58,62,31,22,83,14,70,45,89,63,82,74,80,73,58},{11,52},{52,49,6,36,12,79,79,89,58,21,43,21,32,15,68,46,43,11,37,71,58,59,50,28,66},{11,79,89,58,33,23,75,50,73,44,76},{89,9,37,14,7,43,93,70,46,79,58,85,22},{4,10,22,46,13,41,56,37,39,58,87,19,15,88,33,46,13,67,84,9,13,16,58,82,79,77,84,79,39,98,53,84,19,9,93,30,6,82,8,43,17},{62,21,34,86,98,44,81,14,82,54,44,53,36,33,2,68,19,37,60,68,6,31,44,52,95,78,24,20,56,58,11,31,61,79,84,20,35,53,79,60,18,30,43,90},{6,16,42,48,89,31,13,89,14,73,44,91,12,1,36,34,94,86,86,82,45,99,38,2,1,76,26,90,30,61,21,43,26,6,44,98,69,41,48,40,90,76,61,17,81,74,92,54,16},{15,8,16,84,86,34,34,75,92,67,54},{19,31,62,89,26,96,91,32,78,42,84,66,79,29,48,49,5,70,2,71,36,90,70,86,80,28,71,77,3},{17,5,88,70,37},{17,76,71,38,5,87,77,36,76,29,14,36,18,80,23,39},{21,37,68,55,90,49,24,88,13,97,97,61,71,29,89,75,98},{73,87,99,92,49,12,74,59,64,19,89,53,12,44,73,81,57,88,72,37,4,56,81,14,29,81,84,98,98,60,75,98,86,51,88},{35,7,98,35,89,39,27,69,30},{23},{91,65,2,73,12,91,47,14,48,1,69,95,81,59,36,79,35,9},{54,25,8,41,64,96,84,47,85},{68,54,56,89,25,27,83,2,24,87,86,4,96,29,69,93,32,2,22,75,28,44,81,49,13,26,67,78,55,39,33,5,62,95,80,95,78,34,36,30,98,99},{96,64,38,15,13,52,35,51,58,8,62,66,33,36,70,75,5,34,54,8,27,99,3,26,47,1,61,75},{85,51,48,48,79,4,61,32,30,94,40,65,7,86,75,27,89,47,19,99,55,96,24,70,37,27,26,47,33,81,36,13,14,39,90,92,54,93,83,93,67,35,47,75,54},{17,66,58,44,36,32,93,79,30,62,88,4,94,41,56,74,27,11,91,2,95,11,44,93,51,31,68,95,71,44,41,81,69,38,28,13,73,7,63,8,89,14,35},{82,91,99,3,24,5,56,84,15,51,33,55,78,52,19,32,36,81,73,34,57,45,79,36,13,73,39,79,43,50,3,73,70,30,3,88},{2,3,98,55,1,88,84,56,66,26,36,29,51,1,35,48,93,99,73,93,68,89,97,51,35,6,38,30,84,9,1,92,10,67,42,99},{92},{50,66,97,64,10,81,14,33,2,75,7,68,82,82,40,2,45,70,6,92,74,58,53,51,73,22,99,5,7,68,2,26,95,4,47,27,18,90,89,14,9},{80,61,92,13,68,82,89,28,7,35},{69,15,28,27,60,79,20},{38,31,3,33,58,82,75,73,67,42,42,76,23,15,81,82,16,63,71,68,44,26,78,31,48,15,65,65,51,37,49,16,68,61,93,13,59,23,34,84},{62,63,60,5,95,90,78,58,87,37,26,13,55,81,30,19,80,82,4,24},{8,11,45},{64,21,66,1,72,10,36,85,24,90,27,68,81,63,46,91,3,81,83,44,33,67,72,31,96},{12,84,24,51,57,17,46,58,74,28,82,85,64,23,31,77,23,97,34,56,90,47,36},{76,18,75,5,93,67,79,43,73,16,46,19,19,54,38,56,99,60,88,31,48},{88,10,77,8,66,37,46,51,95,71,43,78,24,14,78,9,88,76,33,27,58},{37,14,60,29,82,67,7,19,7,47,33,87,69,21,77,82,55,73,68,43,89,97,50,92,91,33,31,96,13,84,18,86,96,61,74,22,51,4,76,23,97,63,66},{93,33,45,89,72,53,28,7,43,51,64,71,29,49,7,49,65,99,60,75,12,72,97,4,41,41,68,44,47,26,66},{6,37,42,78,68,92}},{{73,76,46,23,86,18,9,70,59,62,16,29,73},{61,96,64,50,73,94,12,57,61},{94,91,84,25,31,11,12,3,44,40,49,47,25,34,98,31},{52,39,9,83,41,89,28,13,32,34,4,24,92,74,70,24,59,42,84,98,35,77,38,58,3,80,35,21,80},{86,91,2,3,3,90,9,69,43,69,63,3,64,81,37,50,57,58},{55,86,11,29,5,8,54,40,67,51,99,37,65,70,6,89,77,95,44,64,27,91,16,12,73,51,43,15,51,44,21,44,4,84},{59,63,28,26,57,36,55,65,66,74,61,39,94,55,37,4,36,36,39,51,92,11,50,87,37,51,53,77,24,77,22,45,92,31,21,99,73,18,72,55,59,76},{63,51,4,58,65,63,19,79,25,31,9,79,67,32,37,34,19,65,24,36,48,75},{12,97,13,26,16,69,64,92,90,72,61,1,40,13,59,1,44,44,70,50},{62,3,60,24,42,25,91,49,8,73,93,22,4,22,67,30,6,58,85,14,63,74,11,12,8,11,95,2,88,98,37,41,87,82,62,62,51},{52,74,28,24,98,78,22,44,90,79,47,99,22,30,28,37,39,91,35,7,57,99},{40,79,99,66,98,1,47,99,10,54,28,79,43,1,74,28,93,95,85,36,44,52,70,58,83,77,29,68,31,77,31,75,69,12,76},{17,55,59,48,74,43,12,36,24,73,94,69,22,20,34,66,44,9,84},{71,66,21,8,26,93,80,30,3,80,35,63,61,43,12,81,79,53,83,5,15,69,26,46,17,4,89,86,68,97,33,48,47},{47,27,37,82,69,28,65,13,74,14,67,81,43,61,75,95,54,45,98,87,5,27,69,6,99,82,55,45,26,58,52,19,97,22,41,24,74,9,27,11,87},{53,94,37,35,74,93,43,72,98,29,72,82,89,92,7,20,70,38,90,55,51,5,72,48,14,98,95,93,65,79,60,31,42,55,51,4},{24,57,83,16,92,22,33,51,80,19,78,68,29,67,99},{80,76,99,52,90,30,67,49,13,57,93,90,44,68,44,48,72,54,98,15,17,34,40,69,1},{67,81,18,33,82,69,42,42,57,88,82,9,9,75,83,87,37,81,15,86,52,24,7,44,58,90,21,70,29,81,82,88,23,2,33,39,5,76,98,85,93,74,11,79,52},{51,76,56,56,63,69,51,29,29,88,33,13,58,52,94,15,6,3,38,52,43,22,78,41,92,50,26,3,86,71,68,76,87,8,25},{98},{6,60,39,44,3,58,75,97,29,49,88,44,92,43,12,5,38,75,57,3,85,16,86,62,16,40,76,37,5,69,16,63,84,78,74,18,4,89,73,67,60,56,10,3,61,64,24}}};
for (int i =0; i < len(param0); i+=2 )
for (int j =0; j < param0[i].size(); ++j )
for (int k =0; k < param0[i][j].size(); ++k )
param0[i][j][k]= param0[i][j][k] %2;
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
for (int i =0; i < len(param0); ++i )
for (int j =0; j < param0[i].size(); ++j )
for (int k =0; k < param0[i][j].size(); ++k )
param0[i][j][k] %=2;
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
} | == | [
"a) )",
"b) (",
"c) ==",
"d) #include",
"e) ]"
] | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.