dataset_name stringclasses 1
value | src_lang stringclasses 1
value | entry_func stringclasses 1
value | prefix stringlengths 65 1.25k ⌀ | import_str listlengths 0 1 | suffix null | demos listlengths 0 0 | data_id stringlengths 9 106 | doc_string stringclasses 1
value | tgt_lang stringclasses 1
value | compare_func listlengths 0 0 | solution stringlengths 40 1.94k | task_name stringclasses 1
value | test_cases listlengths 10 11 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n, int k ) {
int p = 1;
if ( k % 2 ) p = - 1;
return ( pow ( n - 1, k ) + p * ( n - 1 ) ) / n;
}
| [] | null | [] | FIND_MAXIMUM_AVERAGE_SUBARRAY_OF_K_LENGTH | python | [] | def f_gold ( arr , n , k ) :
if k > n :
return - 1
csum = [ 0 ] * n
csum [ 0 ] = arr [ 0 ]
for i in range ( 1 , n ) :
csum [ i ] = csum [ i - 1 ] + arr [ i ] ;
max_sum = csum [ k - 1 ]
max_end = k - 1
for i in range ( k , n ) :
curr_sum = csum [ i ] - csum [ i - k ]
if curr_sum > max_sum :
max_sum = curr_sum
max_end = i
return max_end - k + 1
| code_translation | [
[
"[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], 29, 20",
"9"
],
[
"[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, 3... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int l, int r, int x ) {
if ( r >= l ) {
int mid = l + ( r - l ) / 2;
if ( arr [ mid ] == x ) return mid;
if ( arr [ mid ] > x ) return f_gold ( arr, l, mid - 1, x );
return f_gold ( arr, mid + 1, r, x );
}
return - 1;
}
| [] | null | [] | NUMBER_ORDERED_PAIRS_AI_AJ_0 | python | [] | def f_gold ( a , n ) :
count = 0
for i in range ( 0 , n ) :
for j in range ( i + 1 , n ) :
if ( a [ i ] & a [ j ] ) == 0 :
count += 2
return count
| code_translation | [
[
"[17, 20, 32, 35, 35, 36, 43, 47, 59, 59, 68, 69, 70, 70, 75, 82, 88, 94, 96, 99], 17",
"54"
],
[
"[-78, -40, 58, -36, 34, -12, -38, 48, -66, 16, 50, -26, -22, 46, -70, -68, -44, -52, -78, -50], 11",
"6"
],
[
"[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, ... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int m, int n, int x ) {
int table [ n + 1 ] [ x + 1 ];
memset ( table, 0, sizeof ( table ) );
for ( int j = 1;
j <= m && j <= x;
j ++ ) table [ 1 ] [ j ] = 1;
for ( int i = 2;
i <= n;
i ++ ) for ( int j = 1;
j <= x;
j ++ ) for ( int k = 1;
k <= m && k < j;
k ++ ) table [ i ] [ j ] += table [ i - 1 ] [ j - k ];
return table [ n ] [ x ];
}
| [] | null | [] | NUMBER_SUBSEQUENCES_AB_STRING_REPEATED_K_TIMES | python | [] | def f_gold ( s , K ) :
n = len ( s )
c1 = 0
c2 = 0
C = 0
for i in range ( n ) :
if s [ i ] == 'a' :
c1 += 1
if s [ i ] == 'b' :
c2 += 1
C += c1
return C * K + ( K * ( K - 1 ) / 2 ) * c1 * c2
| code_translation | [
[
"'abbc', 96",
"9312.0"
],
[
"'abahk', 7",
"49.0"
],
[
"'hugbabab', 5",
"75.0"
],
[
"'abadbc', 60",
"7260.0"
],
[
"'nkg9', 8",
"0.0"
],
[
"'jh7dab', 41",
"861.0"
],
[
"'abd', 87",
"3828.0"
],
[
"'aabb8yk', 4",
"40.0"
],
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
int dp [ n + 1 ];
dp [ 0 ] = 0;
for ( int i = 1;
i <= n;
i ++ ) {
if ( i >= 1 && i <= 3 ) dp [ i ] = 1;
else if ( i == 4 ) dp [ i ] = 2;
else dp [ i ] = dp [ i - 1 ] + dp [ i - 4 ];
}
return dp [ n ];
}
| [] | null | [] | MAXIMUM_SUM_BITONIC_SUBARRAY | python | [] | def f_gold ( arr , n ) :
msis = [ None ] * n
msds = [ None ] * n
max_sum = 0
msis [ 0 ] = arr [ 0 ]
for i in range ( 1 , n ) :
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 i in range ( n - 2 , - 1 , - 1 ) :
if ( arr [ i ] > arr [ i + 1 ] ) :
msds [ i ] = msds [ i + 1 ] + arr [ i ]
else :
msds [ i ] = arr [ i ]
for i in range ( n ) :
if ( max_sum < ( msis [ i ] + msds [ i ] - arr [ i ] ) ) :
max_sum = ( msis [ i ] + msds [ i ] - arr [ i ] )
return max_sum
| code_translation | [
[
"[7, 12, 16, 23, 26, 27, 39, 39, 40, 44, 57, 58, 77, 78, 81, 82, 84, 86, 91, 94, 94, 95, 97], 13",
"315"
],
[
"[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, -6... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n, int k ) {
int dist_count = 0;
for ( int i = 0;
i < n;
i ++ ) {
int j;
for ( j = 0;
j < n;
j ++ ) if ( i != j && arr [ j ] == arr [ i ] ) break;
if ( j == n ) dist_count ++;
if ( dist_count == k ) return arr [ i ];
}
return - 1;
}
| [] | null | [] | MAXIMUM_GAMES_PLAYED_WINNER | python | [] | def f_gold ( N ) :
dp = [ 0 for i in range ( N ) ]
dp [ 0 ] = 1
dp [ 1 ] = 2
i = 1
while dp [ i ] <= N :
i = i + 1
dp [ i ] = dp [ i - 1 ] + dp [ i - 2 ]
return ( i - 1 )
| code_translation | [
[
"73",
"8"
],
[
"28",
"6"
],
[
"33",
"6"
],
[
"23",
"6"
],
[
"84",
"8"
],
[
"31",
"6"
],
[
"48",
"7"
],
[
"46",
"7"
],
[
"45",
"7"
],
[
"90",
"9"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n ) {
int difference = 0;
int ans = 0;
int hash_positive [ n + 1 ], hash_negative [ n + 1 ];
fill_n ( hash_positive, n + 1, 0 );
fill_n ( hash_negative, n + 1, 0 );
hash_positive [ 0 ] = 1;
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] & 1 == 1 ) difference ++;
else difference --;
if ( difference < 0 ) {
ans += hash_negative [ - difference ];
hash_negative [ - difference ] ++;
}
else {
ans += hash_positive [ difference ];
hash_positive [ difference ] ++;
}
}
return ans;
}
| [] | null | [] | EFFICIENT_SEARCH_IN_AN_ARRAY_WHERE_DIFFERENCE_BETWEEN_ADJACENT_IS_1 | python | [] | def f_gold(arr, n, x):
i = 0
while (i <= n - 1):
if (arr[i] == x):
return i
i += abs(arr[i] - x)
return - 1
| code_translation | [
[
"[5, 4, 5, 6, 5, 4, 3, 2], 29, 6",
"3"
],
[
"[5, 4, 5, 6, 5, 4, 3, 2], 19, 3",
"6"
],
[
"[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], 37, 1",
"14"
],
[
"[50, 51, 52, 51, 50, 49, 48], 17, 49",
"... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
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;
}
| [] | null | [] | COUNT_SET_BITS_IN_AN_INTEGER_3 | python | [] | def f_gold ( n ) :
if ( n == 0 ) :
return 0
else :
return 1 + f_gold ( n & ( n - 1 ) )
| code_translation | [
[
"6",
"2"
],
[
"58",
"4"
],
[
"90",
"4"
],
[
"69",
"3"
],
[
"15",
"4"
],
[
"54",
"4"
],
[
"60",
"4"
],
[
"51",
"4"
],
[
"46",
"4"
],
[
"91",
"5"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int x, int y, int z ) {
if ( ! ( y / x ) ) return ( ! ( y / z ) ) ? y : z;
return ( ! ( x / z ) ) ? x : z;
}
| [] | null | [] | COMPUTE_N_UNDER_MODULO_P | python | [] | def f_gold ( n , p ) :
if n >= p :
return 0
result = 1
for i in range ( 1 , n + 1 ) :
result = ( result * i ) % p
return result
| code_translation | [
[
"85, 18",
"0"
],
[
"14, 13",
"0"
],
[
"83, 21",
"0"
],
[
"30, 35",
"0"
],
[
"96, 51",
"0"
],
[
"55, 58",
"0"
],
[
"82, 71",
"0"
],
[
"12, 74",
"44"
],
[
"38, 3",
"0"
],
[
"46, 73",
"67"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold | null | [] | null | [] | COUNT_FACTORIAL_NUMBERS_IN_A_GIVEN_RANGE | python | [] | def f_gold ( low , high ) :
fact = 1
x = 1
while ( fact < low ) :
fact = fact * x
x += 1
res = 0
while ( fact <= high ) :
res += 1
fact = fact * x
x += 1
return res
| code_translation | [
[
"57, 79",
"0"
],
[
"57, 21",
"0"
],
[
"31, 37",
"0"
],
[
"62, 87",
"0"
],
[
"49, 98",
"0"
],
[
"82, 76",
"0"
],
[
"31, 45",
"0"
],
[
"5, 52",
"2"
],
[
"76, 43",
"0"
],
[
"55, 6",
"0"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold | null | [] | null | [] | FIND_THE_ELEMENT_THAT_APPEARS_ONCE | python | [] | def f_gold ( arr , n ) :
ones = 0
twos = 0
for i in range ( n ) :
twos = twos | ( ones & arr [ i ] )
ones = ones ^ arr [ i ]
common_bit_mask = ~ ( ones & twos )
ones &= common_bit_mask
twos &= common_bit_mask
return ones
| code_translation | [
[
"[7, 26, 26, 48, 59, 62, 66, 70, 72, 75, 76, 81, 97, 98], 7",
"72"
],
[
"[-42, -48, -64, -74, 56, -34, 20, 16, 34, -84, 86, 38, 56, -86, 30, -74, -96, 96, 12, 10, -46, 10, -36, 38, 34, -46, -20, 14, 12, 62, -54, 20, -82, 24, 96], 27",
"-28"
],
[
"[0, 0, 1, 1], 3",
"1"
],
[
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( string str ) {
int result = 0;
for ( int i = 0;
i < str . size ( );
i ++ ) if ( i == ( str [ i ] - 'a' ) || i == ( str [ i ] - 'A' ) ) result ++;
return result;
}
| [] | null | [] | PAINTING_FENCE_ALGORITHM | python | [] | def f_gold ( n , k ) :
total = k
mod = 1000000007
same , diff = 0 , k
for i in range ( 2 , n + 1 ) :
same = diff
diff = total * ( k - 1 )
diff = diff % mod
total = ( same + diff ) % mod
return total
| code_translation | [
[
"6, 30",
"725841870"
],
[
"23, 87",
"370622679"
],
[
"89, 31",
"7554776"
],
[
"63, 36",
"76740139"
],
[
"23, 68",
"647498520"
],
[
"44, 66",
"70208793"
],
[
"81, 18",
"227130467"
],
[
"43, 73",
"204618786"
],
[
"9,... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
return ( n * n ) + ( n * n * n );
}
| [] | null | [] | COUNT_POSSIBLE_PATHS_TOP_LEFT_BOTTOM_RIGHT_NXM_MATRIX_2 | python | [] | def f_gold ( p , q ) :
dp = [ 1 for i in range ( q ) ]
for i in range ( p - 1 ) :
for j in range ( 1 , q ) :
dp [ j ] += dp [ j - 1 ]
return dp [ q - 1 ]
| code_translation | [
[
"73, 75",
"5800834723650648582408201347161496628568500"
],
[
"70, 5",
"1088430"
],
[
"53, 62",
"544984327577929166763558054404688"
],
[
"80, 70",
"16698257436934424602116017431974081551656800"
],
[
"9, 59",
"5743572120"
],
[
"38, 48",
"9310640289... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
long int dp [ n + 1 ] [ 27 ];
memset ( dp, 0, sizeof ( dp ) );
for ( int i = 0;
i <= 25;
i ++ ) dp [ 1 ] [ i ] = 1;
for ( int i = 2;
i <= n;
i ++ ) {
for ( int j = 0;
j <= 25;
j ++ ) if ( j == 0 ) dp [ i ] [ j ] = dp [ i - 1 ] [ j + 1 ];
else dp [ i ] [ j ] = ( dp [ i - 1 ] [ j - 1 ] + dp [ i - 1 ] [ j + 1 ] );
}
long int sum = 0;
for ( int i = 0;
i <= 25;
i ++ ) sum = ( sum + dp [ n ] [ i ] );
return sum;
}
| [] | null | [] | SUM_MATRIX_ELEMENT_ELEMENT_INTEGER_DIVISION_ROW_COLUMN | python | [] | def f_gold ( N ) :
ans = 0
for i in range ( 1 , N + 1 ) :
for j in range ( 1 , N + 1 ) :
ans += i // j
return ans
| code_translation | [
[
"60",
"7021"
],
[
"74",
"11190"
],
[
"8",
"77"
],
[
"74",
"11190"
],
[
"34",
"1974"
],
[
"66",
"8680"
],
[
"96",
"19920"
],
[
"11",
"156"
],
[
"45",
"3697"
],
[
"72",
"10530"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int num ) {
if ( num < 0 ) return f_gold ( - num );
if ( num == 0 || num == 7 ) return 1;
if ( num < 10 ) return 0;
return f_gold ( num / 10 - 2 * ( num - num / 10 * 10 ) );
}
| [] | null | [] | DOUBLE_FACTORIAL | python | [] | def f_gold ( n ) :
if ( n == 0 or n == 1 ) :
return 1 ;
return n * f_gold ( n - 2 ) ;
| code_translation | [
[
"52",
"27064431817106664380040216576000000"
],
[
"93",
"2987435000850314871976096554696085799164511452611632783323554397412109375"
],
[
"15",
"2027025"
],
[
"72",
"25563186766285862273530264901662157745369907200000000"
],
[
"61",
"178215198865986332638610166... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( char str [ ], int n ) {
int ans = ( n * ( n + 1 ) ) / 2;
int a_index = 0;
int b_index = 0;
int c_index = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( str [ i ] == 'a' ) {
a_index = i + 1;
ans -= min ( b_index, c_index );
}
else if ( str [ i ] == 'b' ) {
b_index = i + 1;
ans -= min ( a_index, c_index );
}
else {
c_index = i + 1;
ans -= min ( a_index, b_index );
}
}
return ans;
}
| [] | null | [] | COUNT_NUMBER_WAYS_TILE_FLOOR_SIZE_N_X_M_USING_1_X_M_SIZE_TILES | python | [] | def f_gold ( n , m ) :
count = [ ]
for i in range ( n + 2 ) :
count.append ( 0 )
count [ 0 ] = 0
for i in range ( 1 , n + 1 ) :
if ( i > m ) :
count [ i ] = count [ i - 1 ] + count [ i - m ]
elif ( i < m ) :
count [ i ] = 1
else :
count [ i ] = 2
return count [ n ]
| code_translation | [
[
"93, 54",
"41"
],
[
"17, 4",
"131"
],
[
"38, 39",
"1"
],
[
"33, 64",
"1"
],
[
"78, 35",
"90"
],
[
"40, 61",
"1"
],
[
"95, 6",
"10665883415"
],
[
"12, 8",
"6"
],
[
"69, 60",
"11"
],
[
"78, 21",
"1578... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
double f_gold ( double a, double b ) {
double mod;
if ( a < 0 ) mod = - a;
else mod = a;
if ( b < 0 ) b = - b;
while ( mod >= b ) mod = mod - b;
if ( a < 0 ) return - mod;
return mod;
}
| [] | null | [] | PROGRAM_PRINT_IDENTITY_MATRIX_1 | python | [] | def f_gold ( mat , N ) :
for row in range ( N ) :
for col in range ( N ) :
if ( row == col and mat [ row ] [ col ] != 1 ) :
return False ;
elif ( row != col and mat [ row ] [ col ] != 0 ) :
return False ;
return True ;
| code_translation | [
[
"[[]], 0",
"True"
],
[
"[[1]], 1",
"True"
],
[
"[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]], 4",
"True"
],
[
"[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [1, 0, 0, 1]], 4",
"False"
],
[
"[[7, 28, 37, 88, 70, 41, 11, 67, 9, 9, 35, 80, 99, 45, 41, 88, ... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
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;
}
| [] | null | [] | DYNAMIC_PROGRAMMING_SET_37_BOOLEAN_PARENTHESIZATION_PROBLEM | python | [] | def f_gold ( symb , oper , n ) :
F = [ [ 0 for i in range ( n + 1 ) ] for i in range ( n + 1 ) ]
T = [ [ 0 for i in range ( n + 1 ) ] for i in range ( n + 1 ) ]
for i in range ( n ) :
if symb [ i ] == 'F' :
F [ i ] [ i ] = 1
else :
F [ i ] [ i ] = 0
if symb [ i ] == 'T' :
T [ i ] [ i ] = 1
else :
T [ i ] [ i ] = 0
for gap in range ( 1 , n ) :
i = 0
for j in range ( gap , n ) :
T [ i ] [ j ] = F [ i ] [ j ] = 0
for g in range ( gap ) :
k = i + g
tik = T [ i ] [ k ] + F [ i ] [ k ] ;
tkj = T [ k + 1 ] [ j ] + F [ k + 1 ] [ j ] ;
if oper [ k ] == '&' :
T [ i ] [ j ] += T [ i ] [ k ] * T [ k + 1 ] [ j ]
F [ i ] [ j ] += ( tik * tkj - T [ i ] [ k ] * T [ k + 1 ] [ j ] )
if oper [ k ] == '|' :
F [ i ] [ j ] += F [ i ] [ k ] * F [ k + 1 ] [ j ]
T [ i ] [ j ] += ( tik * tkj - F [ i ] [ k ] * F [ k + 1 ] [ j ] )
if oper [ k ] == '^' :
T [ i ] [ j ] += ( F [ i ] [ k ] * T [ k + 1 ] [ j ] + T [ i ] [ k ] * F [ k + 1 ] [ j ] )
F [ i ] [ j ] += ( T [ i ] [ k ] * T [ k + 1 ] [ j ] + F [ i ] [ k ] * F [ k + 1 ] [ j ] )
i += 1
return T [ 0 ] [ n - 1 ]
| code_translation | [
[
"'TTFT', '|&^', 4",
"4"
],
[
"'TFT', '^&', 3",
"2"
],
[
"'TFF', '^|', 3",
"2"
],
[
"'TTFT', '|||', 4",
"5"
],
[
"'TTFT', '&&&', 4",
"0"
],
[
"'TTFT', '&&^', 4",
"5"
],
[
"'TTFT', '^&|', 4",
"2"
],
[
"'TTFT', '^^^', 4",
"5"... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int x, int y ) {
x = x % 10;
if ( y != 0 ) y = y % 4 + 4;
return ( ( ( int ) ( pow ( x, y ) ) ) % 10 );
}
| [
"from math import sqrt"
] | null | [] | PROGRAM_TO_FIND_THE_AREA_OF_PENTAGON | python | [] | from math import sqrt
def f_gold ( a ) :
area = ( sqrt ( 5 * ( 5 + 2 * ( sqrt ( 5 ) ) ) ) * a * a ) / 4
return area
| code_translation | [
[
"2009.019461888707",
"6944120.6857642615"
],
[
"-1480.5131394215787",
"3771147.371815937"
],
[
"357.7870347569567",
"220240.9998483103"
],
[
"-8040.293697508038",
"111222537.30911414"
],
[
"3821.882657293133",
"25130647.008061722"
],
[
"-6840.6350722... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int base ) {
base = ( base - 2 );
base = base / 2;
return base * ( base + 1 ) / 2;
}
| [] | null | [] | MAXIMUM_CONSECUTIVE_NUMBERS_PRESENT_ARRAY | python | [] | def f_gold ( arr , n ) :
S = set ( ) ;
for i in range ( n ) :
S.add ( arr [ i ] ) ;
ans = 0 ;
for i in range ( n ) :
if S.__contains__ ( arr [ i ] ) :
j = arr [ i ] ;
while ( S.__contains__ ( j ) ) :
j += 1 ;
ans = max ( ans , j - arr [ i ] ) ;
return ans ;
| code_translation | [
[
"[3, 5, 9, 24, 28, 31, 49, 54, 67, 85, 86, 94, 97, 97], 11",
"2"
],
[
"[-34, 16, -80, -10, 80, 2, 50, -74, -76, 36, -84, -24, 74, -54, -22, 46, 80, 58, -8, 70, 24, -88, 52, 62, 30, 42, 48, 16, 78, -82, 64, -36, 84, -72], 29",
"1"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( int p ) {
long long checkNumber = pow ( 2, p ) - 1;
long long nextval = 4 % checkNumber;
for ( int i = 1;
i < p - 1;
i ++ ) nextval = ( nextval * nextval - 2 ) % checkNumber;
return ( nextval == 0 );
}
| [] | null | [] | LARGEST_SUM_CONTIGUOUS_SUBARRAY_2 | python | [] | def f_gold ( a , size ) :
max_so_far = a [ 0 ]
curr_max = a [ 0 ]
for i in range ( 1 , size ) :
curr_max = max ( a [ i ] , curr_max + a [ i ] )
max_so_far = max ( max_so_far , curr_max )
return max_so_far
| code_translation | [
[
"[1, 3, 4, 7, 8, 8, 10, 12, 16, 19, 19, 20, 20, 21, 21, 22, 26, 27, 29, 34, 36, 38, 38, 39, 41, 43, 44, 47, 47, 49, 57, 57, 60, 62, 63, 65, 75, 77, 77, 78, 81, 82, 82, 83, 83, 84, 85, 98, 99], 38",
"1265"
],
[
"[-40, 14, 2, -70, 86, -90, -50, -54, -2, 90, 30], 10",
"90"
],
[
"[0, 0, 0,... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int A [ ], int n ) {
int min_val = * min_element ( A, A + n );
return ( min_val * ( n - 1 ) );
}
| [] | null | [] | MINIMUM_SUM_TWO_NUMBERS_FORMED_DIGITS_ARRAY_2 | python | [] | def f_gold ( a , n ) :
a = sorted ( a )
num1 , num2 = 0 , 0
for i in range ( n ) :
if i % 2 == 0 :
num1 = num1 * 10 + a [ i ]
else :
num2 = num2 * 10 + a [ i ]
return num2 + num1
| code_translation | [
[
"[4, 16, 29, 30, 38, 83], 5",
"918"
],
[
"[58, 74, -28, -60, -6, 66, -76, 46, 0, -24, 28, -16, -14, 24, -94, -56, -80, 40, -18, -68, -8, -94, -88, -12, -20, -8], 16",
"-2063616120"
],
[
"[0, 1], 1",
"0"
],
[
"[7, 12, 78, 8], 3",
"90"
],
[
"[-78, -48, -48, -26, 8... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
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 ];
}
| [] | null | [] | MODULAR_EXPONENTIATION_POWER_IN_MODULAR_ARITHMETIC | python | [] | def f_gold ( x , y , p ) :
res = 1
x = x % p
while ( y > 0 ) :
if ( ( y & 1 ) == 1 ) :
res = ( res * x ) % p
y = y >> 1
x = ( x * x ) % p
return res
| code_translation | [
[
"45, 5, 68",
"61"
],
[
"67, 25, 49",
"18"
],
[
"26, 91, 44",
"4"
],
[
"33, 61, 9",
"0"
],
[
"35, 8, 13",
"3"
],
[
"68, 41, 5",
"3"
],
[
"14, 76, 20",
"16"
],
[
"5, 89, 13",
"5"
],
[
"23, 42, 45",
"19"
],
[
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int ar1 [ ], int ar2 [ ], int n ) {
int i = 0;
int j = 0;
int count;
int m1 = - 1, m2 = - 1;
for ( count = 0;
count <= n;
count ++ ) {
if ( i == n ) {
m1 = m2;
m2 = ar2 [ 0 ];
break;
}
else if ( j == n ) {
m1 = m2;
m2 = ar1 [ 0 ];
break;
}
if ( ar1 [ i ] < ar2 [ j ] ) {
m1 = m2;
m2 = ar1 [ i ];
i ++;
}
else {
m1 = m2;
m2 = ar2 [ j ];
j ++;
}
}
return ( m1 + m2 ) / 2;
}
| [] | null | [] | WRITE_A_C_PROGRAM_TO_FIND_THE_PARITY_OF_AN_UNSIGNED_INTEGER | python | [] | def f_gold ( n ) :
parity = 0
while n :
parity = ~ parity
n = n & ( n - 1 )
return parity
| code_translation | [
[
"63",
"0"
],
[
"64",
"-1"
],
[
"85",
"0"
],
[
"36",
"0"
],
[
"20",
"0"
],
[
"63",
"0"
],
[
"42",
"-1"
],
[
"19",
"-1"
],
[
"62",
"-1"
],
[
"97",
"-1"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int a, int b ) {
if ( a == b ) return a;
if ( a == 0 ) return b;
if ( b == 0 ) return a;
if ( ~ a & 1 ) {
if ( b & 1 ) return f_gold ( a >> 1, b );
else return f_gold ( a >> 1, b >> 1 ) << 1;
}
if ( ~ b & 1 ) return f_gold ( a, b >> 1 );
if ( a > b ) return f_gold ( ( a - b ) >> 1, b );
return f_gold ( ( b - a ) >> 1, a );
}
| [] | null | [] | SMALLEST_POWER_OF_2_GREATER_THAN_OR_EQUAL_TO_N_1 | python | [] | def f_gold ( n ) :
p = 1
if ( n and not ( n & ( n - 1 ) ) ) :
return n
while ( p < n ) :
p <<= 1
return p ;
| code_translation | [
[
"31",
"32"
],
[
"89",
"128"
],
[
"92",
"128"
],
[
"66",
"128"
],
[
"38",
"64"
],
[
"34",
"64"
],
[
"17",
"32"
],
[
"24",
"32"
],
[
"54",
"64"
],
[
"20",
"32"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
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 ];
}
| [] | null | [] | K_TH_MISSING_ELEMENT_INCREASING_SEQUENCE_NOT_PRESENT_GIVEN_SEQUENCE | python | [] | def f_gold ( a , b , k , n1 , n2 ) :
s = set ( )
for i in range ( n2 ) :
s.add ( b [ i ] )
missing = 0
for i in range ( n1 ) :
if a [ i ] not in s :
missing += 1
if missing == k :
return a [ i ]
return - 1
| code_translation | [
[
"[2, 9, 9, 13, 38, 41, 50, 59, 64, 64, 72, 78, 79, 80, 84, 92, 94, 98, 99], [5, 9, 11, 21, 24, 27, 30, 35, 38, 39, 40, 45, 48, 48, 51, 58, 61, 91, 92], 11, 9, 18",
"-1"
],
[
"[-54, -80, -62, 98, -68, 42, 98, 80, -8, -6, 26, 0, -60, -24, -74, -48, 4, -54, 20, 32, 42, 68, -50, 58, -50, 96, -34, 22, ... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( int arr [ ], int n, int x ) {
int i;
for ( i = 0;
i < n - 1;
i ++ ) if ( arr [ i ] > arr [ i + 1 ] ) break;
int l = ( i + 1 ) % n;
int r = i;
while ( l != r ) {
if ( arr [ l ] + arr [ r ] == x ) return true;
if ( arr [ l ] + arr [ r ] < x ) l = ( l + 1 ) % n;
else r = ( n + r - 1 ) % n;
}
return false;
}
| [] | null | [] | SUM_MATRIX_ELEMENT_ABSOLUTE_DIFFERENCE_ROW_COLUMN_NUMBERS | python | [] | def f_gold ( n ) :
arr = [ [ 0 for x in range ( n ) ] for y in range ( n ) ]
for i in range ( n ) :
for j in range ( n ) :
arr [ i ] [ j ] = abs ( i - j )
sum = 0
for i in range ( n ) :
for j in range ( n ) :
sum += arr [ i ] [ j ]
return sum
| code_translation | [
[
"60",
"71980"
],
[
"44",
"28380"
],
[
"72",
"124392"
],
[
"90",
"242970"
],
[
"99",
"323400"
],
[
"45",
"30360"
],
[
"27",
"6552"
],
[
"11",
"440"
],
[
"65",
"91520"
],
[
"52",
"46852"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int p [ ], int n ) {
int m [ n ] [ n ];
int i, j, k, L, q;
for ( i = 1;
i < n;
i ++ ) m [ i ] [ i ] = 0;
for ( L = 2;
L < n;
L ++ ) {
for ( i = 1;
i < n - L + 1;
i ++ ) {
j = i + L - 1;
m [ i ] [ j ] = INT_MAX;
for ( k = i;
k <= j - 1;
k ++ ) {
q = m [ i ] [ k ] + m [ k + 1 ] [ j ] + p [ i - 1 ] * p [ k ] * p [ j ];
if ( q < m [ i ] [ j ] ) m [ i ] [ j ] = q;
}
}
}
return m [ 1 ] [ n - 1 ];
}
| [] | null | [] | WRITE_YOU_OWN_POWER_WITHOUT_USING_MULTIPLICATION_AND_DIVISION | python | [] | def f_gold ( a , b ) :
if ( b == 0 ) :
return 1
answer = a
increment = a
for i in range ( 1 , b ) :
for j in range ( 1 , a ) :
answer += increment
increment = answer
return answer
| code_translation | [
[
"66, 4",
"18974736"
],
[
"82, 66",
"2049813067056723342764042528136639432893302901053747234410457506551439003896274462989048978198596972547480537410778555874279424"
],
[
"12, 38",
"102067469997853225734913580209377959215104"
],
[
"55, 33",
"27037638262714967295762346820... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( string str ) {
int len = str . length ( );
int open [ len + 1 ], close [ len + 1 ];
int index = - 1;
memset ( open, 0, sizeof ( open ) );
memset ( close, 0, sizeof ( close ) );
open [ 0 ] = 0;
close [ len ] = 0;
if ( str [ 0 ] == '(' ) open [ 1 ] = 1;
if ( str [ len - 1 ] == ')' ) close [ len - 1 ] = 1;
for ( int i = 1;
i < len;
i ++ ) {
if ( str [ i ] == '(' ) open [ i + 1 ] = open [ i ] + 1;
else open [ i + 1 ] = open [ i ];
}
for ( int i = len - 2;
i >= 0;
i -- ) {
if ( str [ i ] == ')' ) close [ i ] = close [ i + 1 ] + 1;
else close [ i ] = close [ i + 1 ];
}
if ( open [ len ] == 0 ) return len;
if ( close [ 0 ] == 0 ) return 0;
for ( int i = 0;
i <= len;
i ++ ) if ( open [ i ] == close [ i ] ) index = i;
return index;
}
| [] | null | [] | FIND_WHETHER_AN_ARRAY_IS_SUBSET_OF_ANOTHER_ARRAY_SET_1_1 | python | [] | def f_gold ( arr1 , arr2 , m , n ) :
i = 0
j = 0
if m < n :
return 0
arr1.sort ( )
arr2.sort ( )
while i < n and j < m :
if arr1 [ j ] < arr2 [ i ] :
j += 1
elif arr1 [ j ] == arr2 [ i ] :
j += 1
i += 1
elif arr1 [ j ] > arr2 [ i ] :
return 0
return False if i < n else True
| code_translation | [
[
"[7, 10, 10, 10, 13, 17, 23, 24, 25, 28, 30, 33, 37, 49, 49, 50, 57, 60, 60, 63, 63, 64, 65, 65, 72, 81, 84, 85, 85, 94, 96], [10, 13, 17, 63], 29, 4",
"True"
],
[
"[-94, -94, -92, -92, -90, -88, -86, -80, -76, -76, -68, -62, -58, -56, -54, -50, -42, -42, -20, -18, -18, -14, -8, -2, 0, 0, 0, 2, 6,... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int r ) {
if ( r <= 0 ) return 0;
int result = 4;
for ( int x = 1;
x < r;
x ++ ) {
int ySquare = r * r - x * x;
int y = sqrt ( ySquare );
if ( y * y == ySquare ) result += 4;
}
return result;
}
| [] | null | [] | SORT_EVEN_PLACED_ELEMENTS_INCREASING_ODD_PLACED_DECREASING_ORDER | python | [] | def f_gold ( arr , n ) :
evenArr = [ ]
oddArr = [ ]
for i in range ( n ) :
if ( ( i % 2 ) == 0 ) :
evenArr.append ( arr [ i ] )
else :
oddArr.append ( arr [ i ] )
evenArr = sorted ( evenArr )
oddArr = sorted ( oddArr )
oddArr = oddArr [ : : - 1 ]
i = 0
for j in range ( len ( evenArr ) ) :
arr [ i ] = evenArr [ j ]
i += 1
for j in range ( len ( oddArr ) ) :
arr [ i ] = oddArr [ j ]
i += 1
| code_translation | [
[
"[6, 6, 15, 38, 51, 79, 82, 85, 84, 81, 72, 50, 21, 10, 6, 86, 87], 15",
"None"
],
[
"[-24, 18, 26, 82, 20, -36, -88, -52, 28, 2], 7",
"None"
],
[
"[0, 0, 0, 1, 1, 1], 3",
"None"
],
[
"[35, 38, 81, 94, 70, 47, 43, 30, 57, 55, 78, 97, 72, 1], 8",
"None"
],
[
"[-8... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n ) {
unordered_map < int, int > hM;
int sum = 0;
int max_len = 0;
int ending_index = - 1;
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = ( arr [ i ] == 0 ) ? - 1 : 1;
for ( int i = 0;
i < n;
i ++ ) {
sum += arr [ i ];
if ( sum == 0 ) {
max_len = i + 1;
ending_index = i;
}
if ( hM . find ( sum + n ) != hM . end ( ) ) {
if ( max_len < i - hM [ sum + n ] ) {
max_len = i - hM [ sum + n ];
ending_index = i;
}
}
else hM [ sum + n ] = i;
}
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = ( arr [ i ] == - 1 ) ? 0 : 1;
printf ( "%d to %d\n", ending_index - max_len + 1, ending_index );
return max_len;
}
| [
"import math"
] | null | [] | CHECK_IF_A_NUMBER_IS_POWER_OF_ANOTHER_NUMBER_1 | python | [] | import math
def f_gold ( x , y ) :
res1 = math.log ( y ) / math.log ( x ) ;
res2 = math.log ( y ) / math.log ( x ) ;
return 1 if ( res1 == res2 ) else 0 ;
| code_translation | [
[
"57, 1",
"1"
],
[
"3, 9",
"1"
],
[
"10, 101",
"1"
],
[
"10, 10000",
"1"
],
[
"6, 46656",
"1"
],
[
"2, 2048",
"1"
],
[
"2, 40",
"1"
],
[
"20, 79",
"1"
],
[
"96, 98",
"1"
],
[
"25, 5",
"1"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
double f_gold ( vector < int > & A, int K ) {
int n = A . size ( );
double pre_sum [ n + 1 ];
pre_sum [ 0 ] = 0;
for ( int i = 0;
i < n;
i ++ ) pre_sum [ i + 1 ] = pre_sum [ i ] + A [ i ];
double dp [ n ] = {
0 };
double sum = 0;
for ( int i = 0;
i < n;
i ++ ) dp [ i ] = ( pre_sum [ n ] - pre_sum [ i ] ) / ( n - i );
for ( int k = 0;
k < K - 1;
k ++ ) for ( int i = 0;
i < n;
i ++ ) for ( int j = i + 1;
j < n;
j ++ ) dp [ i ] = max ( dp [ i ], ( pre_sum [ j ] - pre_sum [ i ] ) / ( j - i ) + dp [ j ] );
return dp [ 0 ];
}
| [] | null | [] | POLICEMEN_CATCH_THIEVES | python | [] | def f_gold ( arr , n , k ) :
i = 0
l = 0
r = 0
res = 0
thi = [ ]
pol = [ ]
while i < n :
if arr [ i ] == 'P' :
pol.append ( i )
elif arr [ i ] == 'T' :
thi.append ( i )
i += 1
while l < len ( thi ) and r < len ( pol ) :
if ( abs ( thi [ l ] - pol [ r ] ) <= k ) :
res += 1
l += 1
r += 1
elif thi [ l ] < pol [ r ] :
l += 1
else :
r += 1
return res
| code_translation | [
[
"['A', 'B', 'B', 'D', 'E', 'E', 'F', 'G', 'G', 'G', 'I', 'J', 'O', 'P', 'Q', 'Q', 'Q', 'Q', 'R', 'R', 'S', 'U', 'X', 'Y', 'Y', 'c', 'd', 'h', 'i', 'i', 'i', 'i', 'k', 'k', 'l', 'l', 'l', 'l', 'm', 'p', 'r', 'r', 's', 't', 't', 'u', 'x', 'z'], 33, 45",
"0"
],
[
"['7', '6', '0', '1', '0', '1'], 3, 3... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
int a = 1, b = 2, c = 0;
if ( n <= 2 ) {
return n;
}
for ( int i = 3;
i <= n;
i ++ ) {
c = b + ( i - 1 ) * a;
a = b;
b = c;
}
return c;
}
| [] | null | [] | DYNAMIC_PROGRAMMING_SET_36_CUT_A_ROPE_TO_MAXIMIZE_PRODUCT_1 | python | [] | def f_gold(n):
if (n == 2 or n == 3):
return (n - 1)
res = 1
while (n > 4):
n -= 3
res *= 3
return (n * res)
| code_translation | [
[
"62",
"6973568802"
],
[
"53",
"258280326"
],
[
"8",
"18"
],
[
"6",
"9"
],
[
"35",
"354294"
],
[
"35",
"354294"
],
[
"46",
"19131876"
],
[
"74",
"564859072962"
],
[
"69",
"94143178827"
],
[
"3",
"2"
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int a [ ], int n, int k ) {
int result = 0;
for ( int i = 0;
i < n;
++ i ) {
if ( a [ i ] != 1 && a [ i ] > k ) {
result = result + min ( a [ i ] % k, k - a [ i ] % k );
}
else {
result = result + k - a [ i ];
}
}
return result;
}
| [] | null | [] | MAXIMUM_CONSECUTIVE_REPEATING_CHARACTER_STRING | python | [] | def f_gold ( str ) :
l = len ( str )
count = 0
res = str [ 0 ]
for i in range ( l ) :
cur_count = 1
for j in range ( i + 1 , l ) :
if ( str [ i ] != str [ j ] ) :
break
cur_count += 1
if cur_count > count :
count = cur_count
res = str [ i ]
return res
| code_translation | [
[
"'geeekk'",
"'e'"
],
[
"'3786868'",
"'3'"
],
[
"'110'",
"'1'"
],
[
"'aaaabbcbbb'",
"'a'"
],
[
"'11'",
"'1'"
],
[
"'011101'",
"'1'"
],
[
"'WoHNyJYLC'",
"'W'"
],
[
"'3141711779'",
"'1'"
],
[
"'10111101101'",
"'1'... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n, int k ) {
priority_queue < int, vector < int >, greater < int > > pq;
for ( int i = 0;
i < n;
i ++ ) pq . push ( arr [ i ] );
int count = 0, ans = 1;
while ( pq . empty ( ) == false && count < k ) {
ans = ans * pq . top ( );
pq . pop ( );
count ++;
}
return ans;
}
| [] | null | [] | COUNT_NEGATIVE_NUMBERS_IN_A_COLUMN_WISE_ROW_WISE_SORTED_MATRIX | python | [] | def f_gold ( M , n , m ) :
count = 0
for i in range ( n ) :
for j in range ( m ) :
if M [ i ] [ j ] < 0 :
count += 1
else :
break
return count
| code_translation | [
[
"[[31, 92, 57, 28, 79, 84, 92, 19, 31, 71, 91, 46, 60, 79, 82, 4, 70, 82, 41, 79, 80, 29, 26, 76, 92, 18, 94, 55, 46, 69, 67, 60, 85, 25, 11], [58, 69, 14, 55, 6, 69, 81, 60, 38, 52, 81, 80, 1, 47, 42, 82, 2, 70, 68, 71, 50, 98, 84, 1, 45, 24, 49, 33, 56, 4, 60, 42, 14, 45, 13], [28, 92, 91, 71, 75, 97, 30, 9... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( char str [ ], int n ) {
int dp [ n ] [ n ];
memset ( dp, 0, sizeof ( dp ) );
bool P [ n ] [ n ];
memset ( P, false, sizeof ( P ) );
for ( int i = 0;
i < n;
i ++ ) P [ i ] [ i ] = true;
for ( int i = 0;
i < n - 1;
i ++ ) {
if ( str [ i ] == str [ i + 1 ] ) {
P [ i ] [ i + 1 ] = true;
dp [ i ] [ i + 1 ] = 1;
}
}
for ( int gap = 2;
gap < n;
gap ++ ) {
for ( int i = 0;
i < n - gap;
i ++ ) {
int j = gap + i;
if ( str [ i ] == str [ j ] && P [ i + 1 ] [ j - 1 ] ) P [ i ] [ j ] = true;
if ( P [ i ] [ j ] == true ) dp [ i ] [ j ] = dp [ i ] [ j - 1 ] + dp [ i + 1 ] [ j ] + 1 - dp [ i + 1 ] [ j - 1 ];
else dp [ i ] [ j ] = dp [ i ] [ j - 1 ] + dp [ i + 1 ] [ j ] - dp [ i + 1 ] [ j - 1 ];
}
}
return dp [ 0 ] [ n - 1 ];
}
| [] | null | [] | MAXIMIZE_VOLUME_CUBOID_GIVEN_SUM_SIDES_1 | python | [] | def f_gold ( s ) :
length = int ( s / 3 )
s -= length
breadth = s / 2
height = s - breadth
return int ( length * breadth * height )
| code_translation | [
[
"8",
"18"
],
[
"96",
"32768"
],
[
"96",
"32768"
],
[
"96",
"32768"
],
[
"12",
"64"
],
[
"95",
"31744"
],
[
"72",
"13824"
],
[
"81",
"19683"
],
[
"42",
"2744"
],
[
"13",
"81"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int a, int b, int c ) {
if ( ( a < b && b < c ) || ( c < b && b < a ) ) return b;
else if ( ( b < a && a < c ) || ( c < a && a < b ) ) return a;
else return c;
}
| [] | null | [] | NUMBER_OF_BINARY_TREES_FOR_GIVEN_PREORDER_SEQUENCE_LENGTH | python | [] | def f_gold(n):
BT = [0] * (n + 1)
BT[0] = BT[1] = 1
for i in range(2, n + 1):
for j in range(i):
BT[i] += BT[j] * BT[i - j - 1]
return BT[n]
| code_translation | [
[
"87",
"16435314834665426797069144960762886143367590394940"
],
[
"69",
"337485502510215975556783793455058624700"
],
[
"15",
"9694845"
],
[
"11",
"58786"
],
[
"11",
"58786"
],
[
"15",
"9694845"
],
[
"47",
"33868773757191046886429490"
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int x ) {
return ( ( x & 0x0F ) << 4 | ( x & 0xF0 ) >> 4 );
}
| [] | null | [] | CHECK_WHETHER_ARITHMETIC_PROGRESSION_CAN_FORMED_GIVEN_ARRAY | python | [] | def f_gold ( arr , n ) :
if ( n == 1 ) : return True
arr.sort ( )
d = arr [ 1 ] - arr [ 0 ]
for i in range ( 2 , n ) :
if ( arr [ i ] - arr [ i - 1 ] != d ) :
return False
return True
| code_translation | [
[
"[1, 4, 16, 64], 4",
"False"
],
[
"[0, 4, 8, 12], 4",
"True"
],
[
"[-2, 0, 2, 4, 6], 5",
"True"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 7",
"True"
],
[
"[46, 56, 66, 76, 86], 5",
"True"
],
[
"[46, 56, 56, 66, 76, 86], 6",
"False"
],
[
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
int ans = 0, temp = 0, num;
for ( int i = 1;
i <= n && temp < n;
i ++ ) {
temp = i - 1;
num = 1;
while ( temp < n ) {
if ( temp + i <= n ) ans += ( i * num );
else ans += ( ( n - temp ) * num );
temp += i;
num ++;
}
}
return ans;
}
| [] | null | [] | COUNT_PAIRS_WHOSE_PRODUCTS_EXIST_IN_ARRAY | python | [] | def f_gold ( arr , n ) :
result = 0 ;
for i in range ( 0 , n ) :
for j in range ( i + 1 , n ) :
product = arr [ i ] * arr [ j ] ;
for k in range ( 0 , n ) :
if ( arr [ k ] == product ) :
result = result + 1 ;
break ;
return result ;
| code_translation | [
[
"[3, 7, 26, 40, 46, 89, 99], 5",
"0"
],
[
"[98, 42, -24, -60, 74, 86, 6, 8, 72, -58, 38, -20, 6, -6, 8, 48, -34, 30, 60, 66, 38, -54, 8, -94, -8, 0, -64, -94, -94, -72, -84, -36, 88, -62, -88, 46, -4, 88], 24",
"6"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
if ( n <= 0 ) return 0;
int fibo [ n + 1 ];
fibo [ 0 ] = 0, fibo [ 1 ] = 1;
int sum = fibo [ 0 ] + fibo [ 1 ];
for ( int i = 2;
i <= n;
i ++ ) {
fibo [ i ] = fibo [ i - 1 ] + fibo [ i - 2 ];
sum += fibo [ i ];
}
return sum;
}
| [] | null | [] | MAXIMUM_CONSECUTIVE_REPEATING_CHARACTER_STRING_1 | python | [] | def f_gold ( str ) :
n = len ( str )
count = 0
res = str [ 0 ]
cur_count = 1
for i in range ( n ) :
if ( i < n - 1 and str [ i ] == str [ i + 1 ] ) :
cur_count += 1
else :
if cur_count > count :
count = cur_count
res = str [ i ]
cur_count = 1
return res
| code_translation | [
[
"'geeekk'",
"'e'"
],
[
"'3786868'",
"'3'"
],
[
"'110'",
"'1'"
],
[
"'aaaabbcbbb'",
"'a'"
],
[
"'11'",
"'1'"
],
[
"'011101'",
"'1'"
],
[
"'WoHNyJYLC'",
"'W'"
],
[
"'3141711779'",
"'1'"
],
[
"'10111101101'",
"'1'... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr1 [ ], int n, int arr2 [ ], int m ) {
int table [ m ];
for ( int j = 0;
j < m;
j ++ ) table [ j ] = 0;
for ( int i = 0;
i < n;
i ++ ) {
int current = 0;
for ( int j = 0;
j < m;
j ++ ) {
if ( arr1 [ i ] == arr2 [ j ] ) if ( current + 1 > table [ j ] ) table [ j ] = current + 1;
if ( arr1 [ i ] > arr2 [ j ] ) if ( table [ j ] > current ) current = table [ j ];
}
}
int result = 0;
for ( int i = 0;
i < m;
i ++ ) if ( table [ i ] > result ) result = table [ i ];
return result;
}
| [] | null | [] | C_PROGRAM_CONCATENATE_STRING_GIVEN_NUMBER_TIMES | python | [] | def f_gold ( s , n ) :
s1 = s
for i in range ( 1 , n ) :
s += s1
return s
| code_translation | [
[
"'LPWsaI', 41",
"'LPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaI'"
],
[
"'9037515104', 72",
"'... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n ) {
unordered_set < int > us;
int even_count = 0;
for ( int i = 0;
i < n;
i ++ ) if ( arr [ i ] % 2 == 0 ) us . insert ( arr [ i ] );
unordered_set < int > :: iterator itr;
for ( itr = us . begin ( );
itr != us . end ( );
itr ++ ) even_count ++;
return ( pow ( 2, even_count ) - 1 );
}
| [] | null | [] | COUNT_NUMBER_OF_OCCURRENCES_OR_FREQUENCY_IN_A_SORTED_ARRAY | python | [] | def f_gold ( arr , n , x ) :
res = 0
for i in range ( n ) :
if x == arr [ i ] :
res += 1
return res
| code_translation | [
[
"[16, 18, 24, 27, 34, 36, 41, 43, 43, 52, 59, 76, 86, 87, 90, 91, 94, 96, 98, 98], 14, 43",
"2"
],
[
"[64, 66, -36], 1, 64",
"1"
],
[
"[0, 0, 0], 2, 0",
"2"
],
[
"[9, 85, 34, 43, 70, 96, 44, 7, 27, 33, 34, 5, 91, 84, 76, 45, 20, 37, 15, 37, 20, 24, 13, 49, 74, 13, 50, 81, 8... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int low, int high ) {
if ( high < low ) return 0;
if ( high == low ) return low;
int mid = low + ( high - low ) / 2;
if ( mid < high && arr [ mid + 1 ] < arr [ mid ] ) return ( mid + 1 );
if ( mid > low && arr [ mid ] < arr [ mid - 1 ] ) return mid;
if ( arr [ high ] > arr [ mid ] ) return f_gold ( arr, low, mid - 1 );
return f_gold ( arr, mid + 1, high );
}
| [] | null | [] | FIRST_ELEMENT_OCCURRING_K_TIMES_ARRAY | python | [] | def f_gold ( arr , n , k ) :
count_map = { } ;
for i in range ( 0 , n ) :
if ( arr [ i ] in count_map.keys ( ) ) :
count_map [ arr [ i ] ] += 1
else :
count_map [ arr [ i ] ] = 1
i += 1
for i in range ( 0 , n ) :
if ( count_map [ arr [ i ] ] == k ) :
return arr [ i ]
i += 1
return - 1
| code_translation | [
[
"[2, 3, 4, 4, 7, 18, 20, 23, 27, 30, 31, 31, 32, 35, 36, 43, 45, 46, 49, 50, 53, 55, 59, 60, 64, 64, 65, 68, 78, 80, 80, 85, 95], 30, 2",
"4"
],
[
"[-26, 32, 36, 6, 64, 24, -28, 96], 6, 3",
"-1"
],
[
"[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, ... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int set [ ], int n ) {
if ( n <= 2 ) return n;
int L [ n ] [ n ];
int llap = 2;
for ( int i = 0;
i < n;
i ++ ) L [ i ] [ n - 1 ] = 2;
for ( int j = n - 2;
j >= 1;
j -- ) {
int i = j - 1, k = j + 1;
while ( i >= 0 && k <= n - 1 ) {
if ( set [ i ] + set [ k ] < 2 * set [ j ] ) k ++;
else if ( set [ i ] + set [ k ] > 2 * set [ j ] ) {
L [ i ] [ j ] = 2, i --;
}
else {
L [ i ] [ j ] = L [ j ] [ k ] + 1;
llap = max ( llap, L [ i ] [ j ] );
i --;
k ++;
}
}
while ( i >= 0 ) {
L [ i ] [ j ] = 2;
i --;
}
}
return llap;
}
| [] | null | [] | SPLIT_ARRAY_ADD_FIRST_PART_END | python | [] | def f_gold ( arr , n , k ) :
for i in range ( 0 , k ) :
x = arr [ 0 ]
for j in range ( 0 , n - 1 ) :
arr [ j ] = arr [ j + 1 ]
arr [ n - 1 ] = x
| code_translation | [
[
"[75], 0, 0",
"None"
],
[
"[12, -58, 90, -30, 10, -88, 2, -14, 82, -82, -58, -60, -38, 48, -2, 32, -48, -46, 90, -54, -18, 28, 72, 86, 0, -2, -74, -46, 2, -74], 27, 17",
"None"
],
[
"[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1], 7, 7",
"None"
],
[
"[51, 26, 36, 10, 62, 62, 56, 61, 67,... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int x, int y ) {
int res = 1;
for ( int i = 0;
i < y;
i ++ ) res = ( res * x ) % 10;
return res;
}
| [
"import heapq"
] | null | [] | K_TH_LARGEST_SUM_CONTIGUOUS_SUBARRAY | python | [] | import heapq
def f_gold ( arr , n , k ) :
sum = [ ]
sum.append ( 0 )
sum.append ( arr [ 0 ] )
for i in range ( 2 , n + 1 ) :
sum.append ( sum [ i - 1 ] + arr [ i - 1 ] )
Q = [ ]
heapq.heapify ( Q )
for i in range ( 1 , n + 1 ) :
for j in range ( i , n + 1 ) :
x = sum [ j ] - sum [ i - 1 ]
if len ( Q ) < k :
heapq.heappush ( Q , x )
else :
if Q [ 0 ] < x :
heapq.heappop ( Q )
heapq.heappush ( Q , x )
return Q [ 0 ]
| code_translation | [
[
"[2, 3, 5, 7, 8, 29, 29, 44, 47, 52, 60, 65, 73, 83, 87, 92, 92, 95], 10, 12",
"157"
],
[
"[44, -98, -10, 14, -6, -46, 6, -74, -4, 36, 10, -2, 30, 28, 96, -84, -36, -76, 64, -74, -20, 94, -4, 14, 78, 52, -56, 98, -68, -76, -10, 20, 88, -98, 96, 80, 96, -32, -40, -30, 82], 34, 37",
"166"
],
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int a [ ], int n ) {
unordered_set < int > s ( a, a + n );
int arr_sum = accumulate ( a, a + n, 0 );
int set_sum = accumulate ( s . begin ( ), s . end ( ), 0 );
return ( 3 * set_sum - arr_sum ) / 2;
}
| [] | null | [] | TEMPLE_OFFERINGS | python | [] | def f_gold ( n , templeHeight ) :
sum = 0
for i in range ( n ) :
left = 0
right = 0
for j in range ( i - 1 , - 1 , - 1 ) :
if ( templeHeight [ j ] < templeHeight [ j + 1 ] ) :
left += 1
else :
break
for j in range ( i + 1 , n ) :
if ( templeHeight [ j ] < templeHeight [ j - 1 ] ) :
right += 1
else :
break
sum += max ( right , left ) + 1
return sum
| code_translation | [
[
"12, [3, 11, 12, 15, 16, 21, 24, 29, 32, 39, 42, 44, 51, 68, 79, 81, 81, 85, 92, 94]",
"78"
],
[
"46, [76, 48, 88, 70, -64, 66, -6, -58, 26, -28, -42, -94, 80, -4, -56, -46, 4, 90, -12, -78, 64, 18, -38, 26, 56, -24, 66, -18, -12, 0, -94, 12, -10, 4, -68, -20, 88, 2, -58, 16, 46, -80, -42, 44, -86... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n, int m ) {
return ( m * n * ( n + 1 ) * ( m + 1 ) ) / 4;
}
| [] | null | [] | MINIMUM_NUMBER_OF_JUMPS_TO_REACH_END_OF_A_GIVEN_ARRAY_2 | python | [] | def f_gold ( arr , n ) :
jumps = [ 0 for i in range ( n ) ]
for i in range ( n - 2 , - 1 , - 1 ) :
if ( arr [ i ] == 0 ) :
jumps [ i ] = float ( 'inf' )
elif ( arr [ i ] >= n - i - 1 ) :
jumps [ i ] = 1
else :
min = float ( 'inf' )
for j in range ( i + 1 , n ) :
if ( j <= arr [ i ] + i ) :
if ( min > jumps [ j ] ) :
min = jumps [ j ]
if ( min != float ( 'inf' ) ) :
jumps [ i ] = min + 1
else :
jumps [ i ] = min
return jumps [ 0 ]
| code_translation | [
[
"[1, 6, 7, 14, 22, 32, 42, 42, 43, 48, 54, 57, 59, 69, 84, 92, 98], 11",
"3"
],
[
"[98, -66, -70, -64, -88, -76, -90, 16, 58, 68, -10, -42, -28, 10, 72, 68, -30, 60, 92, -56, 80, -4, -82, 30, 58, 98, -56, 98, -14, -38, -20, -74, -46, -22, 78, 36, -54, -64, 80, -10, -26, 82, 96, -72, -36, -36, -32,... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( int x, int y, int n ) {
int dp [ n + 1 ];
dp [ 0 ] = false;
dp [ 1 ] = true;
for ( int i = 2;
i <= n;
i ++ ) {
if ( i - 1 >= 0 and ! dp [ i - 1 ] ) dp [ i ] = true;
else if ( i - x >= 0 and ! dp [ i - x ] ) dp [ i ] = true;
else if ( i - y >= 0 and ! dp [ i - y ] ) dp [ i ] = true;
else dp [ i ] = false;
}
return dp [ n ];
}
| [] | null | [] | MINIMUM_SUM_SUBSEQUENCE_LEAST_ONE_EVERY_FOUR_CONSECUTIVE_ELEMENTS_PICKED | python | [] | def f_gold ( arr , n ) :
dp = [ 0 ] * n
if ( n == 1 ) :
return arr [ 0 ]
if ( n == 2 ) :
return min ( arr [ 0 ] , arr [ 1 ] )
if ( n == 3 ) :
return min ( arr [ 0 ] , min ( arr [ 1 ] , arr [ 2 ] ) )
if ( n == 4 ) :
return min ( min ( arr [ 0 ] , arr [ 1 ] ) , min ( arr [ 2 ] , arr [ 3 ] ) )
dp [ 0 ] = arr [ 0 ]
dp [ 1 ] = arr [ 1 ]
dp [ 2 ] = arr [ 2 ]
dp [ 3 ] = arr [ 3 ]
for i in range ( 4 , n ) :
dp [ i ] = arr [ i ] + min ( min ( dp [ i - 1 ] , dp [ i - 2 ] ) , min ( dp [ i - 3 ] , dp [ i - 4 ] ) )
return min ( min ( dp [ n - 1 ] , dp [ n - 2 ] ) , min ( dp [ n - 4 ] , dp [ n - 3 ] ) )
| code_translation | [
[
"[2, 7, 11, 12, 13, 14, 18, 20, 22, 26, 28, 29, 31, 32, 33, 35, 38, 38, 40, 40, 41, 42, 43, 44, 45, 53, 54, 54, 59, 62, 69, 72, 74, 75, 75, 76, 79, 83, 84, 89, 91, 96, 97, 98, 99, 99], 30",
"227"
],
[
"[50, -22, 90, -40, 46, 86, 50, 44, 12, -42, -58, 6, 52, -16, 4, 46, 44, 0, -64, 78, -14, -80, 30... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n ) {
queue < int > q;
sort ( arr, arr + n );
q . push ( arr [ 0 ] );
for ( int i = 1;
i < n;
i ++ ) {
int now = q . front ( );
if ( arr [ i ] >= 2 * now ) q . pop ( );
q . push ( arr [ i ] );
}
return q . size ( );
}
| [] | null | [] | PRODUCT_NODES_K_TH_LEVEL_TREE_REPRESENTED_STRING | python | [] | def f_gold ( tree , k ) :
level = - 1
product = 1
n = len ( tree )
for i in range ( 0 , n ) :
if ( tree [ i ] == '(' ) :
level += 1
elif ( tree [ i ] == ')' ) :
level -= 1
else :
if ( level == k ) :
product *= ( int ( tree [ i ] ) - int ( '0' ) )
return product
| code_translation | [
[
"'(0(5(6()())(4()(9()())))(7(1()())(3()())))', 2",
"72"
],
[
"'(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))', 3",
"15"
],
[
"'(0(5(6()())(4()(9()())))(7(1()())(3()())))', 1",
"35"
],
[
"'(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))', 2",
"0"
],
[
"'(8(... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int k ) {
return k * k * k;
}
| [] | null | [] | RECURSIVE_C_PROGRAM_LINEARLY_SEARCH_ELEMENT_GIVEN_ARRAY | python | [] | def f_gold ( arr , l , r , 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 )
| code_translation | [
[
"[10, 74, 5], 0, 2, 1",
"-1"
],
[
"[-90, 72, 36, 96, 42, 0, -66, 5], 0, 7, 96",
"3"
],
[
"[0, 5], 0, 1, -1",
"-1"
],
[
"[99, 70, 67, 5], 0, 3, 3",
"-1"
],
[
"[-98, -98, -26, -26, -24, -18, -16, 80, 5], 0, 8, 80",
"7"
],
[
"[1, 1, 1, 1, 0, 1, 5], 0, 6... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n ) {
unordered_map < int, int > mp;
for ( int i = 0;
i < n;
i ++ ) mp [ arr [ i ] ] ++;
for ( int i = 0;
i < n;
i ++ ) if ( mp [ arr [ i ] ] == 1 ) return arr [ i ];
return - 1;
}
| [] | null | [] | CHECK_POSSIBLE_SORT_ARRAY_CONDITIONAL_SWAPPING_ADJACENT_ALLOWED | python | [] | def f_gold ( arr , n ) :
for i in range ( 0 , n - 1 ) :
if ( arr [ i ] > arr [ i + 1 ] ) :
if ( arr [ i ] - arr [ i + 1 ] == 1 ) :
arr [ i ] , arr [ i + 1 ] = arr [ i + 1 ] , arr [ i ]
else :
return False
return True
| code_translation | [
[
"[1, 4, 12, 16, 37, 44, 47, 51, 55, 57, 57, 62, 62, 62, 64, 69, 69, 70, 72, 81, 81, 88, 89, 97], 15",
"True"
],
[
"[-86, 0, 14, -16, -12, -72, 62, -34, -72, 30, 84, -60, 84, -64, 50, 74, 18, -82, -64, -64, -74, -56, 86, 84, -32, -10, 20, 4, 8, 96, 82, 26, 42], 18",
"False"
],
[
"[0, 0,... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
int A [ n + 1 ], B [ n + 1 ];
A [ 0 ] = 1, A [ 1 ] = 0, B [ 0 ] = 0, B [ 1 ] = 1;
for ( int i = 2;
i <= n;
i ++ ) {
A [ i ] = A [ i - 2 ] + 2 * B [ i - 1 ];
B [ i ] = A [ i - 1 ] + B [ i - 2 ];
}
return A [ n ];
}
| [] | null | [] | C_PROGRAM_FACTORIAL_NUMBER_2 | python | [] | def f_gold ( n ) :
return 1 if ( n == 1 or n == 0 ) else n * f_gold ( n - 1 )
| code_translation | [
[
"66",
"544344939077443064003729240247842752644293064388798874532860126869671081148416000000000000000"
],
[
"93",
"1156772507081641574759205162306240436214753229576413535186142281213246807121467315215203289516844845303838996289387078090752000000000000000000000"
],
[
"39",
"203978820... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int a, int b ) {
if ( a == 0 ) return b;
return f_gold ( b % a, a );
}
| [] | null | [] | SUM_SERIES_23_45_67_89_UPTO_N_TERMS | python | [] | def f_gold ( n ) :
i = 1 ;
res = 0.0 ;
sign = True ;
while ( n > 0 ) :
n = n - 1 ;
if ( sign ) :
sign = False ;
res = res + ( i + 1 ) / ( i + 2 ) ;
i = i + 2 ;
else :
sign = True ;
res = res - ( i + 1 ) / ( i + 2 ) ;
i = i + 2 ;
return res ;
| code_translation | [
[
"49",
"0.7803986631477524"
],
[
"4",
"-0.16507936507936516"
],
[
"60",
"-0.21050375120783382"
],
[
"90",
"-0.21185466678122022"
],
[
"96",
"-0.2120245854859959"
],
[
"29",
"0.7770671416747363"
],
[
"86",
"-0.21172836828074082"
],
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n, int k ) {
if ( k > n ) return - 1;
int sum = arr [ 0 ];
for ( int i = 1;
i < k;
i ++ ) sum += arr [ i ];
int max_sum = sum, max_end = k - 1;
for ( int i = k;
i < n;
i ++ ) {
int sum = sum + arr [ i ] - arr [ i - k ];
if ( sum > max_sum ) {
max_sum = sum;
max_end = i;
}
}
return max_end - k + 1;
}
| [] | null | [] | COUNT_NUMBER_PAIRS_N_B_N_GCD_B_B | python | [] | def f_gold(n):
k = n
imin = 1
ans = 0
while (imin <= n):
imax = n / k
ans += k * (imax - imin + 1)
imin = imax + 1
k = n / imin
return ans
| code_translation | [
[
"17",
"58.47239288489289"
],
[
"72",
"349.9783310569835"
],
[
"43",
"187.0499406858786"
],
[
"55",
"252.6486716559348"
],
[
"62",
"291.1683590456309"
],
[
"22",
"81.19789150478006"
],
[
"17",
"58.47239288489289"
],
[
"68",
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int N ) {
queue < int > q;
q . push ( 1 );
int cnt = 0;
int t;
while ( ! q . empty ( ) ) {
t = q . front ( );
q . pop ( );
if ( t <= N ) {
cnt ++;
q . push ( t * 10 );
q . push ( t * 10 + 1 );
}
}
return cnt;
}
| [
"import math"
] | null | [] | CALCULATE_VOLUME_DODECAHEDRON | python | [] | import math
def f_gold ( side ) :
return ( ( ( 15 + ( 7 * ( math.sqrt ( 5 ) ) ) ) / 4 ) * ( math.pow ( side , 3 ) ) )
| code_translation | [
[
"56",
"1345766.2993890555"
],
[
"73",
"2981083.5487053124"
],
[
"22",
"81596.89069273109"
],
[
"10",
"7663.118960624633"
],
[
"84",
"4541961.260438062"
],
[
"20",
"61304.95168499706"
],
[
"51",
"1016520.3932458181"
],
[
"91",
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n ) {
unordered_map < int, int > inc, dcr;
int len_inc [ n ], len_dcr [ n ];
int longLen = 0;
for ( int i = 0;
i < n;
i ++ ) {
int len = 0;
if ( inc . find ( arr [ i ] - 1 ) != inc . end ( ) ) len = inc [ arr [ i ] - 1 ];
inc [ arr [ i ] ] = len_inc [ i ] = len + 1;
}
for ( int i = n - 1;
i >= 0;
i -- ) {
int len = 0;
if ( dcr . find ( arr [ i ] - 1 ) != dcr . end ( ) ) len = dcr [ arr [ i ] - 1 ];
dcr [ arr [ i ] ] = len_dcr [ i ] = len + 1;
}
for ( int i = 0;
i < n;
i ++ ) if ( longLen < ( len_inc [ i ] + len_dcr [ i ] - 1 ) ) longLen = len_inc [ i ] + len_dcr [ i ] - 1;
return longLen;
}
| [] | null | [] | SORT_ARRAY_CONTAIN_1_N_VALUES | python | [] | def f_gold ( arr , n ) :
for i in range ( n ) :
arr [ i ] = i + 1
| code_translation | [
[
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 53, 59, 64, 69, 69, 70, 71, 72, 84, 93, 96], 19",
"None"
],
[
"[1, 2, 3, 4, 5, 6, 7, 8, -90, 40, -62], 8",
"None"
],
[
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( int A [ ], int arr_size, int sum ) {
int l, r;
for ( int i = 0;
i < arr_size - 2;
i ++ ) {
for ( int j = i + 1;
j < arr_size - 1;
j ++ ) {
for ( int k = j + 1;
k < arr_size;
k ++ ) {
if ( A [ i ] + A [ j ] + A [ k ] == sum ) {
cout << "Triplet is " << A [ i ] << ", " << A [ j ] << ", " << A [ k ];
return true;
}
}
}
}
return false;
}
| [] | null | [] | PROGRAM_CHECK_INPUT_INTEGER_STRING | python | [] | def f_gold ( s ) :
for i in range ( len ( s ) ) :
if s [ i ].isdigit ( ) != True :
return False
return True
| code_translation | [
[
"'MgTOyHo NT'",
"False"
],
[
"'033675175'",
"True"
],
[
"'011001'",
"True"
],
[
"'XLlccG'",
"False"
],
[
"'8223900094410'",
"True"
],
[
"'000'",
"True"
],
[
"'aupp'",
"False"
],
[
"'90202721499'",
"True"
],
[
"'110... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( int n ) {
if ( n <= 1 ) return false;
for ( int i = 2;
i < n;
i ++ ) if ( n % i == 0 ) return false;
return true;
}
| [
"import sys"
] | null | [] | MINIMUM_XOR_VALUE_PAIR_1 | python | [] | import sys
def f_gold ( arr , n ) :
arr.sort ( )
minXor = int ( sys.float_info.max )
val = 0
for i in range ( 0 , n - 1 ) :
val = arr [ i ] ^ arr [ i + 1 ] ;
minXor = min ( minXor , val ) ;
return minXor
| code_translation | [
[
"[8, 11, 12, 27, 32, 32, 36, 56, 57, 66, 68, 70, 74, 78, 82, 83, 96], 10",
"0"
],
[
"[-60, -8, 4, 38, 40, 42, 48, 66], 7",
"-4"
],
[
"[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], 19",
"0"
],
[
"[2, 3, 4, 6, 7,... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
return ( n * ( 2 * n - 1 ) * ( 2 * n + 1 ) ) / 3;
}
| [] | null | [] | SUM_K_TH_GROUP_ODD_POSITIVE_NUMBERS | python | [] | def f_gold(k):
cur = int((k * (k - 1)) + 1)
sum = 0
while k:
sum += cur
cur += 2
k = k - 1
return sum
| code_translation | [
[
"91",
"753571"
],
[
"52",
"140608"
],
[
"78",
"474552"
],
[
"51",
"132651"
],
[
"65",
"274625"
],
[
"39",
"59319"
],
[
"42",
"74088"
],
[
"12",
"1728"
],
[
"56",
"175616"
],
[
"98",
"941192"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n ) {
if ( n < 3 ) return - 1;
sort ( arr, arr + n );
return max ( arr [ 0 ] * arr [ 1 ] * arr [ n - 1 ], arr [ n - 1 ] * arr [ n - 2 ] * arr [ n - 3 ] );
}
| [] | null | [] | FIND_SMALLEST_VALUE_REPRESENTED_SUM_SUBSET_GIVEN_ARRAY | python | [] | def f_gold ( arr , n ) :
res = 1
for i in range ( 0 , n ) :
if arr [ i ] <= res :
res = res + arr [ i ]
else :
break
return res
| code_translation | [
[
"[16, 23, 24, 41, 48, 58, 72, 75], 4",
"1"
],
[
"[-14, -82, 12, -14, -38, 12, 40, 12, -74, 42, -36, 64], 8",
"-95"
],
[
"[0, 0, 1, 1, 1, 1], 5",
"4"
],
[
"[17, 89, 44], 2",
"1"
],
[
"[-94, -92, -84, -82, -72, -58, -56, -40, -34, -34, -24, -22, -8, -8, 12, 14, 16... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( string & str ) {
vector < bool > mark ( 26, false );
int index;
for ( int i = 0;
i < str . length ( );
i ++ ) {
if ( 'A' <= str [ i ] && str [ i ] <= 'Z' ) index = str [ i ] - 'A';
else if ( 'a' <= str [ i ] && str [ i ] <= 'z' ) index = str [ i ] - 'a';
mark [ index ] = true;
}
for ( int i = 0;
i <= 25;
i ++ ) if ( mark [ i ] == false ) return ( false );
return ( true );
}
| [] | null | [] | EFFICIENT_WAY_CHECK_WHETHER_N_TH_FIBONACCI_NUMBER_MULTIPLE_10 | python | [] | def f_gold ( n ) :
return ( n % 15 == 0 )
| code_translation | [
[
"30",
"True"
],
[
"-30",
"True"
],
[
"60",
"True"
],
[
"90",
"True"
],
[
"99",
"False"
],
[
"32",
"False"
],
[
"21",
"False"
],
[
"65",
"False"
],
[
"21",
"False"
],
[
"99",
"False"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int N ) {
return ceil ( log2 ( N + 1 ) ) - 1;
}
| [] | null | [] | DYNAMIC_PROGRAMMING_SET_14_MAXIMUM_SUM_INCREASING_SUBSEQUENCE | python | [] | def f_gold ( arr , n ) :
max = 0
msis = [ 0 for x in range ( n ) ]
for i in range ( n ) :
msis [ i ] = arr [ i ]
for i in range ( 1 , n ) :
for j in range ( i ) :
if ( arr [ i ] > arr [ j ] and msis [ i ] < msis [ j ] + arr [ i ] ) :
msis [ i ] = msis [ j ] + arr [ i ]
for i in range ( n ) :
if max < msis [ i ] :
max = msis [ i ]
return max
| code_translation | [
[
"[4, 5, 7, 12, 23, 31, 31, 45, 47, 60, 67, 70, 84, 85, 91, 96], 11",
"301"
],
[
"[-88, -38, -50, -14, 36, -32, 0, -8, -12, -62, -46, 66, -46, -26, 6, -44, 14, -74, -84, 52, -28], 18",
"102"
],
[
"[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,... | |
transcoder-geeksforgeeks | cpp | f_gold | null | [] | null | [] | SUM_NODES_K_TH_LEVEL_TREE_REPRESENTED_STRING | python | [] | def f_gold ( tree , k ) :
level = - 1
sum = 0
n = len ( tree )
for i in range ( n ) :
if ( tree [ i ] == '(' ) :
level += 1
elif ( tree [ i ] == ')' ) :
level -= 1
else :
if ( level == k ) :
sum += ( ord ( tree [ i ] ) - ord ( '0' ) )
return sum
| code_translation | [
[
"'(0(5(6()())(4()(9()())))(7(1()())(3()())))', 2",
"14"
],
[
"'(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))', 3",
"9"
],
[
"'(0(5(6()())(4()(9()())))(7(1()())(3()())))', 1",
"12"
],
[
"'(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))', 2",
"16"
],
[
"'(8(... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( int arr [ ], int n ) {
int remainder = 0;
for ( int i = 0;
i < n;
i ++ ) remainder = ( remainder + arr [ i ] ) % 3;
return ( remainder == 0 );
}
| [] | null | [] | PROGRAM_OCTAL_DECIMAL_CONVERSION | python | [] | def f_gold ( n ) :
num = n ;
dec_value = 0 ;
base = 1 ;
temp = num ;
while ( temp ) :
last_digit = temp % 10 ;
temp = int ( temp / 10 ) ;
dec_value += last_digit * base ;
base = base * 8 ;
return dec_value ;
| code_translation | [
[
"37",
"31"
],
[
"25",
"21"
],
[
"63",
"51"
],
[
"66",
"54"
],
[
"32",
"26"
],
[
"5",
"5"
],
[
"41",
"33"
],
[
"82",
"66"
],
[
"54",
"44"
],
[
"5",
"5"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( string a, string b ) {
int m = a . length ( );
int n = b . length ( );
int lookup [ m + 1 ] [ n + 1 ] = {
{
0 }
};
for ( int i = 0;
i <= n;
++ i ) lookup [ 0 ] [ i ] = 0;
for ( int i = 0;
i <= m;
++ i ) lookup [ i ] [ 0 ] = 1;
for ( int i = 1;
i <= m;
i ++ ) {
for ( int j = 1;
j <= n;
j ++ ) {
if ( a [ i - 1 ] == b [ j - 1 ] ) lookup [ i ] [ j ] = lookup [ i - 1 ] [ j - 1 ] + lookup [ i - 1 ] [ j ];
else lookup [ i ] [ j ] = lookup [ i - 1 ] [ j ];
}
}
return lookup [ m ] [ n ];
}
| [] | null | [] | REARRANGE_ARRAY_MAXIMUM_MINIMUM_FORM_SET_2_O1_EXTRA_SPACE_1 | python | [] | def f_gold ( arr , n ) :
max_ele = arr [ n - 1 ]
min_ele = arr [ 0 ]
for i in range ( n ) :
if i % 2 == 0 :
arr [ i ] = max_ele
max_ele -= 1
else :
arr [ i ] = min_ele
min_ele += 1
| code_translation | [
[
"[75, 3, 74, 4, 73, 5, 72, 6, 71, 7, 70, 8, 69, 9, 68, 10, 67, 11, 66, 12, 65, 13, 64, 14, 63, 15, 62, 16, 61, 17, 60, 18, 59, 19, 58, 20, 57, 21, 56, 22, 75, 80, 82, 86, 92, 95, 96, 99], 40",
"None"
],
[
"[72, 45, 71, 46, 70, 47, 69, 48, 68, 49, 67, 50, 66, 51, 65, 52, 64, 53, 63, 54, 62, 55, 61,... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( string num ) {
int n = num . length ( );
if ( n == 0 && num [ 0 ] == '0' ) return true;
if ( n % 3 == 1 ) num = "00" + num;
if ( n % 3 == 2 ) num = "0" + num;
int gSum = 0;
for ( int i = 0;
i < n;
i ++ ) {
int group = 0;
group += ( num [ i ++ ] - '0' ) * 100;
group += ( num [ i ++ ] - '0' ) * 10;
group += num [ i ] - '0';
gSum += group;
}
if ( gSum > 1000 ) {
num = to_string ( gSum );
n = num . length ( );
gSum = f_gold ( num );
}
return ( gSum == 999 );
}
| [] | null | [] | CHECK_IF_STRING_REMAINS_PALINDROME_AFTER_REMOVING_GIVEN_NUMBER_OF_CHARACTERS | python | [] | def f_gold ( str , n ) :
l = len ( str )
if ( l >= n ) :
return True
return False
| code_translation | [
[
"'ZCoQhuM', 2",
"True"
],
[
"'7437725', 53",
"False"
],
[
"'11', 30",
"False"
],
[
"'buGlvR', 1",
"True"
],
[
"'9', 92",
"False"
],
[
"'101101010110', 3",
"True"
],
[
"'YguiM', 18",
"False"
],
[
"'8198', 90",
"False"
],
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n, int k ) {
unordered_map < int, int > h;
for ( int i = 0;
i < n;
i ++ ) h [ arr [ i ] ] ++;
if ( h . size ( ) < k ) return - 1;
int dist_count = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( h [ arr [ i ] ] == 1 ) dist_count ++;
if ( dist_count == k ) return arr [ i ];
}
return - 1;
}
| [] | null | [] | NUMBER_INDEXES_EQUAL_ELEMENTS_GIVEN_RANGE | python | [] | def f_gold ( a , n , l , r ) :
count = 0
for i in range ( l , r ) :
if ( a [ i ] == a [ i + 1 ] ) :
count += 1
return count
| code_translation | [
[
"[4, 13, 13, 16, 16, 19, 39, 41, 48, 52, 57, 62, 65, 67, 76, 84, 88, 91, 95, 96, 97, 98], 18, 12, 17",
"0"
],
[
"[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], ... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( string str ) {
int n = str . length ( );
if ( ( str [ n - 1 ] - '0' ) % 2 != 0 ) return false;
int digitSum = 0;
for ( int i = 0;
i < n;
i ++ ) digitSum += ( str [ i ] - '0' );
return ( digitSum % 3 == 0 );
}
| [] | null | [] | COUNT_SET_BITS_IN_AN_INTEGER_2 | python | [] | def f_gold ( n ) :
count = 0
while ( n ) :
n &= ( n - 1 )
count += 1
return count
| code_translation | [
[
"32",
"1"
],
[
"94",
"5"
],
[
"33",
"2"
],
[
"99",
"4"
],
[
"17",
"2"
],
[
"64",
"1"
],
[
"80",
"2"
],
[
"42",
"3"
],
[
"12",
"2"
],
[
"86",
"4"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( int arr [ ], int n ) {
int temp [ n ];
for ( int i = 0;
i < n;
i ++ ) temp [ i ] = arr [ i ];
sort ( temp, temp + n );
int front;
for ( front = 0;
front < n;
front ++ ) if ( temp [ front ] != arr [ front ] ) break;
int back;
for ( back = n - 1;
back >= 0;
back -- ) if ( temp [ back ] != arr [ back ] ) break;
if ( front >= back ) return true;
do {
front ++;
if ( arr [ front - 1 ] < arr [ front ] ) return false;
}
while ( front != back );
return true;
}
| [] | null | [] | TRIANGULAR_NUMBERS | python | [] | def f_gold ( num ) :
if ( num < 0 ) :
return False
sum , n = 0 , 1
while ( sum <= num ) :
sum = sum + n
if ( sum == num ) :
return True
n += 1
return False
| code_translation | [
[
"97",
"False"
],
[
"97",
"False"
],
[
"32",
"False"
],
[
"40",
"False"
],
[
"18",
"False"
],
[
"14",
"False"
],
[
"90",
"False"
],
[
"39",
"False"
],
[
"1",
"True"
],
[
"57",
"False"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( string num ) {
int series [ ] = {
1, 3, 2, - 1, - 3, - 2 };
int series_index = 0;
int result = 0;
for ( int i = num . size ( ) - 1;
i >= 0;
i -- ) {
int digit = num [ i ] - '0';
result += digit * series [ series_index ];
series_index = ( series_index + 1 ) % 6;
result %= 7;
}
if ( result < 0 ) result = ( result + 7 ) % 7;
return result;
}
| [] | null | [] | ROUND_THE_GIVEN_NUMBER_TO_NEAREST_MULTIPLE_OF_10 | python | [] | def f_gold ( n ) :
a = ( n // 10 ) * 10
b = a + 10
return ( b if n - a > b - n else a )
| code_translation | [
[
"31",
"30"
],
[
"78",
"80"
],
[
"19",
"20"
],
[
"36",
"40"
],
[
"77",
"80"
],
[
"94",
"90"
],
[
"86",
"90"
],
[
"16",
"20"
],
[
"95",
"90"
],
[
"2",
"0"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
int dp [ n + 1 ];
for ( int i = 0;
i <= n;
i ++ ) {
if ( i <= 2 ) dp [ i ] = i;
else dp [ i ] = dp [ i - 1 ] + ( i - 1 ) * dp [ i - 2 ];
}
return dp [ n ];
}
| [] | null | [] | SUM_MATRIX_ELEMENT_ABSOLUTE_DIFFERENCE_ROW_COLUMN_NUMBERS_1 | python | [] | def f_gold ( n ) :
sum = 0
for i in range ( n ) :
sum += i * ( n - i )
return 2 * sum
| code_translation | [
[
"63",
"83328"
],
[
"72",
"124392"
],
[
"28",
"7308"
],
[
"35",
"14280"
],
[
"6",
"70"
],
[
"70",
"114310"
],
[
"20",
"2660"
],
[
"8",
"168"
],
[
"8",
"168"
],
[
"35",
"14280"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( string str ) {
vector < char > list;
for ( int i = 0;
i < str . length ( );
i ++ ) {
auto pos = find ( list . begin ( ), list . end ( ), str [ i ] );
if ( pos != list . end ( ) ) {
auto posi = find ( list . begin ( ), list . end ( ), str [ i ] );
list . erase ( posi );
}
else list . push_back ( str [ i ] );
}
if ( str . length ( ) % 2 == 0 && list . empty ( ) || ( str . length ( ) % 2 == 1 && list . size ( ) == 1 ) ) return true;
else return false;
}
| [] | null | [] | NUMBER_JUMP_REQUIRED_GIVEN_LENGTH_REACH_POINT_FORM_D_0_ORIGIN_2D_PLANE | python | [] | def f_gold ( a , b , d ) :
temp = a
a = min ( a , b )
b = max ( temp , b )
if ( d >= b ) :
return ( d + b - 1 ) / b
if ( d == 0 ) :
return 0
if ( d == a ) :
return 1
return 2
| code_translation | [
[
"35, 8, 77",
"3.1714285714285713"
],
[
"85, 55, 33",
"2"
],
[
"22, 23, 64",
"3.739130434782609"
],
[
"8, 43, 29",
"2"
],
[
"12, 64, 11",
"2"
],
[
"58, 25, 26",
"2"
],
[
"65, 4, 28",
"2"
],
[
"10, 95, 55",
"2"
],
[
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
bool f_gold ( unsigned int n ) {
int count = 0;
if ( n && ! ( n & ( n - 1 ) ) ) {
while ( n > 1 ) {
n >>= 1;
count += 1;
}
return ( count % 2 == 0 ) ? 1 : 0;
}
return 0;
}
| [] | null | [] | CHECK_IF_A_NUMBER_IS_POWER_OF_ANOTHER_NUMBER | python | [] | def f_gold ( x , y ) :
if ( x == 1 ) :
return ( y == 1 )
pow = 1
while ( pow < y ) :
pow = pow * x
return ( pow == y )
| code_translation | [
[
"57, 1",
"True"
],
[
"3, 9",
"True"
],
[
"10, 101",
"False"
],
[
"10, 10000",
"True"
],
[
"6, 46656",
"True"
],
[
"2, 2048",
"True"
],
[
"1, 40",
"False"
],
[
"20, 79",
"False"
],
[
"96, 98",
"False"
],
[
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int N ) {
if ( N == 1 ) return 4;
int countB = 1, countS = 1, prev_countB, prev_countS;
for ( int i = 2;
i <= N;
i ++ ) {
prev_countB = countB;
prev_countS = countS;
countS = prev_countB + prev_countS;
countB = prev_countS;
}
int result = countS + countB;
return ( result * result );
}
| [] | null | [] | MINIMUM_FLIP_REQUIRED_MAKE_BINARY_MATRIX_SYMMETRIC_1 | python | [] | def f_gold ( mat , n ) :
flip = 0
for i in range ( n ) :
for j in range ( i ) :
if mat [ i ] [ j ] != mat [ j ] [ i ] :
flip += 1
return flip
| code_translation | [
[
"[[16, 16, 47, 49, 50, 64, 70, 83, 88], [11, 12, 24, 32, 36, 39, 48, 58, 62], [29, 31, 35, 49, 71, 78, 82, 92, 96], [6, 21, 46, 53, 83, 88, 94, 94, 97], [29, 36, 41, 52, 83, 89, 89, 90, 90], [3, 11, 35, 45, 47, 79, 81, 85, 96], [31, 43, 62, 62, 62, 65, 66, 68, 81], [8, 9, 10, 26, 36, 43, 58, 70, 95], [2, 8, 2... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
long long int f_gold ( int n ) {
long long int multiTerms = n * ( n + 1 ) / 2;
long long int sum = multiTerms;
for ( int i = 2;
i <= n;
i ++ ) {
multiTerms = multiTerms - ( i - 1 );
sum = sum + multiTerms * i;
}
return sum;
}
| [] | null | [] | SUM_SERIES_12_32_52_2N_12 | python | [] | def f_gold ( n ) :
sum = 0
for i in range ( 1 , n + 1 ) :
sum = sum + ( 2 * i - 1 ) * ( 2 * i - 1 )
return sum
| code_translation | [
[
"14",
"3654"
],
[
"61",
"302621"
],
[
"37",
"67525"
],
[
"86",
"848046"
],
[
"47",
"138415"
],
[
"98",
"1254890"
],
[
"70",
"457310"
],
[
"24",
"18424"
],
[
"76",
"585276"
],
[
"24",
"18424"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int a [ ], int b [ ], int n, int m ) {
unordered_map < int, int > countA, countB;
for ( int i = 0;
i < n;
i ++ ) countA [ a [ i ] ] ++;
for ( int i = 0;
i < m;
i ++ ) countB [ b [ i ] ] ++;
int res = 0;
for ( auto x : countA ) if ( countB . find ( x . first ) != countB . end ( ) ) res += min ( x . second, countB [ x . first ] );
return res;
}
| [] | null | [] | SWAP_TWO_NUMBERS_WITHOUT_USING_TEMPORARY_VARIABLE | python | [] | def f_gold ( xp , yp ) :
xp [ 0 ] = xp [ 0 ] ^ yp [ 0 ]
yp [ 0 ] = xp [ 0 ] ^ yp [ 0 ]
xp [ 0 ] = xp [ 0 ] ^ yp [ 0 ]
| code_translation | [
[
"[5, 7, 12, 13, 15, 17, 24, 27, 28, 31, 36, 44, 55, 55, 56, 58, 60, 62, 64, 73, 75, 77, 89, 90, 93, 93, 95, 97, 98], [2, 8, 12, 13, 14, 20, 23, 25, 27, 28, 31, 33, 33, 37, 38, 39, 42, 42, 43, 47, 52, 54, 62, 67, 71, 72, 73, 76, 77, 79, 81, 81, 85, 86, 89, 91, 91, 96, 96, 99]",
"None"
],
[
"[-14, 5... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
int nthElement = 19 + ( n - 1 ) * 9;
int outliersCount = ( int ) log10 ( nthElement ) - 1;
nthElement += 9 * outliersCount;
return nthElement;
}
| [] | null | [] | CHECK_IF_ALL_THE_ELEMENTS_CAN_BE_MADE_OF_SAME_PARITY_BY_INVERTING_ADJACENT_ELEMENTS | python | [] | def f_gold ( a , n ) :
count_odd = 0 ; count_even = 0 ;
for i in range ( n ) :
if ( a [ i ] & 1 ) :
count_odd += 1 ;
else :
count_even += 1 ;
if ( count_odd % 2 and count_even % 2 ) :
return False ;
else :
return True ;
| code_translation | [
[
"[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], 30",
"True"
],
[
"[-90, -20, -60, -64, -24, 84, -2, -32, 28, -54, 44, -96, 52, 88, 20, -56, -2], 12",
"True"
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
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;
}
| [] | null | [] | CHECK_WHETHER_TRIANGLE_VALID_NOT_SIDES_GIVEN | python | [] | def f_gold ( a , b , c ) :
if ( a + b <= c ) or ( a + c <= b ) or ( b + c <= a ) :
return False
else :
return True
| code_translation | [
[
"29, 19, 52",
"False"
],
[
"83, 34, 49",
"False"
],
[
"48, 14, 65",
"False"
],
[
"59, 12, 94",
"False"
],
[
"56, 39, 22",
"True"
],
[
"68, 85, 9",
"False"
],
[
"63, 36, 41",
"True"
],
[
"95, 34, 37",
"False"
],
[
"... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int a [ ], int n ) {
int count = 0;
for ( int i = 0;
i < n;
i ++ ) {
for ( int j = i + 1;
j < n;
j ++ ) if ( ( a [ i ] & a [ j ] ) == 0 ) count += 2;
}
return count;
}
| [] | null | [] | TOTAL_NUMBER_OF_NON_DECREASING_NUMBERS_WITH_N_DIGITS | python | [] | def f_gold ( n ) :
dp = [ [ 0 for i in range ( n + 1 ) ] for i in range ( 10 ) ]
for i in range ( 10 ) :
dp [ i ] [ 1 ] = 1
for digit in range ( 10 ) :
for len in range ( 2 , n + 1 ) :
for x in range ( digit + 1 ) :
dp [ digit ] [ len ] += dp [ x ] [ len - 1 ]
count = 0
for i in range ( 10 ) :
count += dp [ i ] [ n ]
return count
| code_translation | [
[
"21",
"14307150"
],
[
"40",
"2054455634"
],
[
"83",
"868754947060"
],
[
"93",
"2290415157800"
],
[
"43",
"3679075400"
],
[
"98",
"3585446225075"
],
[
"35",
"708930508"
],
[
"86",
"1174992339235"
],
[
"76",
"411... | |
transcoder-geeksforgeeks | cpp | f_gold | null | [] | null | [] | MAXIMUM_PROFIT_BY_BUYING_AND_SELLING_A_SHARE_AT_MOST_TWICE | python | [] | def f_gold(price, n):
profit = [0] * n
max_price = price[n - 1]
for i in range(n - 2, 0, - 1):
if price[i] > max_price:
max_price = price[i]
profit[i] = max(profit[i + 1], max_price - price[i])
min_price = price[0]
for i in range(1, n):
if price[i] < min_price:
min_price = price[i]
profit[i] = max(profit[i - 1], profit[i] + (price[i] - min_price))
result = profit[n - 1]
return result
| code_translation | [
[
"[9, 10, 10, 12, 17, 18, 23, 32, 41, 44, 47, 50, 59, 69, 69, 75, 82, 84, 87, 89, 97, 99], 20",
"80"
],
[
"[6, 6, 60, 40, 32, -70, -92, 88, 10, -8, -54, 4, 16, 8, -44, 80, -70, 36, 36, -74, -94, 18, -64, -66, -46, 0, -54, -84, 16, -88, -34, -24, 92, 84, 62], 34",
"366"
],
[
"[0, 0, 0, 0... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( string s, int K ) {
int n = s . length ( );
int C, c1 = 0, c2 = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( s [ i ] == 'a' ) c1 ++;
if ( s [ i ] == 'b' ) {
c2 ++;
C += c1;
}
}
return C * K + ( K * ( K - 1 ) / 2 ) * c1 * c2;
}
| [] | null | [] | MAXIMUM_POSSIBLE_SUM_WINDOW_ARRAY_ELEMENTS_WINDOW_ARRAY_UNIQUE | python | [] | def f_gold ( A , B , n ) :
mp = set ( )
result = 0
curr_sum = curr_begin = 0
for i in range ( 0 , n ) :
while A [ i ] in mp :
mp.remove ( A [ curr_begin ] )
curr_sum -= B [ curr_begin ]
curr_begin += 1
mp.add ( A [ i ] )
curr_sum += B [ i ]
result = max ( result , curr_sum )
return result
| code_translation | [
[
"[4, 8, 10, 10, 16, 23, 33, 36, 43, 47, 50, 55, 56, 72, 84, 85, 86, 86, 88, 90, 92, 99], [8, 26, 30, 35, 45, 47, 55, 56, 59, 61, 64, 66, 67, 69, 73, 77, 78, 81, 82, 85, 86, 99], 20",
"852"
],
[
"[48, -22, 84, 76, 50, -14, -82, 28, 86, -50, -40, 10, 48, 20, -48, -84, -64, -48, -32, -84, -32, 10, 42... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
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;
}
| [] | null | [] | MAXIMUM_WEIGHT_PATH_ENDING_ELEMENT_LAST_ROW_MATRIX | python | [] | def f_gold ( mat , N ) :
dp = [ [ 0 for i in range ( N ) ] for j in range ( N ) ]
dp [ 0 ] [ 0 ] = mat [ 0 ] [ 0 ]
for i in range ( 1 , N ) :
dp [ i ] [ 0 ] = mat [ i ] [ 0 ] + dp [ i - 1 ] [ 0 ]
for i in range ( 1 , N ) :
for j in range ( 1 , min ( i + 1 , N ) ) :
dp [ i ] [ j ] = mat [ i ] [ j ] + \
max ( dp [ i - 1 ] [ j - 1 ] , dp [ i - 1 ] [ j ] )
result = 0
for i in range ( N ) :
if ( result < dp [ N - 1 ] [ i ] ) :
result = dp [ N - 1 ] [ i ]
return result
| code_translation | [
[
"[[1, 3, 17, 22, 24, 29, 36, 38, 41, 42, 44, 44, 47, 48, 49, 51, 52, 54, 64, 69, 70, 77, 79, 82, 86, 86, 87, 88, 97, 99], [5, 6, 17, 21, 27, 27, 37, 39, 47, 48, 48, 52, 53, 54, 57, 59, 61, 63, 68, 72, 75, 77, 78, 81, 88, 89, 91, 95, 95, 97], [2, 8, 10, 16, 17, 18, 18, 18, 20, 27, 33, 35, 36, 42, 48, 51, 56, 6... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int N ) {
int dp [ N ];
dp [ 0 ] = 1;
dp [ 1 ] = 2;
int i = 2;
do {
dp [ i ] = dp [ i - 1 ] + dp [ i - 2 ];
}
while ( dp [ i ++ ] <= N );
return ( i - 2 );
}
| [] | null | [] | HOW_TO_CHECK_IF_A_GIVEN_ARRAY_REPRESENTS_A_BINARY_HEAP | python | [] | def f_gold ( arr , i , n ) :
if i > int ( ( n - 2 ) / 2 ) :
return True
if ( arr [ i ] >= arr [ 2 * i + 1 ] and arr [ i ] >= arr [ 2 * i + 2 ] and f_gold ( arr , 2 * i + 1 , n ) and f_gold ( arr , 2 * i + 2 , n ) ) :
return True
return False
| code_translation | [
[
"[1, 2, 3, 5, 24, 24, 25, 25, 36, 37, 37, 39, 42, 44, 46, 50, 51, 54, 56, 60, 62, 70, 71, 73, 75, 80, 80, 85, 86, 89, 91, 95, 99], 0, 18",
"False"
],
[
"[-44, -58, 88, -42, 42, -14, -44, 42, 64, 94, -46, -70, 34, -10, -46, -52, -6, -78, 64, 56, 74, 98, -34, -4, -92, 6, -52, -20, 78, -72, -40], 0, ... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n, int x ) {
int i = 0;
while ( i <= n - 1 ) {
if ( arr [ i ] == x ) return i;
i += abs ( arr [ i ] - x );
}
return - 1;
}
| [] | null | [] | COMPUTE_NCR_P_SET_1_INTRODUCTION_AND_DYNAMIC_PROGRAMMING_SOLUTION | python | [] | def f_gold ( n , r , p ) :
C = [ 0 for i in range ( r + 1 ) ]
C [ 0 ] = 1
for i in range ( 1 , n + 1 ) :
for j in range ( min ( i , r ) , 0 , - 1 ) :
C [ j ] = ( C [ j ] + C [ j - 1 ] ) % p
return C [ r ]
| code_translation | [
[
"82, 5, 94",
"50"
],
[
"45, 24, 95",
"80"
],
[
"44, 68, 61",
"0"
],
[
"88, 24, 43",
"0"
],
[
"90, 75, 57",
"0"
],
[
"98, 55, 43",
"2"
],
[
"80, 54, 88",
"0"
],
[
"60, 75, 65",
"0"
],
[
"52, 73, 86",
"0"
],
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n ) {
if ( n == 0 ) return 0;
else return 1 + f_gold ( n & ( n - 1 ) );
}
| [] | null | [] | SQUARE_ROOT_OF_AN_INTEGER | python | [] | def f_gold ( x ) :
if ( x == 0 or x == 1 ) :
return x
i = 1 ; result = 1
while ( result <= x ) :
i += 1
result = i * i
return i - 1
| code_translation | [
[
"89",
"9"
],
[
"11",
"3"
],
[
"14",
"3"
],
[
"92",
"9"
],
[
"76",
"8"
],
[
"63",
"7"
],
[
"51",
"7"
],
[
"16",
"4"
],
[
"83",
"9"
],
[
"66",
"8"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int n, int p ) {
if ( n >= p ) return 0;
int result = 1;
for ( int i = 1;
i <= n;
i ++ ) result = ( result * i ) % p;
return result;
}
| [] | null | [] | MAXIMIZE_VOLUME_CUBOID_GIVEN_SUM_SIDES | python | [] | def f_gold(s):
maxvalue = 0
i = 1
for i in range(s - 1):
j = 1
for j in range(s):
k = s - i - j
maxvalue = max(maxvalue, i * j * k)
return maxvalue
| code_translation | [
[
"67",
"11132"
],
[
"48",
"4096"
],
[
"59",
"7600"
],
[
"22",
"392"
],
[
"14",
"100"
],
[
"66",
"10648"
],
[
"1",
"0"
],
[
"75",
"15625"
],
[
"58",
"7220"
],
[
"78",
"17576"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int a [ ], int b [ ], int n, int k ) {
int diff = 0, res = 0;
int temp;
for ( int i = 0;
i < n;
i ++ ) {
int pro = a [ i ] * b [ i ];
res = res + pro;
if ( pro < 0 && b [ i ] < 0 ) temp = ( a [ i ] + 2 * k ) * b [ i ];
else if ( pro < 0 && a [ i ] < 0 ) temp = ( a [ i ] - 2 * k ) * b [ i ];
else if ( pro > 0 && a [ i ] < 0 ) temp = ( a [ i ] + 2 * k ) * b [ i ];
else if ( pro > 0 && a [ i ] > 0 ) temp = ( a [ i ] - 2 * k ) * b [ i ];
int d = abs ( pro - temp );
if ( d > diff ) diff = d;
}
return res - diff;
}
| [
"import math"
] | null | [] | PROGRAM_PRINT_SUM_GIVEN_NTH_TERM_1 | python | [] | import math
def f_gold ( n ) :
return math.pow ( n , 2 )
| code_translation | [
[
"42",
"1764.0"
],
[
"40",
"1600.0"
],
[
"67",
"4489.0"
],
[
"73",
"5329.0"
],
[
"18",
"324.0"
],
[
"16",
"256.0"
],
[
"74",
"5476.0"
],
[
"33",
"1089.0"
],
[
"92",
"8464.0"
],
[
"22",
"484.0"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int low, int high ) {
int fact = 1, x = 1;
while ( fact < low ) {
fact = fact * x;
x ++;
}
int res = 0;
while ( fact <= high ) {
res ++;
fact = fact * x;
x ++;
}
return res;
}
| [] | null | [] | REARRANGE_POSITIVE_AND_NEGATIVE_NUMBERS_PUBLISH | python | [] | def f_gold ( arr , n ) :
i = - 1
for j in range ( n ) :
if ( arr [ j ] < 0 ) :
i += 1
arr [ i ] , arr [ j ] = arr [ j ] , arr [ i ]
pos , neg = i + 1 , 0
while ( pos < n and neg < pos and arr [ neg ] < 0 ) :
arr [ neg ] , arr [ pos ] = arr [ pos ] , arr [ neg ]
pos += 1
neg += 2
| code_translation | [
[
"[5, 5, 6, 7, 8, 10, 13, 15, 15, 27, 27, 29, 29, 29, 29, 31, 33, 33, 36, 38, 38, 39, 42, 47, 47, 51, 51, 51, 52, 53, 55, 56, 57, 64, 66, 66, 67, 68, 70, 72, 74, 78, 86, 88, 94, 97, 97], 26",
"None"
],
[
"[73, -64, 15, -5, 64, -74, 30, 55, -57, -73, -31, 48], 8",
"None"
],
[
"[0, 0, 0, ... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n ) {
int ones = 0, twos = 0;
int common_bit_mask;
for ( int i = 0;
i < n;
i ++ ) {
twos = twos | ( ones & arr [ i ] );
ones = ones ^ arr [ i ];
common_bit_mask = ~ ( ones & twos );
ones &= common_bit_mask;
twos &= common_bit_mask;
}
return ones;
}
| [] | null | [] | GIVEN_A_SORTED_AND_ROTATED_ARRAY_FIND_IF_THERE_IS_A_PAIR_WITH_A_GIVEN_SUM_1 | python | [] | def f_gold ( arr , n , x ) :
for i in range ( n ) :
if arr [ i ] > arr [ i + 1 ] :
break
l = ( i + 1 ) % n
r = i
cnt = 0
while ( l != r ) :
if arr [ l ] + arr [ r ] == x :
cnt += 1
if l == ( r - 1 + n ) % n :
return cnt
l = ( l + 1 ) % n
r = ( r - 1 + n ) % n
elif arr [ l ] + arr [ r ] < x :
l = ( l + 1 ) % n
else :
r = ( n + r - 1 ) % n
return cnt
| code_translation | [
[
"[24, 54], 1, 1",
"0"
],
[
"[68, -30, -18, -6, 70, -40, 86, 98, -24, -48], 8, 8",
"0"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 33, 28",
"0"
],
[
"[84, 44, 40, 45, 2, 41, 52, 17, ... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
long f_gold ( int n, int k ) {
long total = k;
int mod = 1000000007;
int same = 0, diff = k;
for ( int i = 2;
i <= n;
i ++ ) {
same = diff;
diff = total * ( k - 1 );
diff = diff % mod;
total = ( same + diff ) % mod;
}
return total;
}
| [] | null | [] | COUNT_TOTAL_SET_BITS_IN_ALL_NUMBERS_FROM_1_TO_N | python | [] | def f_gold ( n ) :
i = 0
ans = 0
while ( ( 1 << i ) <= n ) :
k = 0
change = 1 << i
for j in range ( 0 , n + 1 ) :
ans += k
if change == 1 :
k = not k
change = 1 << i
else :
change -= 1
i += 1
return ans
| code_translation | [
[
"90",
"279"
],
[
"56",
"159"
],
[
"43",
"112"
],
[
"31",
"80"
],
[
"77",
"231"
],
[
"35",
"88"
],
[
"43",
"112"
],
[
"66",
"197"
],
[
"15",
"32"
],
[
"95",
"304"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int m, int n ) {
int dp [ n ] = {
1 };
dp [ 0 ] = 1;
for ( int i = 0;
i < m;
i ++ ) {
for ( int j = 1;
j < n;
j ++ ) {
dp [ j ] += dp [ j - 1 ];
}
}
return dp [ n - 1 ];
}
| [] | null | [] | CHECK_EXIST_TWO_ELEMENTS_ARRAY_WHOSE_SUM_EQUAL_SUM_REST_ARRAY | python | [] | def f_gold ( arr , n ) :
s = set ( )
sum = 0
for i in range ( n ) :
sum += arr [ i ]
if sum % 2 != 0 :
return False
sum = sum / 2
for i in range ( n ) :
val = sum - arr [ i ]
if arr [ i ] not in s :
s.add ( arr [ i ] )
if val in s :
print ( "Pair elements are" , arr [ i ] , "and" , int ( val ) )
| code_translation | [
[
"[2, 11, 5, 1, 4, 7], 6",
"None"
],
[
"[2, 4, 2, 1, 11, 15], 6",
"False"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 13",
"None"
],
[
"[69, 6, 24, 30, 75, 37, 61, 76, 19, 18, 90, 9, 49, 24, 58, 97, 18, 85, 24, 93, 71, 98, 92, 59, 75, 75, 75,... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int low, int high ) {
if ( high >= low ) {
int mid = ( low + high ) / 2;
if ( mid == arr [ mid ] ) return mid;
if ( mid > arr [ mid ] ) return f_gold ( arr, ( mid + 1 ), high );
else return f_gold ( arr, low, ( mid - 1 ) );
}
return - 1;
}
| [] | null | [] | CHECK_POSSIBLE_TRANSFORM_ONE_STRING_ANOTHER | python | [] | def f_gold ( s1 , s2 ) :
n = len ( s1 )
m = len ( s2 )
dp = ( [ [ False for i in range ( m + 1 ) ] for i in range ( n + 1 ) ] )
dp [ 0 ] [ 0 ] = True
for i in range ( len ( s1 ) ) :
for j in range ( len ( s2 ) + 1 ) :
if ( dp [ i ] [ j ] ) :
if ( ( j < len ( s2 ) and ( s1 [ i ].upper ( ) == s2 [ j ] ) ) ) :
dp [ i + 1 ] [ j + 1 ] = True
if ( s1 [ i ].isupper ( ) == False ) :
dp [ i + 1 ] [ j ] = True
return ( dp [ n ] [ m ] )
| code_translation | [
[
"'daBcd', 'ABC'",
"True"
],
[
"'417514', '9'",
"False"
],
[
"'010000', '1111011010'",
"False"
],
[
"'ZcKYguiMrdyn', 'iz'",
"False"
],
[
"'argaju', 'RAJ'",
"True"
],
[
"'1110101101', '110101001'",
"False"
],
[
"'ySOCoSaygi', 'aRhxkYqh'",
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
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;
}
| [
"import math"
] | null | [] | FIND_SUM_EVEN_FACTORS_NUMBER | python | [] | import math
def f_gold ( n ) :
if ( n % 2 != 0 ) :
return 0
res = 1
for i in range ( 2 , ( int ) ( math.sqrt ( n ) ) + 1 ) :
count = 0
curr_sum = 1
curr_term = 1
while ( n % i == 0 ) :
count = count + 1
n = n // i
if ( i == 2 and count == 1 ) :
curr_sum = 0
curr_term = curr_term * i
curr_sum = curr_sum + curr_term
res = res * curr_sum
if ( n >= 2 ) :
res = res * ( 1 + n )
return res
| code_translation | [
[
"71",
"0"
],
[
"78",
"112"
],
[
"39",
"0"
],
[
"36",
"78"
],
[
"49",
"0"
],
[
"17",
"0"
],
[
"53",
"0"
],
[
"66",
"96"
],
[
"92",
"144"
],
[
"71",
"0"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
unsigned int f_gold ( unsigned int n ) {
if ( n == 0 || n == 1 ) return 1;
return n * f_gold ( n - 2 );
}
| [
"import math"
] | null | [] | CALCULATE_AREA_TETRAHEDRON | python | [] | import math
def f_gold ( side ) :
volume = ( side ** 3 / ( 6 * math.sqrt ( 2 ) ) )
return round ( volume , 2 )
| code_translation | [
[
"58",
"22994.17"
],
[
"56",
"20696.54"
],
[
"35",
"5052.87"
],
[
"99",
"114350.83"
],
[
"13",
"258.92"
],
[
"45",
"10739.18"
],
[
"40",
"7542.47"
],
[
"92",
"91769.26"
],
[
"7",
"40.42"
],
[
"13",
"... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
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 ];
}
| [] | null | [] | SQUARED_TRIANGULAR_NUMBER_SUM_CUBES | python | [] | def f_gold ( s ) :
_sum = 0
n = 1
while ( _sum < s ) :
_sum += n * n * n
n += 1
n -= 1
if _sum == s :
return n
return - 1
| code_translation | [
[
"15",
"-1"
],
[
"36",
"3"
],
[
"39",
"-1"
],
[
"43",
"-1"
],
[
"75",
"-1"
],
[
"49",
"-1"
],
[
"56",
"-1"
],
[
"14",
"-1"
],
[
"62",
"-1"
],
[
"97",
"-1"
]
] | |
transcoder-geeksforgeeks | cpp | f_gold | null | [] | null | [] | FREQUENT_ELEMENT_ARRAY | python | [] | def f_gold ( arr , n ) :
arr.sort ( )
max_count = 1 ; res = arr [ 0 ] ; curr_count = 1
for i in range ( 1 , n ) :
if ( arr [ i ] == arr [ i - 1 ] ) :
curr_count += 1
else :
if ( curr_count > max_count ) :
max_count = curr_count
res = arr [ i - 1 ]
curr_count = 1
if ( curr_count > max_count ) :
max_count = curr_count
res = arr [ n - 1 ]
return res
| code_translation | [
[
"[1, 1, 3, 11, 11, 11, 18, 20, 26, 26, 27, 30, 33, 39, 39, 42, 42, 48, 51, 51, 51, 51, 60, 66, 66, 68, 68, 69, 71, 72, 73, 76, 76, 77, 77, 77, 78, 90, 96], 25",
"51"
],
[
"[-74, -46, -38, -32, -22, -18, -14, -8, -4, 14, 30, 36, 42, 46, 48, 64, 66, 72, 80, 92, 94, 96, 96], 18",
"-74"
],
[
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n ) {
int f_gold [ n ];
f_gold [ 0 ] = 1;
for ( int i = 1;
i < n;
i ++ ) {
f_gold [ i ] = 1;
for ( int j = 0;
j < i;
j ++ ) if ( arr [ i ] > arr [ j ] && f_gold [ i ] < f_gold [ j ] + 1 ) f_gold [ i ] = f_gold [ j ] + 1;
}
return * max_element ( f_gold, f_gold + n );
}
| [] | null | [] | FIND_SUM_EVEN_INDEX_BINOMIAL_COEFFICIENTS_1 | python | [] | def f_gold ( n ) :
return ( 1 << ( n - 1 ) )
| code_translation | [
[
"56",
"36028797018963968"
],
[
"28",
"134217728"
],
[
"4",
"8"
],
[
"24",
"8388608"
],
[
"72",
"2361183241434822606848"
],
[
"30",
"536870912"
],
[
"48",
"140737488355328"
],
[
"32",
"2147483648"
],
[
"13",
"40... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( char symb [ ], char oper [ ], int n ) {
int F [ n ] [ n ], T [ n ] [ n ];
for ( int i = 0;
i < n;
i ++ ) {
F [ i ] [ i ] = ( symb [ i ] == 'F' ) ? 1 : 0;
T [ i ] [ i ] = ( symb [ i ] == 'T' ) ? 1 : 0;
}
for ( int gap = 1;
gap < n;
++ gap ) {
for ( int i = 0, j = gap;
j < n;
++ i, ++ j ) {
T [ i ] [ j ] = F [ i ] [ j ] = 0;
for ( int g = 0;
g < gap;
g ++ ) {
int k = i + g;
int tik = T [ i ] [ k ] + F [ i ] [ k ];
int tkj = T [ k + 1 ] [ j ] + F [ k + 1 ] [ j ];
if ( oper [ k ] == '&' ) {
T [ i ] [ j ] += T [ i ] [ k ] * T [ k + 1 ] [ j ];
F [ i ] [ j ] += ( tik * tkj - T [ i ] [ k ] * T [ k + 1 ] [ j ] );
}
if ( oper [ k ] == '|' ) {
F [ i ] [ j ] += F [ i ] [ k ] * F [ k + 1 ] [ j ];
T [ i ] [ j ] += ( tik * tkj - F [ i ] [ k ] * F [ k + 1 ] [ j ] );
}
if ( oper [ k ] == '^' ) {
T [ i ] [ j ] += F [ i ] [ k ] * T [ k + 1 ] [ j ] + T [ i ] [ k ] * F [ k + 1 ] [ j ];
F [ i ] [ j ] += T [ i ] [ k ] * T [ k + 1 ] [ j ] + F [ i ] [ k ] * F [ k + 1 ] [ j ];
}
}
}
}
return T [ 0 ] [ n - 1 ];
}
| [] | null | [] | PYTHON_PROGRAM_FIND_PERIMETER_CIRCUMFERENCE_SQUARE_RECTANGLE_1 | python | [] | def f_gold ( l , w ) :
return ( 2 * ( l + w ) )
| code_translation | [
[
"58, 39",
"194"
],
[
"37, 49",
"172"
],
[
"56, 52",
"216"
],
[
"22, 43",
"130"
],
[
"77, 12",
"178"
],
[
"34, 31",
"130"
],
[
"74, 54",
"256"
],
[
"37, 52",
"178"
],
[
"21, 37",
"116"
],
[
"75, 30",
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
float f_gold ( float a ) {
float area;
area = ( sqrt ( 5 * ( 5 + 2 * ( sqrt ( 5 ) ) ) ) * a * a ) / 4;
return area;
}
| [] | null | [] | LONGEST_REPEATING_AND_NON_OVERLAPPING_SUBSTRING | python | [] | def f_gold ( str ) :
n = len ( str )
LCSRe = [ [ 0 for x in range ( n + 1 ) ] for y in range ( n + 1 ) ]
res = ""
res_length = 0
index = 0
for i in range ( 1 , n + 1 ) :
for j in range ( i + 1 , n + 1 ) :
if ( str [ i - 1 ] == str [ j - 1 ] and LCSRe [ i - 1 ] [ j - 1 ] < ( j - i ) ) :
LCSRe [ i ] [ j ] = LCSRe [ i - 1 ] [ j - 1 ] + 1
if ( LCSRe [ i ] [ j ] > res_length ) :
res_length = LCSRe [ i ] [ j ]
index = max ( i , index )
else :
LCSRe [ i ] [ j ] = 0
if ( res_length > 0 ) :
for i in range ( index - res_length + 1 , index + 1 ) :
res = res + str [ i - 1 ]
return res
| code_translation | [
[
"'fbfHTjE'",
"'f'"
],
[
"'09285256323'",
"'2'"
],
[
"'0011000101110'",
"'001'"
],
[
"'ue JkVZTt'",
"''"
],
[
"'48387612426300'",
"'4'"
],
[
"'010'",
"'0'"
],
[
"'ddRrUz'",
"'d'"
],
[
"'1049162633793'",
"'1'"
],
[
"... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int arr [ ], int n ) {
unordered_set < int > S;
for ( int i = 0;
i < n;
i ++ ) S . insert ( arr [ i ] );
int ans = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( S . find ( arr [ i ] - 1 ) == S . end ( ) ) {
int j = arr [ i ];
while ( S . find ( j ) != S . end ( ) ) j ++;
ans = max ( ans, j - arr [ i ] );
}
}
return ans;
}
| [] | null | [] | NUMBER_N_DIGIT_STEPPING_NUMBERS | python | [] | def f_gold ( n ) :
dp = [ [ 0 for x in range ( 10 ) ] for y in range ( n + 1 ) ] ;
if ( n == 1 ) :
return 10 ;
for j in range ( 10 ) :
dp [ 1 ] [ j ] = 1 ;
for i in range ( 2 , n + 1 ) :
for j in range ( 10 ) :
if ( j == 0 ) :
dp [ i ] [ j ] = dp [ i - 1 ] [ j + 1 ] ;
elif ( j == 9 ) :
dp [ i ] [ j ] = dp [ i - 1 ] [ j - 1 ] ;
else :
dp [ i ] [ j ] = ( dp [ i - 1 ] [ j - 1 ] + dp [ i - 1 ] [ j + 1 ] ) ;
sum = 0 ;
for j in range ( 1 , 10 ) :
sum = sum + dp [ n ] [ j ] ;
return sum ;
| code_translation | [
[
"18",
"547810"
],
[
"66",
"21181622535989461745"
],
[
"73",
"2029839041161556077001"
],
[
"70",
"287240945935564706557"
],
[
"26",
"100719775"
],
[
"41",
"1774846161206"
],
[
"20",
"2017126"
],
[
"25",
"52479500"
],
[
... | |
transcoder-geeksforgeeks | cpp | f_gold |
using namespace std;
int f_gold ( int a [ ], int size ) {
int max_so_far = a [ 0 ];
int curr_max = a [ 0 ];
for ( int i = 1;
i < size;
i ++ ) {
curr_max = max ( a [ i ], curr_max + a [ i ] );
max_so_far = max ( max_so_far, curr_max );
}
return max_so_far;
}
| [] | null | [] | PROGRAM_FIND_STRING_START_END_GEEKS | python | [] | def f_gold ( str , corner ) :
n = len ( str )
cl = len ( corner )
if ( n < cl ) :
return False
return ( ( str [ : cl ] == corner ) and ( str [ n - cl : ] == corner ) )
| code_translation | [
[
"'geeksmanishgeeks', 'geeks'",
"True"
],
[
"'shreyadhatwalia', 'abc'",
"False"
],
[
"'10000100', '100'",
"True"
],
[
"'abaa', 'a'",
"True"
],
[
"'30645530', '30'",
"True"
],
[
"'0000011011001', '001'",
"False"
],
[
"'dkqEd', 'd'",
"Tr... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.