suffix null | compare_func listlengths 0 0 | demos listlengths 0 0 | tgt_lang stringclasses 1
value | task_name stringclasses 1
value | solution stringlengths 40 1.94k | src_lang stringclasses 1
value | doc_string stringclasses 1
value | test_cases listlengths 10 11 | entry_func stringclasses 1
value | data_id stringlengths 9 106 | dataset_name stringclasses 1
value | prefix stringlengths 188 2.04k | import_str listlengths 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
null | [] | [] | python | code_translation | 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
| java | [
[
"'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"
],
... | f_gold | NUMBER_SUBSEQUENCES_AB_STRING_REPEATED_K_TIMES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_SUBSEQUENCES_AB_STRING_REPEATED_K_TIMES{
static int f_gold ( String s , int K ) {
int n = s . length ( ) ;
int C = 0 , c1 = 0 , c2 = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( s . charAt ( i ) == 'a' ) c1 ++ ;
if ( s . charAt ( i ) == 'b' ) {
c2 ++ ;
C += c1 ;
}
}
return C * K + ( K * ( K - 1 ) / 2 ) * c1 * c2 ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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... | f_gold | MAXIMUM_SUM_BITONIC_SUBARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_SUM_BITONIC_SUBARRAY{
static int f_gold ( int arr [ ] , int n ) {
int [ ] msis = new int [ n ] ;
int [ ] msds = new int [ n ] ;
int max_sum = Integer . MIN_VALUE ;
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 | [] | [] | python | code_translation | 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 )
| java | [
[
"73",
"8"
],
[
"28",
"6"
],
[
"33",
"6"
],
[
"23",
"6"
],
[
"84",
"8"
],
[
"31",
"6"
],
[
"48",
"7"
],
[
"46",
"7"
],
[
"45",
"7"
],
[
"90",
"9"
]
] | f_gold | MAXIMUM_GAMES_PLAYED_WINNER | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_GAMES_PLAYED_WINNER{
static int f_gold ( int N ) {
int [ ] dp = new int [ 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 | [] | [] | python | code_translation | 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
| java | [
[
"[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",
"... | f_gold | EFFICIENT_SEARCH_IN_AN_ARRAY_WHERE_DIFFERENCE_BETWEEN_ADJACENT_IS_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class EFFICIENT_SEARCH_IN_AN_ARRAY_WHERE_DIFFERENCE_BETWEEN_ADJACENT_IS_1{
static int f_gold ( int arr [ ] , int n , int x ) {
int i = 0 ;
while ( i <= n - 1 ) {
if ( arr [ i ] == x ) return i ;
i += Math . abs ( arr [ i ] - x ) ;
}
return - 1 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
if ( n == 0 ) :
return 0
else :
return 1 + f_gold ( n & ( n - 1 ) )
| java | [
[
"6",
"2"
],
[
"58",
"4"
],
[
"90",
"4"
],
[
"69",
"3"
],
[
"15",
"4"
],
[
"54",
"4"
],
[
"60",
"4"
],
[
"51",
"4"
],
[
"46",
"4"
],
[
"91",
"5"
]
] | f_gold | COUNT_SET_BITS_IN_AN_INTEGER_3 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_SET_BITS_IN_AN_INTEGER_3{
public static int f_gold ( int n ) {
if ( n == 0 ) return 0 ;
else return 1 + f_gold ( n & ( n - 1 ) ) ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"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"
]
] | f_gold | COMPUTE_N_UNDER_MODULO_P | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COMPUTE_N_UNDER_MODULO_P{
static 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 | [] | [] | python | code_translation | 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
| java | [
[
"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"
]
] | f_gold | COUNT_FACTORIAL_NUMBERS_IN_A_GIVEN_RANGE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_FACTORIAL_NUMBERS_IN_A_GIVEN_RANGE{
static 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 | [] | [] | python | code_translation | 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
| java | [
[
"[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"
],
[
... | f_gold | FIND_THE_ELEMENT_THAT_APPEARS_ONCE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_THE_ELEMENT_THAT_APPEARS_ONCE{
static 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 | [] | [] | python | code_translation | 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
| java | [
[
"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,... | f_gold | PAINTING_FENCE_ALGORITHM | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PAINTING_FENCE_ALGORITHM{
static 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 = ( int ) total * ( k - 1 ) ;
diff = diff % mod ;
total = ( same + diff ) % mod ;
}
return total ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ]
| java | [
[
"73, 75",
"5800834723650648582408201347161496628568500"
],
[
"70, 5",
"1088430"
],
[
"53, 62",
"544984327577929166763558054404688"
],
[
"80, 70",
"16698257436934424602116017431974081551656800"
],
[
"9, 59",
"5743572120"
],
[
"38, 48",
"9310640289... | f_gold | COUNT_POSSIBLE_PATHS_TOP_LEFT_BOTTOM_RIGHT_NXM_MATRIX_2 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_POSSIBLE_PATHS_TOP_LEFT_BOTTOM_RIGHT_NXM_MATRIX_2{
static int f_gold ( int m , int n ) {
int [ ] dp = new int [ n ] ;
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 | [] | [] | python | code_translation | 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
| java | [
[
"60",
"7021"
],
[
"74",
"11190"
],
[
"8",
"77"
],
[
"74",
"11190"
],
[
"34",
"1974"
],
[
"66",
"8680"
],
[
"96",
"19920"
],
[
"11",
"156"
],
[
"45",
"3697"
],
[
"72",
"10530"
]
] | f_gold | SUM_MATRIX_ELEMENT_ELEMENT_INTEGER_DIVISION_ROW_COLUMN | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SUM_MATRIX_ELEMENT_ELEMENT_INTEGER_DIVISION_ROW_COLUMN{
static 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 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
if ( n == 0 or n == 1 ) :
return 1 ;
return n * f_gold ( n - 2 ) ;
| java | [
[
"52",
"27064431817106664380040216576000000"
],
[
"93",
"2987435000850314871976096554696085799164511452611632783323554397412109375"
],
[
"15",
"2027025"
],
[
"72",
"25563186766285862273530264901662157745369907200000000"
],
[
"61",
"178215198865986332638610166... | f_gold | DOUBLE_FACTORIAL | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class DOUBLE_FACTORIAL{
static long f_gold ( long n ) {
if ( n == 0 || n == 1 ) return 1 ;
return n * f_gold ( n - 2 ) ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ]
| java | [
[
"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... | f_gold | COUNT_NUMBER_WAYS_TILE_FLOOR_SIZE_N_X_M_USING_1_X_M_SIZE_TILES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_NUMBER_WAYS_TILE_FLOOR_SIZE_N_X_M_USING_1_X_M_SIZE_TILES{
static int f_gold ( int n , int m ) {
int count [ ] = new int [ n + 1 ] ;
count [ 0 ] = 0 ;
int i ;
for ( 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 | [] | [] | python | code_translation | 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 ;
| java | [
[
"[[]], 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, ... | f_gold | PROGRAM_PRINT_IDENTITY_MATRIX_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PROGRAM_PRINT_IDENTITY_MATRIX_1{
static boolean f_gold ( int mat [ ] [ ] , int N ) {
for ( int row = 0 ;
row < N ;
row ++ ) {
for ( int col = 0 ;
col < N ;
col ++ ) {
if ( row == col && mat [ row ] [ col ] != 1 ) return false ;
else if ( row != col && mat [ row ] [ col ] != 0 ) return false ;
}
}
return true ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ]
| java | [
[
"'TTFT', '|&^', 4",
"4"
],
[
"'TFT', '^&', 3",
"2"
],
[
"'TFF', '^|', 3",
"2"
],
[
"'TTFT', '|||', 4",
"5"
],
[
"'TTFT', '&&&', 4",
"0"
],
[
"'TTFT', '&&^', 4",
"5"
],
[
"'TTFT', '^&|', 4",
"2"
],
[
"'TTFT', '^^^', 4",
"5"... | f_gold | DYNAMIC_PROGRAMMING_SET_37_BOOLEAN_PARENTHESIZATION_PROBLEM | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class DYNAMIC_PROGRAMMING_SET_37_BOOLEAN_PARENTHESIZATION_PROBLEM{
static int f_gold ( char symb [ ] , char oper [ ] , int n ) {
int F [ ] [ ] = new int [ n ] [ n ] ;
int T [ ] [ ] = new int [ 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 | code_translation | from math import sqrt
def f_gold ( a ) :
area = ( sqrt ( 5 * ( 5 + 2 * ( sqrt ( 5 ) ) ) ) * a * a ) / 4
return area
| java | [
[
"2009.019461888707",
"6944120.6857642615"
],
[
"-1480.5131394215787",
"3771147.371815937"
],
[
"357.7870347569567",
"220240.9998483103"
],
[
"-8040.293697508038",
"111222537.30911414"
],
[
"3821.882657293133",
"25130647.008061722"
],
[
"-6840.6350722... | f_gold | PROGRAM_TO_FIND_THE_AREA_OF_PENTAGON | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PROGRAM_TO_FIND_THE_AREA_OF_PENTAGON{
static float f_gold ( float a ) {
float area ;
area = ( float ) ( Math . sqrt ( 5 * ( 5 + 2 * ( Math . sqrt ( 5 ) ) ) ) * a * a ) / 4 ;
return area ;
}
| [
"from math import sqrt"
] | |
null | [] | [] | python | code_translation | 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 ;
| java | [
[
"[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... | f_gold | MAXIMUM_CONSECUTIVE_NUMBERS_PRESENT_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_CONSECUTIVE_NUMBERS_PRESENT_ARRAY{
static int f_gold ( int arr [ ] , int n ) {
HashSet < Integer > S = new HashSet < Integer > ( ) ;
for ( int i = 0 ;
i < n ;
i ++ ) S . add ( arr [ i ] ) ;
int ans = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( S . contains ( arr [ i ] ) ) {
int j = arr [ i ] ;
while ( S . contains ( j ) ) j ++ ;
ans = Math . max ( ans , j - arr [ i ] ) ;
}
}
return ans ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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,... | f_gold | LARGEST_SUM_CONTIGUOUS_SUBARRAY_2 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class LARGEST_SUM_CONTIGUOUS_SUBARRAY_2{
static 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 = Math . max ( a [ i ] , curr_max + a [ i ] ) ;
max_so_far = Math . max ( max_so_far , curr_max ) ;
}
return max_so_far ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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... | f_gold | MINIMUM_SUM_TWO_NUMBERS_FORMED_DIGITS_ARRAY_2 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MINIMUM_SUM_TWO_NUMBERS_FORMED_DIGITS_ARRAY_2{
static int f_gold ( int a [ ] , int n ) {
Arrays . sort ( a ) ;
int num1 = 0 ;
int num2 = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( i % 2 == 0 ) num1 = num1 * 10 + a [ i ] ;
else num2 = num2 * 10 + a [ i ] ;
}
return num2 + num1 ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"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"
],
[
... | f_gold | MODULAR_EXPONENTIATION_POWER_IN_MODULAR_ARITHMETIC | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MODULAR_EXPONENTIATION_POWER_IN_MODULAR_ARITHMETIC{
static int f_gold ( int x , int y , int p ) {
int 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 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
parity = 0
while n :
parity = ~ parity
n = n & ( n - 1 )
return parity
| java | [
[
"63",
"0"
],
[
"64",
"-1"
],
[
"85",
"0"
],
[
"36",
"0"
],
[
"20",
"0"
],
[
"63",
"0"
],
[
"42",
"-1"
],
[
"19",
"-1"
],
[
"62",
"-1"
],
[
"97",
"-1"
]
] | f_gold | WRITE_A_C_PROGRAM_TO_FIND_THE_PARITY_OF_AN_UNSIGNED_INTEGER | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class WRITE_A_C_PROGRAM_TO_FIND_THE_PARITY_OF_AN_UNSIGNED_INTEGER{
static boolean f_gold ( int n ) {
boolean parity = false ;
while ( n != 0 ) {
parity = ! parity ;
n = n & ( n - 1 ) ;
}
return parity ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
p = 1
if ( n and not ( n & ( n - 1 ) ) ) :
return n
while ( p < n ) :
p <<= 1
return p ;
| java | [
[
"31",
"32"
],
[
"89",
"128"
],
[
"92",
"128"
],
[
"66",
"128"
],
[
"38",
"64"
],
[
"34",
"64"
],
[
"17",
"32"
],
[
"24",
"32"
],
[
"54",
"64"
],
[
"20",
"32"
]
] | f_gold | SMALLEST_POWER_OF_2_GREATER_THAN_OR_EQUAL_TO_N_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SMALLEST_POWER_OF_2_GREATER_THAN_OR_EQUAL_TO_N_1{
static int f_gold ( int n ) {
int p = 1 ;
if ( n > 0 && ( n & ( n - 1 ) ) == 0 ) return n ;
while ( p < n ) p <<= 1 ;
return p ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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, ... | f_gold | K_TH_MISSING_ELEMENT_INCREASING_SEQUENCE_NOT_PRESENT_GIVEN_SEQUENCE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class K_TH_MISSING_ELEMENT_INCREASING_SEQUENCE_NOT_PRESENT_GIVEN_SEQUENCE{
static int f_gold ( int a [ ] , int b [ ] , int k , int n1 , int n2 ) {
LinkedHashSet < Integer > s = new LinkedHashSet < > ( ) ;
for ( int i = 0 ;
i < n2 ;
i ++ ) s . add ( b [ i ] ) ;
int missing = 0 ;
for ( int i = 0 ;
i < n1 ;
i ++ ) {
if ( ! s . contains ( a [ i ] ) ) missing ++ ;
if ( missing == k ) return a [ i ] ;
}
return - 1 ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"60",
"71980"
],
[
"44",
"28380"
],
[
"72",
"124392"
],
[
"90",
"242970"
],
[
"99",
"323400"
],
[
"45",
"30360"
],
[
"27",
"6552"
],
[
"11",
"440"
],
[
"65",
"91520"
],
[
"52",
"46852"
]
] | f_gold | SUM_MATRIX_ELEMENT_ABSOLUTE_DIFFERENCE_ROW_COLUMN_NUMBERS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SUM_MATRIX_ELEMENT_ABSOLUTE_DIFFERENCE_ROW_COLUMN_NUMBERS{
static int f_gold ( int n ) {
int [ ] [ ] arr = new int [ n ] [ n ] ;
for ( int i = 0 ;
i < n ;
i ++ ) for ( int j = 0 ;
j < n ;
j ++ ) arr [ i ] [ j ] = Math . abs ( i - j ) ;
int sum = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) for ( int j = 0 ;
j < n ;
j ++ ) sum += arr [ i ] [ j ] ;
return sum ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"66, 4",
"18974736"
],
[
"82, 66",
"2049813067056723342764042528136639432893302901053747234410457506551439003896274462989048978198596972547480537410778555874279424"
],
[
"12, 38",
"102067469997853225734913580209377959215104"
],
[
"55, 33",
"27037638262714967295762346820... | f_gold | WRITE_YOU_OWN_POWER_WITHOUT_USING_MULTIPLICATION_AND_DIVISION | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class WRITE_YOU_OWN_POWER_WITHOUT_USING_MULTIPLICATION_AND_DIVISION{
static 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 ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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,... | f_gold | FIND_WHETHER_AN_ARRAY_IS_SUBSET_OF_ANOTHER_ARRAY_SET_1_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_WHETHER_AN_ARRAY_IS_SUBSET_OF_ANOTHER_ARRAY_SET_1_1{
static boolean f_gold ( int arr1 [ ] , int arr2 [ ] , int m , int n ) {
int i = 0 , j = 0 ;
if ( m < n ) return false ;
Arrays . sort ( arr1 ) ;
Arrays . sort ( arr2 ) ;
while ( i < n && j < m ) {
if ( arr1 [ j ] < arr2 [ i ] ) j ++ ;
else if ( arr1 [ j ] == arr2 [ i ] ) {
j ++ ;
i ++ ;
}
else if ( arr1 [ j ] > arr2 [ i ] ) return false ;
}
if ( i < n ) return false ;
else return true ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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... | f_gold | SORT_EVEN_PLACED_ELEMENTS_INCREASING_ODD_PLACED_DECREASING_ORDER | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SPLIT_ARRAY_ADD_FIRST_PART_END{
public static void f_gold ( int arr [ ] , int n , int k ) {
for ( int i = 0 ;
i < k ;
i ++ ) {
int x = arr [ 0 ] ;
for ( int j = 0 ;
j < n - 1 ;
++ j ) arr [ j ] = arr [ j + 1 ] ;
arr [ n - 1 ] = x ;
}
}
| [] | |
null | [] | [] | python | code_translation | 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 ;
| java | [
[
"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"
]
] | f_gold | CHECK_IF_A_NUMBER_IS_POWER_OF_ANOTHER_NUMBER_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_IF_A_NUMBER_IS_POWER_OF_ANOTHER_NUMBER_1{
static boolean f_gold ( int x , int y ) {
int res1 = ( int ) Math . log ( y ) / ( int ) Math . log ( x ) ;
double res2 = Math . log ( y ) / Math . log ( x ) ;
return ( res1 == res2 ) ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"['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... | f_gold | POLICEMEN_CATCH_THIEVES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class POLICEMEN_CATCH_THIEVES{
static int f_gold ( char arr [ ] , int n , int k ) {
int res = 0 ;
ArrayList < Integer > thi = new ArrayList < Integer > ( ) ;
ArrayList < Integer > pol = new ArrayList < Integer > ( ) ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( arr [ i ] == 'P' ) pol . add ( i ) ;
else if ( arr [ i ] == 'T' ) thi . add ( i ) ;
}
int l = 0 , r = 0 ;
while ( l < thi . size ( ) && r < pol . size ( ) ) {
if ( Math . abs ( thi . get ( l ) - pol . get ( r ) ) <= k ) {
res ++ ;
l ++ ;
r ++ ;
}
else if ( thi . get ( l ) < pol . get ( r ) ) l ++ ;
else r ++ ;
}
return res ;
}
| [] | |
null | [] | [] | python | code_translation | 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)
| java | [
[
"62",
"6973568802"
],
[
"53",
"258280326"
],
[
"8",
"18"
],
[
"6",
"9"
],
[
"35",
"354294"
],
[
"35",
"354294"
],
[
"46",
"19131876"
],
[
"74",
"564859072962"
],
[
"69",
"94143178827"
],
[
"3",
"2"
... | f_gold | DYNAMIC_PROGRAMMING_SET_36_CUT_A_ROPE_TO_MAXIMIZE_PRODUCT_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class DYNAMIC_PROGRAMMING_SET_36_CUT_A_ROPE_TO_MAXIMIZE_PRODUCT_1{
static int f_gold ( int n ) {
if ( n == 2 || n == 3 ) return ( n - 1 ) ;
int res = 1 ;
while ( n > 4 ) {
n -= 3 ;
res *= 3 ;
}
return ( n * res ) ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"'geeekk'",
"'e'"
],
[
"'3786868'",
"'3'"
],
[
"'110'",
"'1'"
],
[
"'aaaabbcbbb'",
"'a'"
],
[
"'11'",
"'1'"
],
[
"'011101'",
"'1'"
],
[
"'WoHNyJYLC'",
"'W'"
],
[
"'3141711779'",
"'1'"
],
[
"'10111101101'",
"'1'... | f_gold | MAXIMUM_CONSECUTIVE_REPEATING_CHARACTER_STRING | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_CONSECUTIVE_REPEATING_CHARACTER_STRING{
static char f_gold ( String str ) {
int len = str . length ( ) ;
int count = 0 ;
char res = str . charAt ( 0 ) ;
for ( int i = 0 ;
i < len ;
i ++ ) {
int cur_count = 1 ;
for ( int j = i + 1 ;
j < len ;
j ++ ) {
if ( str . charAt ( i ) != str . charAt ( j ) ) break ;
cur_count ++ ;
}
if ( cur_count > count ) {
count = cur_count ;
res = str . charAt ( i ) ;
}
}
return res ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[[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... | f_gold | COUNT_NEGATIVE_NUMBERS_IN_A_COLUMN_WISE_ROW_WISE_SORTED_MATRIX | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_NEGATIVE_NUMBERS_IN_A_COLUMN_WISE_ROW_WISE_SORTED_MATRIX{
static int f_gold ( int M [ ] [ ] , int n , int m ) {
int count = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
for ( int j = 0 ;
j < m ;
j ++ ) {
if ( M [ i ] [ j ] < 0 ) count += 1 ;
else break ;
}
}
return count ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( s ) :
length = int ( s / 3 )
s -= length
breadth = s / 2
height = s - breadth
return int ( length * breadth * height )
| java | [
[
"8",
"18"
],
[
"96",
"32768"
],
[
"96",
"32768"
],
[
"96",
"32768"
],
[
"12",
"64"
],
[
"95",
"31744"
],
[
"72",
"13824"
],
[
"81",
"19683"
],
[
"42",
"2744"
],
[
"13",
"81"
]
] | f_gold | MAXIMIZE_VOLUME_CUBOID_GIVEN_SUM_SIDES_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMIZE_VOLUME_CUBOID_GIVEN_SUM_SIDES_1{
static int f_gold ( int s ) {
int length = s / 3 ;
s -= length ;
int breadth = s / 2 ;
int height = s - breadth ;
return length * breadth * height ;
}
| [] | |
null | [] | [] | python | code_translation | 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]
| java | [
[
"87",
"16435314834665426797069144960762886143367590394940"
],
[
"69",
"337485502510215975556783793455058624700"
],
[
"15",
"9694845"
],
[
"11",
"58786"
],
[
"11",
"58786"
],
[
"15",
"9694845"
],
[
"47",
"33868773757191046886429490"
... | f_gold | NUMBER_OF_BINARY_TREES_FOR_GIVEN_PREORDER_SEQUENCE_LENGTH | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_OF_BINARY_TREES_FOR_GIVEN_PREORDER_SEQUENCE_LENGTH{
static int f_gold ( int n ) {
int BT [ ] = new int [ n + 1 ] ;
for ( int i = 0 ;
i <= n ;
i ++ ) BT [ i ] = 0 ;
BT [ 0 ] = BT [ 1 ] = 1 ;
for ( int i = 2 ;
i <= n ;
++ i ) for ( int j = 0 ;
j < i ;
j ++ ) BT [ i ] += BT [ j ] * BT [ i - j - 1 ] ;
return BT [ n ] ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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"
],
[
... | f_gold | CHECK_WHETHER_ARITHMETIC_PROGRESSION_CAN_FORMED_GIVEN_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_WHETHER_ARITHMETIC_PROGRESSION_CAN_FORMED_GIVEN_ARRAY{
static boolean f_gold ( int arr [ ] , int n ) {
if ( n == 1 ) return true ;
Arrays . sort ( arr ) ;
int d = arr [ 1 ] - arr [ 0 ] ;
for ( int i = 2 ;
i < n ;
i ++ ) if ( arr [ i ] - arr [ i - 1 ] != d ) return false ;
return true ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ;
| java | [
[
"[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... | f_gold | COUNT_PAIRS_WHOSE_PRODUCTS_EXIST_IN_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_PAIRS_WHOSE_PRODUCTS_EXIST_IN_ARRAY{
static int f_gold ( int arr [ ] , int n ) {
int result = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
for ( int j = i + 1 ;
j < n ;
j ++ ) {
int product = arr [ i ] * arr [ j ] ;
for ( int k = 0 ;
k < n ;
k ++ ) {
if ( arr [ k ] == product ) {
result ++ ;
break ;
}
}
}
}
return result ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"'geeekk'",
"'e'"
],
[
"'3786868'",
"'3'"
],
[
"'110'",
"'1'"
],
[
"'aaaabbcbbb'",
"'a'"
],
[
"'11'",
"'1'"
],
[
"'011101'",
"'1'"
],
[
"'WoHNyJYLC'",
"'W'"
],
[
"'3141711779'",
"'1'"
],
[
"'10111101101'",
"'1'... | f_gold | MAXIMUM_CONSECUTIVE_REPEATING_CHARACTER_STRING_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_CONSECUTIVE_REPEATING_CHARACTER_STRING_1{
static char f_gold ( String str ) {
int n = str . length ( ) ;
int count = 0 ;
char res = str . charAt ( 0 ) ;
int cur_count = 1 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( i < n - 1 && str . charAt ( i ) == str . charAt ( i + 1 ) ) cur_count ++ ;
else {
if ( cur_count > count ) {
count = cur_count ;
res = str . charAt ( i ) ;
}
cur_count = 1 ;
}
}
return res ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( s , n ) :
s1 = s
for i in range ( 1 , n ) :
s += s1
return s
| java | [
[
"'LPWsaI', 41",
"'LPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaILPWsaI'"
],
[
"'9037515104', 72",
"'... | f_gold | C_PROGRAM_CONCATENATE_STRING_GIVEN_NUMBER_TIMES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class C_PROGRAM_CONCATENATE_STRING_GIVEN_NUMBER_TIMES{
static String f_gold ( String s , int n ) {
String s1 = s ;
for ( int i = 1 ;
i < n ;
i ++ ) s += s1 ;
return s ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n , x ) :
res = 0
for i in range ( n ) :
if x == arr [ i ] :
res += 1
return res
| java | [
[
"[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... | f_gold | COUNT_NUMBER_OF_OCCURRENCES_OR_FREQUENCY_IN_A_SORTED_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_NUMBER_OF_OCCURRENCES_OR_FREQUENCY_IN_A_SORTED_ARRAY{
static int f_gold ( int arr [ ] , int n , int x ) {
int res = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) if ( x == arr [ i ] ) res ++ ;
return res ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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, ... | f_gold | FIRST_ELEMENT_OCCURRING_K_TIMES_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIRST_ELEMENT_OCCURRING_K_TIMES_ARRAY{
static int f_gold ( int arr [ ] , int n , int k ) {
HashMap < Integer , Integer > count_map = new HashMap < > ( ) ;
for ( int i = 0 ;
i < n ;
i ++ ) {
int a = 0 ;
if ( count_map . get ( arr [ i ] ) != null ) {
a = count_map . get ( arr [ i ] ) ;
}
count_map . put ( arr [ i ] , a + 1 ) ;
}
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( count_map . get ( arr [ i ] ) == k ) {
return arr [ i ] ;
}
}
return - 1 ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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,... | f_gold | SPLIT_ARRAY_ADD_FIRST_PART_END | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SPLIT_ARRAY_ADD_FIRST_PART_END{
public static void f_gold ( int arr [ ] , int n , int k ) {
for ( int i = 0 ;
i < k ;
i ++ ) {
int x = arr [ 0 ] ;
for ( int j = 0 ;
j < n - 1 ;
++ j ) arr [ j ] = arr [ j + 1 ] ;
arr [ n - 1 ] = x ;
}
}
| [] | |
null | [] | [] | python | code_translation | 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 ]
| java | [
[
"[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"
],
... | f_gold | K_TH_LARGEST_SUM_CONTIGUOUS_SUBARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class K_TH_LARGEST_SUM_CONTIGUOUS_SUBARRAY{
static int f_gold ( int arr [ ] , int n , int k ) {
int sum [ ] = new int [ n + 1 ] ;
sum [ 0 ] = 0 ;
sum [ 1 ] = arr [ 0 ] ;
for ( int i = 2 ;
i <= n ;
i ++ ) sum [ i ] = sum [ i - 1 ] + arr [ i - 1 ] ;
PriorityQueue < Integer > Q = new PriorityQueue < Integer > ( ) ;
for ( int i = 1 ;
i <= n ;
i ++ ) {
for ( int j = i ;
j <= n ;
j ++ ) {
int x = sum [ j ] - sum [ i - 1 ] ;
if ( Q . size ( ) < k ) Q . add ( x ) ;
else {
if ( Q . peek ( ) < x ) {
Q . poll ( ) ;
Q . add ( x ) ;
}
}
}
}
return Q . poll ( ) ;
}
| [
"import heapq"
] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"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... | f_gold | TEMPLE_OFFERINGS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class TEMPLE_OFFERINGS{
static int f_gold ( int n , int templeHeight [ ] ) {
int sum = 0 ;
for ( int i = 0 ;
i < n ;
++ i ) {
int left = 0 , right = 0 ;
for ( int j = i - 1 ;
j >= 0 ;
-- j ) {
if ( templeHeight [ j ] < templeHeight [ j + 1 ] ) ++ left ;
else break ;
}
for ( int j = i + 1 ;
j < n ;
++ j ) {
if ( templeHeight [ j ] < templeHeight [ j - 1 ] ) ++ right ;
else break ;
}
sum += Math . max ( right , left ) + 1 ;
}
return sum ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ] ) )
| java | [
[
"[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... | f_gold | MINIMUM_SUM_SUBSEQUENCE_LEAST_ONE_EVERY_FOUR_CONSECUTIVE_ELEMENTS_PICKED | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MINIMUM_SUM_SUBSEQUENCE_LEAST_ONE_EVERY_FOUR_CONSECUTIVE_ELEMENTS_PICKED{
static int f_gold ( int [ ] arr , int n ) {
int [ ] dp = new int [ n ] ;
if ( n == 1 ) return arr [ 0 ] ;
if ( n == 2 ) return Math . min ( arr [ 0 ] , arr [ 1 ] ) ;
if ( n == 3 ) return Math . min ( arr [ 0 ] , Math . min ( arr [ 1 ] , arr [ 2 ] ) ) ;
if ( n == 4 ) return Math . min ( Math . min ( arr [ 0 ] , arr [ 1 ] ) , Math . min ( arr [ 2 ] , arr [ 3 ] ) ) ;
dp [ 0 ] = arr [ 0 ] ;
dp [ 1 ] = arr [ 1 ] ;
dp [ 2 ] = arr [ 2 ] ;
dp [ 3 ] = arr [ 3 ] ;
for ( int i = 4 ;
i < n ;
i ++ ) dp [ i ] = arr [ i ] + Math . min ( Math . min ( dp [ i - 1 ] , dp [ i - 2 ] ) , Math . min ( dp [ i - 3 ] , dp [ i - 4 ] ) ) ;
return Math . min ( Math . min ( dp [ n - 1 ] , dp [ n - 2 ] ) , Math . min ( dp [ n - 4 ] , dp [ n - 3 ] ) ) ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"'(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(... | f_gold | PRODUCT_NODES_K_TH_LEVEL_TREE_REPRESENTED_STRING | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PRODUCT_NODES_K_TH_LEVEL_TREE_REPRESENTED_STRING{
static int f_gold ( String tree , int k ) {
int level = - 1 ;
int product = 1 ;
int n = tree . length ( ) ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( tree . charAt ( i ) == '(' ) level ++ ;
else if ( tree . charAt ( i ) == ')' ) level -- ;
else {
if ( level == k ) product *= ( tree . charAt ( i ) - '0' ) ;
}
}
return product ;
}
| [] | |
null | [] | [] | python | code_translation | 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 )
| java | [
[
"[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... | f_gold | RECURSIVE_C_PROGRAM_LINEARLY_SEARCH_ELEMENT_GIVEN_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class RECURSIVE_C_PROGRAM_LINEARLY_SEARCH_ELEMENT_GIVEN_ARRAY{
static 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 ) ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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,... | f_gold | CHECK_POSSIBLE_SORT_ARRAY_CONDITIONAL_SWAPPING_ADJACENT_ALLOWED | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_POSSIBLE_SORT_ARRAY_CONDITIONAL_SWAPPING_ADJACENT_ALLOWED{
static boolean f_gold ( int arr [ ] , int n ) {
for ( int i = 0 ;
i < n - 1 ;
i ++ ) {
if ( arr [ i ] > arr [ i + 1 ] ) {
if ( arr [ i ] - arr [ i + 1 ] == 1 ) {
int temp = arr [ i ] ;
arr [ i ] = arr [ i + 1 ] ;
arr [ i + 1 ] = temp ;
}
else return false ;
}
}
return true ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
return 1 if ( n == 1 or n == 0 ) else n * f_gold ( n - 1 )
| java | [
[
"66",
"544344939077443064003729240247842752644293064388798874532860126869671081148416000000000000000"
],
[
"93",
"1156772507081641574759205162306240436214753229576413535186142281213246807121467315215203289516844845303838996289387078090752000000000000000000000"
],
[
"39",
"203978820... | f_gold | C_PROGRAM_FACTORIAL_NUMBER_2 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class C_PROGRAM_FACTORIAL_NUMBER_2{
static int f_gold ( int n ) {
return ( n == 1 || n == 0 ) ? 1 : n * f_gold ( n - 1 ) ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ;
| java | [
[
"49",
"0.7803986631477524"
],
[
"4",
"-0.16507936507936516"
],
[
"60",
"-0.21050375120783382"
],
[
"90",
"-0.21185466678122022"
],
[
"96",
"-0.2120245854859959"
],
[
"29",
"0.7770671416747363"
],
[
"86",
"-0.21172836828074082"
],
... | f_gold | SUM_SERIES_23_45_67_89_UPTO_N_TERMS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SUM_SERIES_23_45_67_89_UPTO_N_TERMS{
static double f_gold ( int n ) {
int i = 1 ;
double res = 0.0 ;
boolean sign = true ;
while ( n > 0 ) {
n -- ;
if ( sign ) {
sign = ! sign ;
res = res + ( double ) ++ i / ++ i ;
}
else {
sign = ! sign ;
res = res - ( double ) ++ i / ++ i ;
}
}
return res ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"17",
"58.47239288489289"
],
[
"72",
"349.9783310569835"
],
[
"43",
"187.0499406858786"
],
[
"55",
"252.6486716559348"
],
[
"62",
"291.1683590456309"
],
[
"22",
"81.19789150478006"
],
[
"17",
"58.47239288489289"
],
[
"68",
... | f_gold | COUNT_NUMBER_PAIRS_N_B_N_GCD_B_B | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_NUMBER_PAIRS_N_B_N_GCD_B_B{
static int f_gold ( int n ) {
int k = n ;
int imin = 1 ;
int ans = 0 ;
while ( imin <= n ) {
int imax = n / k ;
ans += k * ( imax - imin + 1 ) ;
imin = imax + 1 ;
k = n / imin ;
}
return ans ;
}
| [] | |
null | [] | [] | python | code_translation | import math
def f_gold ( side ) :
return ( ( ( 15 + ( 7 * ( math.sqrt ( 5 ) ) ) ) / 4 ) * ( math.pow ( side , 3 ) ) )
| java | [
[
"56",
"1345766.2993890555"
],
[
"73",
"2981083.5487053124"
],
[
"22",
"81596.89069273109"
],
[
"10",
"7663.118960624633"
],
[
"84",
"4541961.260438062"
],
[
"20",
"61304.95168499706"
],
[
"51",
"1016520.3932458181"
],
[
"91",
... | f_gold | CALCULATE_VOLUME_DODECAHEDRON | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CALCULATE_VOLUME_DODECAHEDRON{
static double f_gold ( int side ) {
return ( ( ( 15 + ( 7 * ( Math . sqrt ( 5 ) ) ) ) / 4 ) * ( Math . pow ( side , 3 ) ) ) ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
for i in range ( n ) :
arr [ i ] = i + 1
| java | [
[
"[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... | f_gold | SORT_ARRAY_CONTAIN_1_N_VALUES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
class SORT_ARRAY_CONTAIN_1_N_VALUES{
static void f_gold ( int [ ] arr , int n ) {
for ( int i = 0 ;
i < n ;
i ++ ) {
arr [ i ] = i + 1 ;
}
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( s ) :
for i in range ( len ( s ) ) :
if s [ i ].isdigit ( ) != True :
return False
return True
| java | [
[
"'MgTOyHo NT'",
"False"
],
[
"'033675175'",
"True"
],
[
"'011001'",
"True"
],
[
"'XLlccG'",
"False"
],
[
"'8223900094410'",
"True"
],
[
"'000'",
"True"
],
[
"'aupp'",
"False"
],
[
"'90202721499'",
"True"
],
[
"'110... | f_gold | PROGRAM_CHECK_INPUT_INTEGER_STRING | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PROGRAM_CHECK_INPUT_INTEGER_STRING{
static boolean f_gold ( String s ) {
for ( int i = 0 ;
i < s . length ( ) ;
i ++ ) if ( Character . isDigit ( s . charAt ( i ) ) == false ) return false ;
return true ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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,... | f_gold | MINIMUM_XOR_VALUE_PAIR_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MINIMUM_XOR_VALUE_PAIR_1{
static int f_gold ( int arr [ ] , int n ) {
Arrays . parallelSort ( arr ) ;
int minXor = Integer . MAX_VALUE ;
int val = 0 ;
for ( int i = 0 ;
i < n - 1 ;
i ++ ) {
val = arr [ i ] ^ arr [ i + 1 ] ;
minXor = Math . min ( minXor , val ) ;
}
return minXor ;
}
| [
"import sys"
] | |
null | [] | [] | python | code_translation | def f_gold(k):
cur = int((k * (k - 1)) + 1)
sum = 0
while k:
sum += cur
cur += 2
k = k - 1
return sum
| java | [
[
"91",
"753571"
],
[
"52",
"140608"
],
[
"78",
"474552"
],
[
"51",
"132651"
],
[
"65",
"274625"
],
[
"39",
"59319"
],
[
"42",
"74088"
],
[
"12",
"1728"
],
[
"56",
"175616"
],
[
"98",
"941192"
]
] | f_gold | SUM_K_TH_GROUP_ODD_POSITIVE_NUMBERS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SUM_K_TH_GROUP_ODD_POSITIVE_NUMBERS{
public static int f_gold ( int k ) {
int cur = ( k * ( k - 1 ) ) + 1 ;
int sum = 0 ;
while ( k -- > 0 ) {
sum += cur ;
cur += 2 ;
}
return sum ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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... | f_gold | FIND_SMALLEST_VALUE_REPRESENTED_SUM_SUBSET_GIVEN_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_SMALLEST_VALUE_REPRESENTED_SUM_SUBSET_GIVEN_ARRAY{
static int f_gold ( int arr [ ] , int n ) {
int res = 1 ;
for ( int i = 0 ;
i < n && arr [ i ] <= res ;
i ++ ) res = res + arr [ i ] ;
return res ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
return ( n % 15 == 0 )
| java | [
[
"30",
"True"
],
[
"-30",
"True"
],
[
"60",
"True"
],
[
"90",
"True"
],
[
"99",
"False"
],
[
"32",
"False"
],
[
"21",
"False"
],
[
"65",
"False"
],
[
"21",
"False"
],
[
"99",
"False"
]
] | f_gold | EFFICIENT_WAY_CHECK_WHETHER_N_TH_FIBONACCI_NUMBER_MULTIPLE_10 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class EFFICIENT_WAY_CHECK_WHETHER_N_TH_FIBONACCI_NUMBER_MULTIPLE_10{
static boolean f_gold ( int n ) {
if ( n % 15 == 0 ) return true ;
return false ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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,... | f_gold | DYNAMIC_PROGRAMMING_SET_14_MAXIMUM_SUM_INCREASING_SUBSEQUENCE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class DYNAMIC_PROGRAMMING_SET_14_MAXIMUM_SUM_INCREASING_SUBSEQUENCE{
static int f_gold ( int arr [ ] , int n ) {
int i , j , max = 0 ;
int msis [ ] = new int [ n ] ;
for ( i = 0 ;
i < n ;
i ++ ) msis [ i ] = arr [ i ] ;
for ( i = 1 ;
i < n ;
i ++ ) for ( j = 0 ;
j < i ;
j ++ ) if ( arr [ i ] > arr [ j ] && msis [ i ] < msis [ j ] + arr [ i ] ) msis [ i ] = msis [ j ] + arr [ i ] ;
for ( i = 0 ;
i < n ;
i ++ ) if ( max < msis [ i ] ) max = msis [ i ] ;
return max ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"'(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(... | f_gold | SUM_NODES_K_TH_LEVEL_TREE_REPRESENTED_STRING | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SUM_NODES_K_TH_LEVEL_TREE_REPRESENTED_STRING{
static int f_gold ( String tree , int k ) {
int level = - 1 ;
int sum = 0 ;
int n = tree . length ( ) ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( tree . charAt ( i ) == '(' ) level ++ ;
else if ( tree . charAt ( i ) == ')' ) level -- ;
else {
if ( level == k ) sum += ( tree . charAt ( i ) - '0' ) ;
}
}
return sum ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ;
| java | [
[
"37",
"31"
],
[
"25",
"21"
],
[
"63",
"51"
],
[
"66",
"54"
],
[
"32",
"26"
],
[
"5",
"5"
],
[
"41",
"33"
],
[
"82",
"66"
],
[
"54",
"44"
],
[
"5",
"5"
]
] | f_gold | PROGRAM_OCTAL_DECIMAL_CONVERSION | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PROGRAM_OCTAL_DECIMAL_CONVERSION{
static int f_gold ( int n ) {
int num = n ;
int dec_value = 0 ;
int base = 1 ;
int temp = num ;
while ( temp > 0 ) {
int last_digit = temp % 10 ;
temp = temp / 10 ;
dec_value += last_digit * base ;
base = base * 8 ;
}
return dec_value ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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,... | f_gold | REARRANGE_ARRAY_MAXIMUM_MINIMUM_FORM_SET_2_O1_EXTRA_SPACE_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
class REARRANGE_ARRAY_MAXIMUM_MINIMUM_FORM_SET_2_O1_EXTRA_SPACE_1{
public static void f_gold ( int arr [ ] , int n ) {
int max_ele = arr [ n - 1 ] ;
int min_ele = arr [ 0 ] ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( i % 2 == 0 ) {
arr [ i ] = max_ele ;
max_ele -= 1 ;
}
else {
arr [ i ] = min_ele ;
min_ele += 1 ;
}
}
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( str , n ) :
l = len ( str )
if ( l >= n ) :
return True
return False
| java | [
[
"'ZCoQhuM', 2",
"True"
],
[
"'7437725', 53",
"False"
],
[
"'11', 30",
"False"
],
[
"'buGlvR', 1",
"True"
],
[
"'9', 92",
"False"
],
[
"'101101010110', 3",
"True"
],
[
"'YguiM', 18",
"False"
],
[
"'8198', 90",
"False"
],
... | f_gold | CHECK_IF_STRING_REMAINS_PALINDROME_AFTER_REMOVING_GIVEN_NUMBER_OF_CHARACTERS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_IF_STRING_REMAINS_PALINDROME_AFTER_REMOVING_GIVEN_NUMBER_OF_CHARACTERS{
static boolean f_gold ( String str , int n ) {
int len = str . length ( ) ;
if ( len >= n ) return true ;
return false ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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], ... | f_gold | NUMBER_INDEXES_EQUAL_ELEMENTS_GIVEN_RANGE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_INDEXES_EQUAL_ELEMENTS_GIVEN_RANGE{
static 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 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
count = 0
while ( n ) :
n &= ( n - 1 )
count += 1
return count
| java | [
[
"32",
"1"
],
[
"94",
"5"
],
[
"33",
"2"
],
[
"99",
"4"
],
[
"17",
"2"
],
[
"64",
"1"
],
[
"80",
"2"
],
[
"42",
"3"
],
[
"12",
"2"
],
[
"86",
"4"
]
] | f_gold | COUNT_SET_BITS_IN_AN_INTEGER_2 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_SET_BITS_IN_AN_INTEGER_2{
static int f_gold ( int n ) {
int count = 0 ;
while ( n > 0 ) {
n &= ( n - 1 ) ;
count ++ ;
}
return count ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"97",
"False"
],
[
"97",
"False"
],
[
"32",
"False"
],
[
"40",
"False"
],
[
"18",
"False"
],
[
"14",
"False"
],
[
"90",
"False"
],
[
"39",
"False"
],
[
"1",
"True"
],
[
"57",
"False"
]
] | f_gold | TRIANGULAR_NUMBERS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class TRIANGULAR_NUMBERS{
static boolean f_gold ( int num ) {
if ( num < 0 ) return false ;
int sum = 0 ;
for ( int n = 1 ;
sum <= num ;
n ++ ) {
sum = sum + n ;
if ( sum == num ) return true ;
}
return false ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
a = ( n // 10 ) * 10
b = a + 10
return ( b if n - a > b - n else a )
| java | [
[
"31",
"30"
],
[
"78",
"80"
],
[
"19",
"20"
],
[
"36",
"40"
],
[
"77",
"80"
],
[
"94",
"90"
],
[
"86",
"90"
],
[
"16",
"20"
],
[
"95",
"90"
],
[
"2",
"0"
]
] | f_gold | ROUND_THE_GIVEN_NUMBER_TO_NEAREST_MULTIPLE_OF_10 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class ROUND_THE_GIVEN_NUMBER_TO_NEAREST_MULTIPLE_OF_10{
static int f_gold ( int n ) {
int a = ( n / 10 ) * 10 ;
int b = a + 10 ;
return ( n - a > b - n ) ? b : a ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
sum = 0
for i in range ( n ) :
sum += i * ( n - i )
return 2 * sum
| java | [
[
"63",
"83328"
],
[
"72",
"124392"
],
[
"28",
"7308"
],
[
"35",
"14280"
],
[
"6",
"70"
],
[
"70",
"114310"
],
[
"20",
"2660"
],
[
"8",
"168"
],
[
"8",
"168"
],
[
"35",
"14280"
]
] | f_gold | SUM_MATRIX_ELEMENT_ABSOLUTE_DIFFERENCE_ROW_COLUMN_NUMBERS_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SUM_MATRIX_ELEMENT_ABSOLUTE_DIFFERENCE_ROW_COLUMN_NUMBERS_1{
static int f_gold ( int n ) {
int sum = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) sum += i * ( n - i ) ;
return 2 * sum ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"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"
],
[
... | f_gold | NUMBER_JUMP_REQUIRED_GIVEN_LENGTH_REACH_POINT_FORM_D_0_ORIGIN_2D_PLANE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_JUMP_REQUIRED_GIVEN_LENGTH_REACH_POINT_FORM_D_0_ORIGIN_2D_PLANE{
static int f_gold ( int a , int b , int d ) {
int temp = a ;
a = Math . min ( a , b ) ;
b = Math . max ( temp , b ) ;
if ( d >= b ) return ( d + b - 1 ) / b ;
if ( d == 0 ) return 0 ;
if ( d == a ) return 1 ;
return 2 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( x , y ) :
if ( x == 1 ) :
return ( y == 1 )
pow = 1
while ( pow < y ) :
pow = pow * x
return ( pow == y )
| java | [
[
"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"
],
[
... | f_gold | CHECK_IF_A_NUMBER_IS_POWER_OF_ANOTHER_NUMBER | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_IF_A_NUMBER_IS_POWER_OF_ANOTHER_NUMBER{
public static boolean f_gold ( int x , int y ) {
if ( x == 1 ) return ( y == 1 ) ;
int pow = 1 ;
while ( pow < y ) pow = pow * x ;
return ( pow == y ) ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[[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... | f_gold | MINIMUM_FLIP_REQUIRED_MAKE_BINARY_MATRIX_SYMMETRIC_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MINIMUM_FLIP_REQUIRED_MAKE_BINARY_MATRIX_SYMMETRIC_1{
static int f_gold ( int mat [ ] [ ] , int n ) {
int flip = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) for ( int j = 0 ;
j < i ;
j ++ ) if ( mat [ i ] [ j ] != mat [ j ] [ i ] ) flip ++ ;
return flip ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
sum = 0
for i in range ( 1 , n + 1 ) :
sum = sum + ( 2 * i - 1 ) * ( 2 * i - 1 )
return sum
| java | [
[
"14",
"3654"
],
[
"61",
"302621"
],
[
"37",
"67525"
],
[
"86",
"848046"
],
[
"47",
"138415"
],
[
"98",
"1254890"
],
[
"70",
"457310"
],
[
"24",
"18424"
],
[
"76",
"585276"
],
[
"24",
"18424"
]
] | f_gold | SUM_SERIES_12_32_52_2N_12 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SUM_SERIES_12_32_52_2N_12{
static int f_gold ( int n ) {
int sum = 0 ;
for ( int i = 1 ;
i <= n ;
i ++ ) sum = sum + ( 2 * i - 1 ) * ( 2 * i - 1 ) ;
return sum ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( xp , yp ) :
xp [ 0 ] = xp [ 0 ] ^ yp [ 0 ]
yp [ 0 ] = xp [ 0 ] ^ yp [ 0 ]
xp [ 0 ] = xp [ 0 ] ^ yp [ 0 ]
| java | [
[
"[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... | f_gold | SWAP_TWO_NUMBERS_WITHOUT_USING_TEMPORARY_VARIABLE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
class SWAP_TWO_NUMBERS_WITHOUT_USING_TEMPORARY_VARIABLE{
static void f_gold ( int [ ] xp , int [ ] yp ) {
xp [ 0 ] = xp [ 0 ] ^ yp [ 0 ] ;
yp [ 0 ] = xp [ 0 ] ^ yp [ 0 ] ;
xp [ 0 ] = xp [ 0 ] ^ yp [ 0 ] ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ;
| java | [
[
"[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"
... | f_gold | CHECK_IF_ALL_THE_ELEMENTS_CAN_BE_MADE_OF_SAME_PARITY_BY_INVERTING_ADJACENT_ELEMENTS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_IF_ALL_THE_ELEMENTS_CAN_BE_MADE_OF_SAME_PARITY_BY_INVERTING_ADJACENT_ELEMENTS{
static boolean f_gold ( int [ ] a , int n ) {
int count_odd = 0 , count_even = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( ( a [ i ] & 1 ) == 1 ) count_odd ++ ;
else count_even ++ ;
}
if ( count_odd % 2 == 1 && count_even % 2 == 1 ) return false ;
else return true ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , b , c ) :
if ( a + b <= c ) or ( a + c <= b ) or ( b + c <= a ) :
return False
else :
return True
| java | [
[
"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"
],
[
"... | f_gold | CHECK_WHETHER_TRIANGLE_VALID_NOT_SIDES_GIVEN | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_WHETHER_TRIANGLE_VALID_NOT_SIDES_GIVEN{
public static int f_gold ( int a , int b , int c ) {
if ( a + b <= c || a + c <= b || b + c <= a ) return 0 ;
else return 1 ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"21",
"14307150"
],
[
"40",
"2054455634"
],
[
"83",
"868754947060"
],
[
"93",
"2290415157800"
],
[
"43",
"3679075400"
],
[
"98",
"3585446225075"
],
[
"35",
"708930508"
],
[
"86",
"1174992339235"
],
[
"76",
"411... | f_gold | TOTAL_NUMBER_OF_NON_DECREASING_NUMBERS_WITH_N_DIGITS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class TOTAL_NUMBER_OF_NON_DECREASING_NUMBERS_WITH_N_DIGITS{
static int f_gold ( int n ) {
int dp [ ] [ ] = new int [ 10 ] [ n + 1 ] ;
for ( int i = 0 ;
i < 10 ;
i ++ ) dp [ i ] [ 1 ] = 1 ;
for ( int digit = 0 ;
digit <= 9 ;
digit ++ ) {
for ( int len = 2 ;
len <= n ;
len ++ ) {
for ( int x = 0 ;
x <= digit ;
x ++ ) dp [ digit ] [ len ] += dp [ x ] [ len - 1 ] ;
}
}
int count = 0 ;
for ( int i = 0 ;
i < 10 ;
i ++ ) count += dp [ i ] [ n ] ;
return count ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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... | f_gold | MAXIMUM_PROFIT_BY_BUYING_AND_SELLING_A_SHARE_AT_MOST_TWICE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_PROFIT_BY_BUYING_AND_SELLING_A_SHARE_AT_MOST_TWICE{
static int f_gold ( int price [ ] , int n ) {
int profit [ ] = new int [ n ] ;
for ( int i = 0 ;
i < n ;
i ++ ) profit [ i ] = 0 ;
int max_price = price [ n - 1 ] ;
for ( int i = n - 2 ;
i >= 0 ;
i -- ) {
if ( price [ i ] > max_price ) max_price = price [ i ] ;
profit [ i ] = Math . max ( profit [ i + 1 ] , max_price - price [ i ] ) ;
}
int min_price = price [ 0 ] ;
for ( int i = 1 ;
i < n ;
i ++ ) {
if ( price [ i ] < min_price ) min_price = price [ i ] ;
profit [ i ] = Math . max ( profit [ i - 1 ] , profit [ i ] + ( price [ i ] - min_price ) ) ;
}
int result = profit [ n - 1 ] ;
return result ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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... | f_gold | MAXIMUM_POSSIBLE_SUM_WINDOW_ARRAY_ELEMENTS_WINDOW_ARRAY_UNIQUE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_POSSIBLE_SUM_WINDOW_ARRAY_ELEMENTS_WINDOW_ARRAY_UNIQUE{
static int f_gold ( int A [ ] , int B [ ] , int n ) {
Set < Integer > mp = new HashSet < Integer > ( ) ;
int result = 0 ;
int curr_sum = 0 , curr_begin = 0 ;
for ( int i = 0 ;
i < n ;
++ i ) {
while ( mp . contains ( A [ i ] ) ) {
mp . remove ( A [ curr_begin ] ) ;
curr_sum -= B [ curr_begin ] ;
curr_begin ++ ;
}
mp . add ( A [ i ] ) ;
curr_sum += B [ i ] ;
result = Integer . max ( result , curr_sum ) ;
}
return result ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[[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... | f_gold | MAXIMUM_WEIGHT_PATH_ENDING_ELEMENT_LAST_ROW_MATRIX | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_WEIGHT_PATH_ENDING_ELEMENT_LAST_ROW_MATRIX{
public static int f_gold ( int mat [ ] [ ] , int N ) {
int dp [ ] [ ] = new int [ N ] [ N ] ;
dp [ 0 ] [ 0 ] = mat [ 0 ] [ 0 ] ;
for ( int i = 1 ;
i < N ;
i ++ ) dp [ i ] [ 0 ] = mat [ i ] [ 0 ] + dp [ i - 1 ] [ 0 ] ;
for ( int i = 1 ;
i < N ;
i ++ ) for ( int j = 1 ;
j < i + 1 && j < N ;
j ++ ) dp [ i ] [ j ] = mat [ i ] [ j ] + Math . max ( dp [ i - 1 ] [ j - 1 ] , dp [ i - 1 ] [ j ] ) ;
int result = 0 ;
for ( int i = 0 ;
i < N ;
i ++ ) if ( result < dp [ N - 1 ] [ i ] ) result = dp [ N - 1 ] [ i ] ;
return result ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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, ... | f_gold | HOW_TO_CHECK_IF_A_GIVEN_ARRAY_REPRESENTS_A_BINARY_HEAP | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class HOW_TO_CHECK_IF_A_GIVEN_ARRAY_REPRESENTS_A_BINARY_HEAP{
static boolean f_gold ( int arr [ ] , int i , int n ) {
if ( i > ( n - 2 ) / 2 ) {
return true ;
}
if ( arr [ i ] >= arr [ 2 * i + 1 ] && arr [ i ] >= arr [ 2 * i + 2 ] && f_gold ( arr , 2 * i + 1 , n ) && f_gold ( arr , 2 * i + 2 , n ) ) {
return true ;
}
return false ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ]
| java | [
[
"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"
],
... | f_gold | COMPUTE_NCR_P_SET_1_INTRODUCTION_AND_DYNAMIC_PROGRAMMING_SOLUTION | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COMPUTE_NCR_P_SET_1_INTRODUCTION_AND_DYNAMIC_PROGRAMMING_SOLUTION{
static int f_gold ( int n , int r , int p ) {
int C [ ] = new int [ r + 1 ] ;
Arrays . fill ( C , 0 ) ;
C [ 0 ] = 1 ;
for ( int i = 1 ;
i <= n ;
i ++ ) {
for ( int j = Math . min ( i , r ) ;
j > 0 ;
j -- ) C [ j ] = ( C [ j ] + C [ j - 1 ] ) % p ;
}
return C [ r ] ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"89",
"9"
],
[
"11",
"3"
],
[
"14",
"3"
],
[
"92",
"9"
],
[
"76",
"8"
],
[
"63",
"7"
],
[
"51",
"7"
],
[
"16",
"4"
],
[
"83",
"9"
],
[
"66",
"8"
]
] | f_gold | SQUARE_ROOT_OF_AN_INTEGER | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SQUARE_ROOT_OF_AN_INTEGER{
static 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 ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"67",
"11132"
],
[
"48",
"4096"
],
[
"59",
"7600"
],
[
"22",
"392"
],
[
"14",
"100"
],
[
"66",
"10648"
],
[
"1",
"0"
],
[
"75",
"15625"
],
[
"58",
"7220"
],
[
"78",
"17576"
]
] | f_gold | MAXIMIZE_VOLUME_CUBOID_GIVEN_SUM_SIDES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMIZE_VOLUME_CUBOID_GIVEN_SUM_SIDES{
static int f_gold ( int s ) {
int maxvalue = 0 ;
for ( int i = 1 ;
i <= s - 2 ;
i ++ ) {
for ( int j = 1 ;
j <= s - 1 ;
j ++ ) {
int k = s - i - j ;
maxvalue = Math . max ( maxvalue , i * j * k ) ;
}
}
return maxvalue ;
}
| [] | |
null | [] | [] | python | code_translation | import math
def f_gold ( n ) :
return math.pow ( n , 2 )
| java | [
[
"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"
]
] | f_gold | PROGRAM_PRINT_SUM_GIVEN_NTH_TERM_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PROGRAM_PRINT_SUM_GIVEN_NTH_TERM_1{
static int f_gold ( long n ) {
return ( int ) Math . pow ( n , 2 ) ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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, ... | f_gold | REARRANGE_POSITIVE_AND_NEGATIVE_NUMBERS_PUBLISH | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
class REARRANGE_POSITIVE_AND_NEGATIVE_NUMBERS_PUBLISH{
static void f_gold ( int arr [ ] , int n ) {
int i = - 1 , temp = 0 ;
for ( int j = 0 ;
j < n ;
j ++ ) {
if ( arr [ j ] < 0 ) {
i ++ ;
temp = arr [ i ] ;
arr [ i ] = arr [ j ] ;
arr [ j ] = temp ;
}
}
int pos = i + 1 , neg = 0 ;
while ( pos < n && neg < pos && arr [ neg ] < 0 ) {
temp = arr [ neg ] ;
arr [ neg ] = arr [ pos ] ;
arr [ pos ] = temp ;
pos ++ ;
neg += 2 ;
}
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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, ... | f_gold | GIVEN_A_SORTED_AND_ROTATED_ARRAY_FIND_IF_THERE_IS_A_PAIR_WITH_A_GIVEN_SUM_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class GIVEN_A_SORTED_AND_ROTATED_ARRAY_FIND_IF_THERE_IS_A_PAIR_WITH_A_GIVEN_SUM_1{
static int 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 ;
int cnt = 0 ;
while ( l != r ) {
if ( arr [ l ] + arr [ r ] == x ) {
cnt ++ ;
if ( l == ( r - 1 + n ) % n ) {
return cnt ;
}
l = ( l + 1 ) % n ;
r = ( r - 1 + n ) % n ;
}
else if ( arr [ l ] + arr [ r ] < x ) l = ( l + 1 ) % n ;
else r = ( n + r - 1 ) % n ;
}
return cnt ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"90",
"279"
],
[
"56",
"159"
],
[
"43",
"112"
],
[
"31",
"80"
],
[
"77",
"231"
],
[
"35",
"88"
],
[
"43",
"112"
],
[
"66",
"197"
],
[
"15",
"32"
],
[
"95",
"304"
]
] | f_gold | COUNT_TOTAL_SET_BITS_IN_ALL_NUMBERS_FROM_1_TO_N | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_TOTAL_SET_BITS_IN_ALL_NUMBERS_FROM_1_TO_N{
static int f_gold ( int n ) {
int i = 0 ;
int ans = 0 ;
while ( ( 1 << i ) <= n ) {
boolean k = false ;
int change = 1 << i ;
for ( int j = 0 ;
j <= n ;
j ++ ) {
if ( k == true ) ans += 1 ;
else ans += 0 ;
if ( change == 1 ) {
k = ! k ;
change = 1 << i ;
}
else {
change -- ;
}
}
i ++ ;
}
return ans ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ) )
| java | [
[
"[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,... | f_gold | CHECK_EXIST_TWO_ELEMENTS_ARRAY_WHOSE_SUM_EQUAL_SUM_REST_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_EXIST_TWO_ELEMENTS_ARRAY_WHOSE_SUM_EQUAL_SUM_REST_ARRAY{
static boolean f_gold ( int arr [ ] , int n ) {
int sum = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
sum += arr [ i ] ;
}
if ( sum % 2 != 0 ) {
return false ;
}
sum = sum / 2 ;
HashSet < Integer > s = new HashSet < Integer > ( ) ;
for ( int i = 0 ;
i < n ;
i ++ ) {
int val = sum - arr [ i ] ;
if ( s . contains ( val ) && val == ( int ) s . toArray ( ) [ s . size ( ) - 1 ] ) {
System . out . printf ( "Pair elements are %d and %d\n" , arr [ i ] , val ) ;
return true ;
}
s . add ( arr [ i ] ) ;
}
return false ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ] )
| java | [
[
"'daBcd', 'ABC'",
"True"
],
[
"'417514', '9'",
"False"
],
[
"'010000', '1111011010'",
"False"
],
[
"'ZcKYguiMrdyn', 'iz'",
"False"
],
[
"'argaju', 'RAJ'",
"True"
],
[
"'1110101101', '110101001'",
"False"
],
[
"'ySOCoSaygi', 'aRhxkYqh'",
... | f_gold | CHECK_POSSIBLE_TRANSFORM_ONE_STRING_ANOTHER | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_POSSIBLE_TRANSFORM_ONE_STRING_ANOTHER{
static boolean f_gold ( String s1 , String s2 ) {
int n = s1 . length ( ) ;
int m = s2 . length ( ) ;
boolean dp [ ] [ ] = new boolean [ n + 1 ] [ m + 1 ] ;
for ( int i = 0 ;
i <= n ;
i ++ ) {
for ( int j = 0 ;
j <= m ;
j ++ ) {
dp [ i ] [ j ] = false ;
}
}
dp [ 0 ] [ 0 ] = true ;
for ( int i = 0 ;
i < s1 . length ( ) ;
i ++ ) {
for ( int j = 0 ;
j <= s2 . length ( ) ;
j ++ ) {
if ( dp [ i ] [ j ] ) {
if ( j < s2 . length ( ) && ( Character . toUpperCase ( s1 . charAt ( i ) ) == s2 . charAt ( j ) ) ) dp [ i + 1 ] [ j + 1 ] = true ;
if ( ! Character . isUpperCase ( s1 . charAt ( i ) ) ) dp [ i + 1 ] [ j ] = true ;
}
}
}
return ( dp [ n ] [ m ] ) ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"71",
"0"
],
[
"78",
"112"
],
[
"39",
"0"
],
[
"36",
"78"
],
[
"49",
"0"
],
[
"17",
"0"
],
[
"53",
"0"
],
[
"66",
"96"
],
[
"92",
"144"
],
[
"71",
"0"
]
] | f_gold | FIND_SUM_EVEN_FACTORS_NUMBER | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_SUM_EVEN_FACTORS_NUMBER{
public static int f_gold ( int n ) {
if ( n % 2 != 0 ) return 0 ;
int res = 1 ;
for ( int i = 2 ;
i <= Math . sqrt ( n ) ;
i ++ ) {
int count = 0 , curr_sum = 1 ;
int curr_term = 1 ;
while ( n % i == 0 ) {
count ++ ;
n = n / i ;
if ( i == 2 && count == 1 ) curr_sum = 0 ;
curr_term *= i ;
curr_sum += curr_term ;
}
res *= curr_sum ;
}
if ( n >= 2 ) res *= ( 1 + n ) ;
return res ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | import math
def f_gold ( side ) :
volume = ( side ** 3 / ( 6 * math.sqrt ( 2 ) ) )
return round ( volume , 2 )
| java | [
[
"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",
"... | f_gold | CALCULATE_AREA_TETRAHEDRON | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CALCULATE_AREA_TETRAHEDRON{
static double f_gold ( int side ) {
double volume = ( Math . pow ( side , 3 ) / ( 6 * Math . sqrt ( 2 ) ) ) ;
return volume ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"15",
"-1"
],
[
"36",
"3"
],
[
"39",
"-1"
],
[
"43",
"-1"
],
[
"75",
"-1"
],
[
"49",
"-1"
],
[
"56",
"-1"
],
[
"14",
"-1"
],
[
"62",
"-1"
],
[
"97",
"-1"
]
] | f_gold | SQUARED_TRIANGULAR_NUMBER_SUM_CUBES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SQUARED_TRIANGULAR_NUMBER_SUM_CUBES{
static int f_gold ( int s ) {
int sum = 0 ;
for ( int n = 1 ;
sum < s ;
n ++ ) {
sum += n * n * n ;
if ( sum == s ) return n ;
}
return - 1 ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"[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"
],
[
... | f_gold | FREQUENT_ELEMENT_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FREQUENT_ELEMENT_ARRAY{
static int f_gold ( int arr [ ] , int n ) {
Arrays . sort ( arr ) ;
int max_count = 1 , res = arr [ 0 ] ;
int curr_count = 1 ;
for ( int i = 1 ;
i < n ;
i ++ ) {
if ( arr [ i ] == arr [ i - 1 ] ) curr_count ++ ;
else {
if ( curr_count > max_count ) {
max_count = curr_count ;
res = arr [ i - 1 ] ;
}
curr_count = 1 ;
}
}
if ( curr_count > max_count ) {
max_count = curr_count ;
res = arr [ n - 1 ] ;
}
return res ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
return ( 1 << ( n - 1 ) )
| java | [
[
"56",
"36028797018963968"
],
[
"28",
"134217728"
],
[
"4",
"8"
],
[
"24",
"8388608"
],
[
"72",
"2361183241434822606848"
],
[
"30",
"536870912"
],
[
"48",
"140737488355328"
],
[
"32",
"2147483648"
],
[
"13",
"40... | f_gold | FIND_SUM_EVEN_INDEX_BINOMIAL_COEFFICIENTS_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_SUM_EVEN_INDEX_BINOMIAL_COEFFICIENTS_1{
static int f_gold ( int n ) {
return ( 1 << ( n - 1 ) ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( l , w ) :
return ( 2 * ( l + w ) )
| java | [
[
"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",
... | f_gold | PYTHON_PROGRAM_FIND_PERIMETER_CIRCUMFERENCE_SQUARE_RECTANGLE_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PYTHON_PROGRAM_FIND_PERIMETER_CIRCUMFERENCE_SQUARE_RECTANGLE_1{
static int f_gold ( int l , int w ) {
return ( 2 * ( l + w ) ) ;
}
| [] | |
null | [] | [] | python | code_translation | 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
| java | [
[
"'fbfHTjE'",
"'f'"
],
[
"'09285256323'",
"'2'"
],
[
"'0011000101110'",
"'001'"
],
[
"'ue JkVZTt'",
"''"
],
[
"'48387612426300'",
"'4'"
],
[
"'010'",
"'0'"
],
[
"'ddRrUz'",
"'d'"
],
[
"'1049162633793'",
"'1'"
],
[
"... | f_gold | LONGEST_REPEATING_AND_NON_OVERLAPPING_SUBSTRING | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class LONGEST_REPEATING_AND_NON_OVERLAPPING_SUBSTRING{
static String f_gold ( String str ) {
int n = str . length ( ) ;
int LCSRe [ ] [ ] = new int [ n + 1 ] [ n + 1 ] ;
String res = "" ;
int res_length = 0 ;
int i , index = 0 ;
for ( i = 1 ;
i <= n ;
i ++ ) {
for ( int j = i + 1 ;
j <= n ;
j ++ ) {
if ( str . charAt ( i - 1 ) == str . charAt ( j - 1 ) && 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 = Math . max ( i , index ) ;
}
}
else {
LCSRe [ i ] [ j ] = 0 ;
}
}
}
if ( res_length > 0 ) {
for ( i = index - res_length + 1 ;
i <= index ;
i ++ ) {
res += str . charAt ( i - 1 ) ;
}
}
return res ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ;
| java | [
[
"18",
"547810"
],
[
"66",
"21181622535989461745"
],
[
"73",
"2029839041161556077001"
],
[
"70",
"287240945935564706557"
],
[
"26",
"100719775"
],
[
"41",
"1774846161206"
],
[
"20",
"2017126"
],
[
"25",
"52479500"
],
[
... | f_gold | NUMBER_N_DIGIT_STEPPING_NUMBERS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_N_DIGIT_STEPPING_NUMBERS{
static long f_gold ( int n ) {
int dp [ ] [ ] = new int [ 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 sum = 0 ;
for ( int j = 1 ;
j <= 9 ;
j ++ ) sum += dp [ n ] [ j ] ;
return sum ;
}
| [] | |
null | [] | [] | python | code_translation | 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 ) )
| java | [
[
"'geeksmanishgeeks', 'geeks'",
"True"
],
[
"'shreyadhatwalia', 'abc'",
"False"
],
[
"'10000100', '100'",
"True"
],
[
"'abaa', 'a'",
"True"
],
[
"'30645530', '30'",
"True"
],
[
"'0000011011001', '001'",
"False"
],
[
"'dkqEd', 'd'",
"Tr... | f_gold | PROGRAM_FIND_STRING_START_END_GEEKS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PROGRAM_FIND_STRING_START_END_GEEKS{
static boolean f_gold ( String str , String corner ) {
int n = str . length ( ) ;
int cl = corner . length ( ) ;
if ( n < cl ) return false ;
return ( str . substring ( 0 , cl ) . equals ( corner ) && str . substring ( n - cl , n ) . equals ( corner ) ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( str ) :
n = len ( str )
for i in range ( n ) :
if ( str [ i ] != 'a' ) :
break
if ( i * 2 != n ) :
return False
for j in range ( i , n ) :
if ( str [ j ] != 'b' ) :
return False
return True
| java | [
[
"'ba'",
"False"
],
[
"'aabb'",
"True"
],
[
"'abab'",
"False"
],
[
"'aaabb'",
"False"
],
[
"'aabbb'",
"False"
],
[
"'abaabbaa'",
"False"
],
[
"'abaababb'",
"False"
],
[
"'bbaa'",
"False"
],
[
"'11001000'",
"Fals... | f_gold | CHECK_STRING_FOLLOWS_ANBN_PATTERN_NOT | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_STRING_FOLLOWS_ANBN_PATTERN_NOT{
public static boolean f_gold ( String s ) {
int l = s . length ( ) ;
if ( l % 2 == 1 ) {
return false ;
}
int i = 0 ;
int j = l - 1 ;
while ( i < j ) {
if ( s . charAt ( i ) != 'a' || s . charAt ( j ) != 'b' ) {
return false ;
}
i ++ ;
j -- ;
}
return true ;
}
| [] | |
null | [] | [] | python | code_translation | import math
def f_gold ( arr , n ) :
min_prefix_sum = 0
res = - math.inf
prefix_sum = [ ]
prefix_sum.append ( arr [ 0 ] )
for i in range ( 1 , n ) :
prefix_sum.append ( prefix_sum [ i - 1 ] + arr [ i ] )
for i in range ( n ) :
res = max ( res , prefix_sum [ i ] - min_prefix_sum )
min_prefix_sum = min ( min_prefix_sum , prefix_sum [ i ] )
return res
| java | [
[
"[8, 9, 11, 17, 18, 19, 23, 24, 27, 30, 31, 31, 35, 44, 46, 47, 49, 51, 55, 58, 59, 61, 65, 67, 71, 71, 71, 71, 78, 78, 82, 91, 98], 20",
"633"
],
[
"[-82, -28, -66, -52, -36, 36, -88, 52, -62, 46, 42, 26, -60, 18, -52, 38, 94, -68, 44, -94, 14, 36, -70], 15",
"114"
],
[
"[0, 0, 0, 0, ... | f_gold | MAXIMUM_SUBARRAY_SUM_USING_PREFIX_SUM | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_SUBARRAY_SUM_USING_PREFIX_SUM{
static int f_gold ( int arr [ ] , int n ) {
int min_prefix_sum = 0 ;
int res = Integer . MIN_VALUE ;
int prefix_sum [ ] = new int [ n ] ;
prefix_sum [ 0 ] = arr [ 0 ] ;
for ( int i = 1 ;
i < n ;
i ++ ) prefix_sum [ i ] = prefix_sum [ i - 1 ] + arr [ i ] ;
for ( int i = 0 ;
i < n ;
i ++ ) {
res = Math . max ( res , prefix_sum [ i ] - min_prefix_sum ) ;
min_prefix_sum = Math . min ( min_prefix_sum , prefix_sum [ i ] ) ;
}
return res ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
mp = dict ( )
for i in range ( n ) :
if arr [ i ] in mp.keys ( ) :
mp [ arr [ i ] ] += 1
else :
mp [ arr [ i ] ] = 1
ans = 0
for it in mp :
count = mp [ it ]
ans += ( count * ( count - 1 ) ) // 2
return ans
| java | [
[
"[5, 11, 18, 22, 40, 46, 50, 51, 53, 55, 64, 67, 73, 78, 86], 14",
"0"
],
[
"[14, -98, 98, 58, -82, 90, -80, -56, -30, -36, -56, -30, -58, 68, 72, -76, 38, -90, -72, 4, -32, 32, -28, 2, 12, -72, 54, 2, 0, -74, 8, 12, 46, 72, -84, -66, 70, 18, 26, 72, -26, 44, -8, 20, -32, -56, 28], 24",
"2"
... | f_gold | COUNT_INDEX_PAIRS_EQUAL_ELEMENTS_ARRAY_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_INDEX_PAIRS_EQUAL_ELEMENTS_ARRAY_1{
public static int f_gold ( int arr [ ] , int n ) {
HashMap < Integer , Integer > hm = new HashMap < > ( ) ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( hm . containsKey ( arr [ i ] ) ) hm . put ( arr [ i ] , hm . get ( arr [ i ] ) + 1 ) ;
else hm . put ( arr [ i ] , 1 ) ;
}
int ans = 0 ;
for ( Map . Entry < Integer , Integer > it : hm . entrySet ( ) ) {
int count = it . getValue ( ) ;
ans += ( count * ( count - 1 ) ) / 2 ;
}
return ans ;
}
| [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.