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 ( n ) :
answer = [ None ] * ( n + 1 ) ;
answer [ 0 ] = 1 ;
i = 1
while i <= n :
answer [ i ] = answer [ i - 1 ] * 3 + 2 ;
i = i + 1
return answer [ n ] ;
| java | [
[
"33",
"11118121133111045"
],
[
"72",
"45056799089878348823680295749545281"
],
[
"81",
"886852976486075539896499261238299785605"
],
[
"93",
"471310032676736470998135463891743276362238245"
],
[
"8",
"13121"
],
[
"76",
"36496007262801462547181039557... | f_gold | NUMBER_TRIANGLES_N_MOVES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_TRIANGLES_N_MOVES{
public static int f_gold ( int n ) {
int [ ] answer = new int [ n + 1 ] ;
answer [ 0 ] = 1 ;
for ( int i = 1 ;
i <= n ;
i ++ ) answer [ i ] = answer [ i - 1 ] * 3 + 2 ;
return answer [ n ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( price , n , k ) :
profit = [ [ 0 for i in range ( n + 1 ) ] for j in range ( k + 1 ) ]
for i in range ( 1 , k + 1 ) :
prevDiff = float ( '-inf' )
for j in range ( 1 , n ) :
prevDiff = max ( prevDiff , profit [ i - 1 ] [ j - 1 ] - price [ j - 1 ] )
profit [ i ] [ j ] = max ( profit [ i ] [ j - 1 ] , price [ j ] + prevDiff )
return profit [ k ] [ n - 1 ]
| java | [
[
"[3, 6, 16, 16, 19, 37, 47, 49, 74, 77, 86, 96], 6, 6",
"34"
],
[
"[-6, -70, -26, 78, 98, -72, 48, -94, -38, 52, -50, 58, 84, 16, -74, 32, -44, -50, 68, -48, 28, 94, -26, -96, -42, 96, -24, 42, -70, 10, -16, -32, 98, 38, -2, 26, -26, -78, 44, -72, -56, -22], 31, 32",
"1272"
],
[
"[0, 0... | f_gold | MAXIMUM_PROFIT_BY_BUYING_AND_SELLING_A_SHARE_AT_MOST_K_TIMES_1 | 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_K_TIMES_1{
static int f_gold ( int price [ ] , int n , int k ) {
int profit [ ] [ ] = new int [ k + 1 ] [ n + 1 ] ;
for ( int i = 0 ;
i <= k ;
i ++ ) profit [ i ] [ 0 ] = 0 ;
for ( int j = 0 ;
j <= n ;
j ++ ) profit [ 0 ] [ j ] = 0 ;
for ( int i = 1 ;
i <= k ;
i ++ ) {
int prevDiff = Integer . MIN_VALUE ;
for ( int j = 1 ;
j < n ;
j ++ ) {
prevDiff = Math . max ( prevDiff , profit [ i - 1 ] [ j - 1 ] - price [ j - 1 ] ) ;
profit [ i ] [ j ] = Math . max ( profit [ i ] [ j - 1 ] , price [ j ] + prevDiff ) ;
}
}
return profit [ k ] [ n - 1 ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold(arr, n):
vis = dict()
for i in range(n):
vis[arr[i]] = 1
k = len(vis)
vid = dict()
ans = 0
right = 0
window = 0
for left in range(n):
while (right < n and window < k):
if arr[right] in vid.keys():
vid[arr[right]] += 1
else:
vid[arr[right]] = 1
if (vid[arr[right]] == 1):
window += 1
right += 1
if (window == k):
ans += (n - right + 1)
vid[arr[left]] -= 1
if (vid[arr[left]] == 0):
window -= 1
return ans
| java | [
[
"[13, 39, 49, 52, 53, 69, 72, 79, 83, 96], 5",
"1"
],
[
"[-98, -98, 22, -10, -28, 0, 56, 72, 36, 88, 96, 22, 90, 74, -60, -64, 0, 2, -42, 0, 94, -82, -74], 20",
"4"
],
[
"[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], 26",
"160"
],
[
... | f_gold | COUNT_SUBARRAYS_TOTAL_DISTINCT_ELEMENTS_ORIGINAL_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_SUBARRAYS_TOTAL_DISTINCT_ELEMENTS_ORIGINAL_ARRAY{
static int f_gold ( int arr [ ] , int n ) {
HashMap < Integer , Integer > vis = new HashMap < Integer , Integer > ( ) {
@ Override public Integer get ( Object key ) {
if ( ! containsKey ( key ) ) return 0 ;
return super . get ( key ) ;
}
};
for ( int i = 0 ;
i < n ;
++ i ) vis . put ( arr [ i ] , 1 ) ;
int k = vis . size ( ) ;
vis . clear ( ) ;
int ans = 0 , right = 0 , window = 0 ;
for ( int left = 0 ;
left < n ;
++ left ) {
while ( right < n && window < k ) {
vis . put ( arr [ right ] , vis . get ( arr [ right ] ) + 1 ) ;
if ( vis . get ( arr [ right ] ) == 1 ) ++ window ;
++ right ;
}
if ( window == k ) ans += ( n - right + 1 ) ;
vis . put ( arr [ left ] , vis . get ( arr [ left ] ) - 1 ) ;
if ( vis . get ( arr [ left ] ) == 0 ) -- window ;
}
return ans ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
return sum ( arr ) - ( ( ( n - 1 ) * n ) // 2 )
| java | [
[
"[4, 8, 27, 34, 39, 42, 43, 54, 72], 5",
"313"
],
[
"[-38, -66, -38, -48, -96, 74, -32, -62, -34, -32, -88, -12, -8, -4], 9",
"-520"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1], 8",
"-23"
],
[
"[88, 86, 23, 81, 76, 16, 94, 64, 59, 50, 71, 62, 10, 89, 73, 64, 65, ... | f_gold | FIND_REPETITIVE_ELEMENT_1_N_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_REPETITIVE_ELEMENT_1_N_1{
static int f_gold ( int [ ] arr , int n ) {
int sum = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) sum += arr [ i ] ;
return sum - ( ( ( n - 1 ) * n ) / 2 ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold(m, n):
if m < n:
return 0
if n == 0:
return 1
res = (f_gold(m - 1, n) + f_gold(m // 2, n - 1))
return res
| java | [
[
"38, 34",
"0"
],
[
"39, 29",
"0"
],
[
"24, 99",
"0"
],
[
"90, 23",
"0"
],
[
"44, 2",
"484"
],
[
"49, 70",
"0"
],
[
"58, 84",
"0"
],
[
"97, 34",
"0"
],
[
"99, 72",
"0"
],
[
"19, 67",
"0"
]
] | f_gold | SEQUENCES_GIVEN_LENGTH_EVERY_ELEMENT_EQUAL_TWICE_PREVIOUS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SEQUENCES_GIVEN_LENGTH_EVERY_ELEMENT_EQUAL_TWICE_PREVIOUS{
static int f_gold ( int m , int n ) {
if ( m < n ) return 0 ;
if ( n == 0 ) return 1 ;
return f_gold ( m - 1 , n ) + f_gold ( m / 2 , n - 1 ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
s = [ ]
first = 0
second = 0
for i in range ( n ) :
if arr [ i ] not in s :
s.append ( arr [ i ] )
continue
if ( arr [ i ] > first ) :
second = first
first = arr [ i ]
elif ( arr [ i ] > second ) :
second = arr [ i ]
return ( first * second )
| java | [
[
"[4, 6, 7, 8, 12, 13, 14, 15, 18, 18, 19, 19, 26, 26, 32, 32, 33, 34, 34, 36, 41, 43, 47, 47, 51, 51, 52, 53, 55, 56, 57, 60, 61, 71, 74, 75, 76, 77, 79, 87, 87, 87, 90, 95, 98, 99], 37",
"2397"
],
[
"[-64, -72, 6, -62, 54, 14, 28, 60, -96, 14, -32, -2, 80, 8, -56, 68, 86, 64, 86, -12, 82], 12",
... | f_gold | MAXIMUM_AREA_RECTANGLE_PICKING_FOUR_SIDES_ARRAY_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_AREA_RECTANGLE_PICKING_FOUR_SIDES_ARRAY_1{
static int f_gold ( int arr [ ] , int n ) {
Set < Integer > s = new HashSet < > ( ) ;
int first = 0 , second = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( ! s . contains ( arr [ i ] ) ) {
s . add ( arr [ i ] ) ;
continue ;
}
if ( arr [ i ] > first ) {
second = first ;
first = arr [ i ] ;
}
else if ( arr [ i ] > second ) second = arr [ i ] ;
}
return ( first * second ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( N , insrt , remov , cpy ) :
if N == 0 :
return 0
if N == 1 :
return insrt
dp = [ 0 ] * ( N + 1 )
for i in range ( 1 , N + 1 ) :
if i % 2 == 0 :
dp [ i ] = min ( dp [ i - 1 ] + insrt , dp [ i // 2 ] + cpy )
else :
dp [ i ] = min ( dp [ i - 1 ] + insrt , dp [ ( i + 1 ) // 2 ] + cpy + remov )
return dp [ N ]
| java | [
[
"59, 75, 12, 45",
"351"
],
[
"66, 68, 32, 41",
"382"
],
[
"98, 55, 69, 5",
"195"
],
[
"63, 4, 41, 12",
"76"
],
[
"99, 37, 98, 55",
"460"
],
[
"45, 28, 59, 7",
"147"
],
[
"60, 53, 40, 52",
"405"
],
[
"11, 96, 50, 50",
"392"... | f_gold | MINIMUM_TIME_WRITE_CHARACTERS_USING_INSERT_DELETE_COPY_OPERATION | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MINIMUM_TIME_WRITE_CHARACTERS_USING_INSERT_DELETE_COPY_OPERATION{
static int f_gold ( int N , int insert , int remove , int copy ) {
if ( N == 0 ) return 0 ;
if ( N == 1 ) return insert ;
int dp [ ] = new int [ N + 1 ] ;
for ( int i = 1 ;
i <= N ;
i ++ ) {
if ( i % 2 == 0 ) dp [ i ] = Math . min ( dp [ i - 1 ] + insert , dp [ i / 2 ] + copy ) ;
else dp [ i ] = Math . min ( dp [ i - 1 ] + insert , dp [ ( i + 1 ) / 2 ] + copy + remove ) ;
}
return dp [ N ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , N ) :
if N < 3 :
return False
arr.sort ( )
for i in range ( N - 2 ) :
if arr [ i ] + arr [ i + 1 ] > arr [ i + 2 ] :
return True
| java | [
[
"[2, 6, 8, 10, 14, 15, 16, 19, 21, 26, 26, 26, 28, 29, 30, 33, 33, 35, 36, 36, 41, 44, 45, 45, 45, 49, 51, 54, 57, 59, 61, 64, 68, 70, 70, 72, 73, 74, 76, 78, 87, 89, 89, 91, 92, 93, 94, 95, 97], 25",
"True"
],
[
"[-96, -94, -90, -86, -78, -78, -74, -72, -64, -64, -58, -56, -50, -46, -44, -36, -26... | f_gold | POSSIBLE_FORM_TRIANGLE_ARRAY_VALUES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class POSSIBLE_FORM_TRIANGLE_ARRAY_VALUES{
static boolean f_gold ( int [ ] arr , int N ) {
if ( N < 3 ) return false ;
Arrays . sort ( arr ) ;
for ( int i = 0 ;
i < N - 2 ;
i ++ ) if ( arr [ i ] + arr [ i + 1 ] > arr [ i + 2 ] ) return true ;
return false ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold(s):
n = len(s)
s1 = ""
s1 = s1 + s[0].lower()
i = 1
while i < n:
if (s[i] == ' ' and i <= n):
s1 = s1 + " " + (s[i + 1]).lower()
i = i + 1
else:
s1 = s1 + (s[i]).upper()
i = i + 1
return s1
| java | [
[
"'TEYndweqZA'",
"'tEYNDWEQZA'"
],
[
"'01865'",
"'01865'"
],
[
"'11001100'",
"'11001100'"
],
[
"'CzwznJmQet'",
"'cZWZNJMQET'"
],
[
"'318305446'",
"'318305446'"
],
[
"'0000001111110'",
"'0000001111110'"
],
[
"'yzT'",
"'yZT'"
],
[
... | f_gold | GOOGLE_CASE_GIVEN_SENTENCE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class GOOGLE_CASE_GIVEN_SENTENCE{
static String f_gold ( String s ) {
int n = s . length ( ) ;
String s1 = "" ;
s1 = s1 + Character . toLowerCase ( s . charAt ( 0 ) ) ;
for ( int i = 1 ;
i < n ;
i ++ ) {
if ( s . charAt ( i ) == ' ' && i < n ) {
s1 = s1 + " " + Character . toLowerCase ( s . charAt ( i + 1 ) ) ;
i ++ ;
}
else s1 = s1 + Character . toUpperCase ( s . charAt ( i ) ) ;
}
return s1 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
num = n ;
dec_value = 0 ;
base1 = 1 ;
len1 = len ( num ) ;
for i in range ( len1 - 1 , - 1 , - 1 ) :
if ( num [ i ] == '1' ) :
dec_value += base1 ;
base1 = base1 * 2 ;
return dec_value ;
| java | [
[
"'uEmIAgF'",
"0"
],
[
"'753310137'",
"20"
],
[
"'010011010'",
"154"
],
[
"'kNi'",
"0"
],
[
"'04562016903312'",
"130"
],
[
"'000111101'",
"61"
],
[
"'bk'",
"0"
],
[
"'9'",
"0"
],
[
"'1'",
"1"
],
[
"'XxT ... | f_gold | PROGRAM_BINARY_DECIMAL_CONVERSION_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PROGRAM_BINARY_DECIMAL_CONVERSION_1{
static int f_gold ( String n ) {
String num = n ;
int dec_value = 0 ;
int base = 1 ;
int len = num . length ( ) ;
for ( int i = len - 1 ;
i >= 0 ;
i -- ) {
if ( num . charAt ( i ) == '1' ) dec_value += base ;
base = base * 2 ;
}
return dec_value ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , n ) :
return ( ( n - 1 ) * min ( a ) )
| java | [
[
"[1, 2, 3, 4, 7, 8, 10, 10, 16, 20, 22, 22, 23, 23, 23, 27, 29, 32, 35, 39, 41, 46, 51, 53, 54, 59, 59, 60, 61, 69, 70, 70, 79, 79, 81, 84, 90, 91, 98], 25",
"24"
],
[
"[-6, 10], 1",
"0"
],
[
"[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 15",
"0"
],
[
"[20, 61, 9... | f_gold | MINIMUM_COST_MAKE_ARRAY_SIZE_1_REMOVING_LARGER_PAIRS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MINIMUM_COST_MAKE_ARRAY_SIZE_1_REMOVING_LARGER_PAIRS{
static int f_gold ( int [ ] a , int n ) {
int min = a [ 0 ] ;
for ( int i = 1 ;
i < a . length ;
i ++ ) {
if ( a [ i ] < min ) min = a [ i ] ;
}
return ( n - 1 ) * min ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , b , mod ) :
res = 0 ;
a = a % mod ;
while ( b ) :
if ( b & 1 ) :
res = ( res + a ) % mod ;
a = ( 2 * a ) % mod ;
b >>= 1 ;
return res ;
| java | [
[
"60, 24, 58",
"48"
],
[
"46, 43, 29",
"6"
],
[
"4, 50, 71",
"58"
],
[
"67, 1, 66",
"1"
],
[
"93, 35, 73",
"43"
],
[
"89, 97, 8",
"1"
],
[
"8, 78, 55",
"19"
],
[
"53, 73, 22",
"19"
],
[
"96, 92, 83",
"34"
],
... | f_gold | MULTIPLY_LARGE_INTEGERS_UNDER_LARGE_MODULO | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MULTIPLY_LARGE_INTEGERS_UNDER_LARGE_MODULO{
static long f_gold ( long a , long b , long mod ) {
long res = 0 ;
a %= mod ;
while ( b > 0 ) {
if ( ( b & 1 ) > 0 ) {
res = ( res + a ) % mod ;
}
a = ( 2 * a ) % mod ;
b >>= 1 ;
}
return res ;
}
| [] | |
null | [] | [] | python | code_translation | import math
def f_gold ( C , l ) :
if ( l >= C ) : return C
eq_root = ( math.sqrt ( 1 + 8 * ( C - l ) ) - 1 ) / 2
return math.ceil ( eq_root ) + l
| java | [
[
"91, 29",
"40"
],
[
"99, 55",
"64"
],
[
"11, 56",
"11"
],
[
"23, 56",
"23"
],
[
"12, 97",
"12"
],
[
"1, 64",
"1"
],
[
"18, 5",
"10"
],
[
"14, 37",
"14"
],
[
"13, 55",
"13"
],
[
"36, 99",
"36"
]
] | f_gold | NUMBER_DAYS_TANK_WILL_BECOME_EMPTY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_DAYS_TANK_WILL_BECOME_EMPTY{
static int f_gold ( int C , int l ) {
if ( l >= C ) return C ;
double eq_root = ( Math . sqrt ( 1 + 8 * ( C - l ) ) - 1 ) / 2 ;
return ( int ) ( Math . ceil ( eq_root ) + l ) ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | def f_gold ( process , need ) :
minResources = 0
minResources = process * ( need - 1 ) + 1
return minResources
| java | [
[
"38, 37",
"1369"
],
[
"82, 3",
"165"
],
[
"2, 26",
"51"
],
[
"38, 72",
"2699"
],
[
"31, 85",
"2605"
],
[
"80, 73",
"5761"
],
[
"11, 9",
"89"
],
[
"2, 31",
"61"
],
[
"26, 59",
"1509"
],
[
"37, 67",
"... | f_gold | PROGRAM_FOR_DEADLOCK_FREE_CONDITION_IN_OPERATING_SYSTEM | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PROGRAM_FOR_DEADLOCK_FREE_CONDITION_IN_OPERATING_SYSTEM{
static int f_gold ( int process , int need ) {
int minResources = 0 ;
minResources = process * ( need - 1 ) + 1 ;
return minResources ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
um = { i : 0 for i in range ( 10 ) }
sum = 0
maxLen = 0
for i in range ( n ) :
if arr [ i ] == 0 :
sum += - 1
else :
sum += 1
if ( sum == 1 ) :
maxLen = i + 1
elif ( sum not in um ) :
um [ sum ] = i
if ( ( sum - 1 ) in um ) :
if ( maxLen < ( i - um [ sum - 1 ] ) ) :
maxLen = i - um [ sum - 1 ]
return maxLen
| java | [
[
"[6, 10, 31, 35], 2",
"1"
],
[
"[4, 88, -72, 28, -54, 32, -34], 6",
"5"
],
[
"[0, 0, 0, 1, 1, 1, 1, 1, 1], 4",
"1"
],
[
"[39, 22, 15, 10, 34, 87, 46, 83, 74, 77, 61, 90, 43, 67, 64, 72, 92, 52, 68, 53, 67, 32, 82, 76, 76, 47, 74, 47, 8, 80, 85, 58, 75], 26",
"9"
],
... | f_gold | LONGEST_SUBARRAY_COUNT_1S_ONE_COUNT_0S | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class LONGEST_SUBARRAY_COUNT_1S_ONE_COUNT_0S{
static int f_gold ( int arr [ ] , int n ) {
HashMap < Integer , Integer > um = new HashMap < Integer , Integer > ( ) ;
int sum = 0 , maxLen = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
sum += arr [ i ] == 0 ? - 1 : 1 ;
if ( sum == 1 ) maxLen = i + 1 ;
else if ( ! um . containsKey ( sum ) ) um . put ( sum , i ) ;
if ( um . containsKey ( sum - 1 ) ) {
if ( maxLen < ( i - um . get ( sum - 1 ) ) ) maxLen = i - um . get ( sum - 1 ) ;
}
}
return maxLen ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
count = 0 ;
if ( n and not ( n & ( n - 1 ) ) ) :
return n
while ( n != 0 ) :
n >>= 1
count += 1
return 1 << count ;
| java | [
[
"74",
"128"
],
[
"70",
"128"
],
[
"85",
"128"
],
[
"78",
"128"
],
[
"71",
"128"
],
[
"32",
"32"
],
[
"97",
"128"
],
[
"90",
"128"
],
[
"64",
"64"
],
[
"48",
"64"
]
] | f_gold | NEXT_POWER_OF_2 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NEXT_POWER_OF_2{
static int f_gold ( int n ) {
int count = 0 ;
if ( n > 0 && ( n & ( n - 1 ) ) == 0 ) return n ;
while ( n != 0 ) {
n >>= 1 ;
count += 1 ;
}
return 1 << count ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( str ) :
res = ord ( str [ 0 ] ) - 48
for i in range ( 1 , len ( str ) ) :
if ( str [ i ] == '0' or str [ i ] == '1' or res < 2 ) :
res += ord ( str [ i ] ) - 48
else :
res *= ord ( str [ i ] ) - 48
return res
| java | [
[
"'pR'",
"2176"
],
[
"'9518'",
"368"
],
[
"'1'",
"1"
],
[
"'nNMCIXUCpRMmvO'",
"6018195974788838400000"
],
[
"'3170487'",
"6272"
],
[
"'0100101010'",
"4"
],
[
"'Z rONcUqWb'",
"-303"
],
[
"'00419297'",
"5670"
],
[
"'0... | f_gold | CALCULATE_MAXIMUM_VALUE_USING_SIGN_TWO_NUMBERS_STRING | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CALCULATE_MAXIMUM_VALUE_USING_SIGN_TWO_NUMBERS_STRING{
static int f_gold ( String str ) {
int res = str . charAt ( 0 ) - '0' ;
for ( int i = 1 ;
i < str . length ( ) ;
i ++ ) {
if ( str . charAt ( i ) == '0' || str . charAt ( i ) == '1' || res < 2 ) res += ( str . charAt ( i ) - '0' ) ;
else res *= ( str . charAt ( i ) - '0' ) ;
}
return res ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
result = 0
Hash = set ( )
for i in range ( n ) :
Hash.add ( arr [ i ] )
for i in range ( n ) :
for j in range ( i + 1 , n ) :
product = arr [ i ] * arr [ j ]
if product in ( Hash ) :
result += 1
return result
| java | [
[
"[7, 10, 17, 17, 18, 20, 27, 28, 29, 29, 31, 32, 41, 43, 45, 46, 63, 66, 69, 69, 70, 75, 87, 95], 17",
"0"
],
[
"[-60], 0",
"0"
],
[
"[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 9",
"36"
],
[
"[52, 83, 36, 57, 93, 11, 32, 91, 52], 8",
"0"
],
[
"[-98, -94, -90... | f_gold | COUNT_PAIRS_WHOSE_PRODUCTS_EXIST_IN_ARRAY_1 | 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_1{
static int f_gold ( int arr [ ] , int n ) {
int result = 0 ;
HashSet < Integer > Hash = new HashSet < > ( ) ;
for ( int i = 0 ;
i < n ;
i ++ ) {
Hash . add ( arr [ i ] ) ;
}
for ( int i = 0 ;
i < n ;
i ++ ) {
for ( int j = i + 1 ;
j < n ;
j ++ ) {
int product = arr [ i ] * arr [ j ] ;
if ( Hash . contains ( product ) ) {
result ++ ;
}
}
}
return result ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
invcount = 0
for i in range ( 1 , n - 1 ) :
small = 0
for j in range ( i + 1 , n ) :
if ( arr [ i ] > arr [ j ] ) :
small += 1
great = 0 ;
for j in range ( i - 1 , - 1 , - 1 ) :
if ( arr [ i ] < arr [ j ] ) :
great += 1
invcount += great * small
return invcount
| java | [
[
"[4, 75, 89], 1",
"0"
],
[
"[84, -66, -52, 34, -28, -6, 20, 22, -78, -26, 14, 24, -92, -18, 32, -94, -64, -38, 56, 4, -10, 58, -66, -58, -10, -8, -62, -60, -26], 26",
"404"
],
[
"[0, 0, 0, 1, 1, 1, 1, 1], 7",
"0"
],
[
"[18, 7, 43, 57, 94, 37, 38, 41, 59, 64, 97, 29, 51, 37,... | f_gold | COUNT_INVERSIONS_OF_SIZE_THREE_IN_A_GIVE_ARRAY_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_INVERSIONS_OF_SIZE_THREE_IN_A_GIVE_ARRAY_1{
static int f_gold ( int arr [ ] , int n ) {
int invcount = 0 ;
for ( int i = 0 ;
i < n - 1 ;
i ++ ) {
int small = 0 ;
for ( int j = i + 1 ;
j < n ;
j ++ ) if ( arr [ i ] > arr [ j ] ) small ++ ;
int great = 0 ;
for ( int j = i - 1 ;
j >= 0 ;
j -- ) if ( arr [ i ] < arr [ j ] ) great ++ ;
invcount += great * small ;
}
return invcount ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
max_count = 0
max_index = 0
prev_zero = - 1
prev_prev_zero = - 1
for curr in range ( n ) :
if ( arr [ curr ] == 0 ) :
if ( curr - prev_prev_zero > max_count ) :
max_count = curr - prev_prev_zero
max_index = prev_zero
prev_prev_zero = prev_zero
prev_zero = curr
if ( n - prev_prev_zero > max_count ) :
max_index = prev_zero
return max_index
| java | [
[
"[2, 8, 9, 13, 13, 19, 19, 21, 21, 24, 28, 28, 29, 29, 29, 32, 34, 38, 39, 43, 45, 46, 57, 59, 62, 63, 67, 67, 68, 69, 70, 70, 71, 72, 74, 74, 76, 78, 79, 81, 90, 90, 95, 96, 98], 36",
"-1"
],
[
"[28, 92, -16, 0, 6, 12, -88, 42, -48, 72, 2, -38, 80, 82, 96, 32, -42, -38, 62, -76, 20, -10, 2, -48, ... | f_gold | FIND_INDEX_0_REPLACED_1_GET_LONGEST_CONTINUOUS_SEQUENCE_1S_BINARY_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_INDEX_0_REPLACED_1_GET_LONGEST_CONTINUOUS_SEQUENCE_1S_BINARY_ARRAY{
static int f_gold ( int arr [ ] , int n ) {
int max_count = 0 ;
int max_index = 0 ;
int prev_zero = - 1 ;
int prev_prev_zero = - 1 ;
for ( int curr = 0 ;
curr < n ;
++ curr ) {
if ( arr [ curr ] == 0 ) {
if ( curr - prev_prev_zero > max_count ) {
max_count = curr - prev_prev_zero ;
max_index = prev_zero ;
}
prev_prev_zero = prev_zero ;
prev_zero = curr ;
}
}
if ( n - prev_prev_zero > max_count ) max_index = prev_zero ;
return max_index ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
lioes = list ( )
maxLen = 0
for i in range ( n ) :
lioes.append ( 1 )
i = 1
for i in range ( n ) :
for j in range ( i ) :
if ( arr [ i ] > arr [ j ] and ( arr [ i ] + arr [ j ] ) % 2 != 0 and lioes [ i ] < lioes [ j ] + 1 ) :
lioes [ i ] = lioes [ j ] + 1
for i in range ( n ) :
if maxLen < lioes [ i ] :
maxLen = lioes [ i ]
return maxLen
| java | [
[
"[7, 8, 9, 16, 16, 27, 32, 33, 35, 35, 39, 39, 41, 42, 44, 47, 48, 50, 56, 59, 66, 69, 70, 73, 74, 76, 78, 87, 87, 89, 94, 96, 96, 98, 98], 32",
"18"
],
[
"[40, 76, -54, -92, -28, -96, 8, 60, 28, -38, -62, -40, -16, 16, 52, 28, 70, -56, -50, 46, 68, -16, -56, 46, 42, 70, 52, -34, 86, -32, -50, 64,... | f_gold | LONGEST_INCREASING_ODD_EVEN_SUBSEQUENCE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class LONGEST_INCREASING_ODD_EVEN_SUBSEQUENCE{
public static int f_gold ( int arr [ ] , int n ) {
int [ ] lioes = new int [ n ] ;
int maxLen = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) lioes [ i ] = 1 ;
for ( int i = 1 ;
i < n ;
i ++ ) for ( int j = 0 ;
j < i ;
j ++ ) if ( arr [ i ] > arr [ j ] && ( arr [ i ] + arr [ j ] ) % 2 != 0 && lioes [ i ] < lioes [ j ] + 1 ) lioes [ i ] = lioes [ j ] + 1 ;
for ( int i = 0 ;
i < n ;
i ++ ) if ( maxLen < lioes [ i ] ) maxLen = lioes [ i ] ;
return maxLen ;
}
| [] | |
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 * 2 ;
return dec_value ;
| java | [
[
"70",
"14"
],
[
"95",
"23"
],
[
"41",
"9"
],
[
"97",
"25"
],
[
"8",
"8"
],
[
"16",
"8"
],
[
"41",
"9"
],
[
"57",
"17"
],
[
"81",
"17"
],
[
"78",
"22"
]
] | f_gold | PROGRAM_BINARY_DECIMAL_CONVERSION | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PROGRAM_BINARY_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 * 2 ;
}
return dec_value ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
result = 0
for i in range ( 1 , 10 ) :
s = [ ]
if ( i <= n ) :
s.append ( i )
result += 1
while len ( s ) != 0 :
tp = s [ - 1 ]
s.pop ( )
for j in range ( tp % 10 , 10 ) :
x = tp * 10 + j
if ( x <= n ) :
s.append ( x )
result += 1
return result
| java | [
[
"69",
"48"
],
[
"72",
"48"
],
[
"88",
"52"
],
[
"7",
"7"
],
[
"66",
"45"
],
[
"34",
"28"
],
[
"23",
"20"
],
[
"37",
"31"
],
[
"33",
"27"
],
[
"21",
"18"
]
] | f_gold | COUNT_NATURAL_NUMBERS_WHOSE_PERMUTATION_GREATER_NUMBER | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_NATURAL_NUMBERS_WHOSE_PERMUTATION_GREATER_NUMBER{
static int f_gold ( int n ) {
int result = 0 ;
for ( int i = 1 ;
i <= 9 ;
i ++ ) {
Stack < Integer > s = new Stack < > ( ) ;
if ( i <= n ) {
s . push ( i ) ;
result ++ ;
}
while ( ! s . empty ( ) ) {
int tp = s . peek ( ) ;
s . pop ( ) ;
for ( int j = tp % 10 ;
j <= 9 ;
j ++ ) {
int x = tp * 10 + j ;
if ( x <= n ) {
s . push ( x ) ;
result ++ ;
}
}
}
}
return result ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( input , unlock_code ) :
rotation = 0 ;
while ( input > 0 or unlock_code > 0 ) :
input_digit = input % 10 ;
code_digit = unlock_code % 10 ;
rotation += min ( abs ( input_digit - code_digit ) , 10 - abs ( input_digit - code_digit ) ) ;
input = int ( input / 10 ) ;
unlock_code = int ( unlock_code / 10 ) ;
return rotation ;
| java | [
[
"71, 46",
"8"
],
[
"90, 65",
"8"
],
[
"28, 84",
"8"
],
[
"41, 23",
"4"
],
[
"32, 58",
"6"
],
[
"39, 82",
"8"
],
[
"33, 58",
"7"
],
[
"89, 32",
"8"
],
[
"50, 51",
"1"
],
[
"92, 77",
"7"
]
] | f_gold | MINIMUM_ROTATIONS_UNLOCK_CIRCULAR_LOCK | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MINIMUM_ROTATIONS_UNLOCK_CIRCULAR_LOCK{
static int f_gold ( int input , int unlock_code ) {
int rotation = 0 ;
int input_digit , code_digit ;
while ( input > 0 || unlock_code > 0 ) {
input_digit = input % 10 ;
code_digit = unlock_code % 10 ;
rotation += Math . min ( Math . abs ( input_digit - code_digit ) , 10 - Math . abs ( input_digit - code_digit ) ) ;
input /= 10 ;
unlock_code /= 10 ;
}
return rotation ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , n ) :
i , total = 0 , 1
for i in range ( 2 , n + 2 ) :
total += i
total -= a [ i - 2 ]
return total
| java | [
[
"[13, 27, 46, 59, 62, 82, 92], 6",
"-261"
],
[
"[22, 86, -64, -20, -56, -16, 86, 42, 72, -90, 10, 42, 56, 8, 50, 24, -34, 0, -78, 64, 18, 20, -84, -22, 90, -20, 86, 26, -54, 0, 90, -48, 4, 88, 18, -64, -22, -74, 48, -36, -86, -24, 88, -64, 68, 62, 92], 38",
"524"
],
[
"[0, 0, 0, 0, 0, ... | f_gold | FIND_THE_MISSING_NUMBER_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_THE_MISSING_NUMBER_1{
static int f_gold ( int a [ ] , int n ) {
int total = 1 ;
for ( int i = 2 ;
i <= ( n + 1 ) ;
i ++ ) {
total += i ;
total -= a [ i - 2 ] ;
}
return total ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n , X ) :
if ( X < arr [ 0 ] ) :
return 0 ;
elif ( X > arr [ n - 1 ] ) :
return n
lowerPnt = 0
i = 1
while ( i < n and arr [ i ] < X ) :
lowerPnt = i
i = i * 2
while ( lowerPnt < n and arr [ lowerPnt ] < X ) :
lowerPnt += 1
return lowerPnt
| java | [
[
"[1, 2, 5, 5, 16, 16, 20, 26, 32, 35, 39, 39, 41, 44, 48, 48, 51, 59, 59, 62, 66, 66, 70, 74, 75, 78, 80, 86, 86, 96], 17, 29",
"8"
],
[
"[-76, 80, -6, -2, 50, 72, 84, -56, 70, 8, 48, 6, -24, -50, -72], 14, 9",
"14"
],
[
"[0, 0, 0, 0, 0, 1, 1, 1, 1], 8, 4",
"8"
],
[
"[74, 6... | f_gold | LOWER_INSERTION_POINT | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class LOWER_INSERTION_POINT{
static int f_gold ( int arr [ ] , int n , int X ) {
if ( X < arr [ 0 ] ) return 0 ;
else if ( X > arr [ n - 1 ] ) return n ;
int lowerPnt = 0 ;
int i = 1 ;
while ( i < n && arr [ i ] < X ) {
lowerPnt = i ;
i = i * 2 ;
}
while ( lowerPnt < n && arr [ lowerPnt ] < X ) lowerPnt ++ ;
return lowerPnt ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( M , n , m ) :
count = 0
i = 0
j = m - 1
while j >= 0 and i < n :
if M [ i ] [ j ] < 0 :
count += ( j + 1 )
i += 1
else :
j -= 1
return count
| java | [
[
"[[76, 39, 83, 83, 24, 11, 7, 97, 81, 52, 7, 81, 68, 25, 14, 54, 69, 12, 53, 38, 94, 77, 75, 28, 38, 92, 47, 46, 86], [63, 95, 96, 14, 82, 98, 75, 5, 72, 27, 71, 62, 15, 55, 63, 37, 10, 2, 68, 98, 15, 21, 25, 83, 84, 46, 93, 23, 87], [47, 23, 49, 53, 26, 14, 50, 50, 5, 3, 2, 28, 69, 14, 47, 82, 78, 48, 89, 84... | f_gold | COUNT_NEGATIVE_NUMBERS_IN_A_COLUMN_WISE_ROW_WISE_SORTED_MATRIX_1 | 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_1{
static int f_gold ( int M [ ] [ ] , int n , int m ) {
int count = 0 ;
int i = 0 ;
int j = m - 1 ;
while ( j >= 0 && i < n ) {
if ( M [ i ] [ j ] < 0 ) {
count += j + 1 ;
i += 1 ;
}
else j -= 1 ;
}
return count ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
um = dict ( )
curr_sum = 0
for i in range ( n ) :
curr_sum += ( - 1 if ( arr [ i ] == 0 ) else arr [ i ] )
if um.get ( curr_sum ) :
um [ curr_sum ] += 1
else :
um [ curr_sum ] = 1
count = 0
for itr in um :
if um [ itr ] > 1 :
count += ( ( um [ itr ] * int ( um [ itr ] - 1 ) ) / 2 )
if um.get ( 0 ) :
count += um [ 0 ]
return int ( count )
| java | [
[
"[2, 12, 18, 19, 19, 20, 20, 21, 25, 29, 38, 54, 54, 71, 72, 72, 74, 75, 77, 78, 80, 80, 81, 84, 97, 97], 24",
"0"
],
[
"[10, 70, 24, -38, 32, -68, 88, -28, -24, -70, -64, 50, -30, 64, 54, -6, 18, -30, -30, -62, -10, 94, -54, -22, -88, 96, 22, 26, -92, -40, -76, 46, 36, 30, 24, -52, 0], 24",
"... | f_gold | COUNT_SUBARRAYS_EQUAL_NUMBER_1S_0S | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_SUBARRAYS_EQUAL_NUMBER_1S_0S{
static int f_gold ( int arr [ ] , int n ) {
Map < Integer , Integer > um = new HashMap < > ( ) ;
int curr_sum = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
curr_sum += ( arr [ i ] == 0 ) ? - 1 : arr [ i ] ;
um . put ( curr_sum , um . get ( curr_sum ) == null ? 1 : um . get ( curr_sum ) + 1 ) ;
}
int count = 0 ;
for ( Map . Entry < Integer , Integer > itr : um . entrySet ( ) ) {
if ( itr . getValue ( ) > 1 ) count += ( ( itr . getValue ( ) * ( itr . getValue ( ) - 1 ) ) / 2 ) ;
}
if ( um . containsKey ( 0 ) ) count += um . get ( 0 ) ;
return count ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
if ( n <= 1 ) :
return n
a = 0
b = 1
c = 1
res = 1
while ( c < n ) :
c = a + b
res = res + 1
a = b
b = c
return res
| java | [
[
"5",
"5"
],
[
"19",
"8"
],
[
"7",
"6"
],
[
"94",
"12"
],
[
"58",
"11"
],
[
"65",
"11"
],
[
"69",
"11"
],
[
"96",
"12"
],
[
"80",
"11"
],
[
"14",
"8"
]
] | f_gold | FIND_INDEX_GIVEN_FIBONACCI_NUMBER_CONSTANT_TIME | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_INDEX_GIVEN_FIBONACCI_NUMBER_CONSTANT_TIME{
static int f_gold ( int n ) {
if ( n <= 1 ) return n ;
int a = 0 , b = 1 , c = 1 ;
int res = 1 ;
while ( c < n ) {
c = a + b ;
res ++ ;
a = b ;
b = c ;
}
return res ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , size ) :
positive = 0
negative = 1
while ( True ) :
while ( positive < size and a [ positive ] >= 0 ) :
positive = positive + 2
while ( negative < size and a [ negative ] <= 0 ) :
negative = negative + 2
if ( positive < size and negative < size ) :
temp = a [ positive ]
a [ positive ] = a [ negative ]
a [ negative ] = temp
else :
break
| java | [
[
"[8, 11, 18, 23, 24, 28, 28, 34, 35, 42, 44, 53, 57, 65, 71, 72, 76, 78, 82, 82, 85, 86, 92, 93], 15",
"None"
],
[
"[0, -95, 27, -2, -70, -28, 3, -37, 75, -74, 85, -63, -93, -51, 68, -8, 67, 90, 3, -47, 32, 8, 12, 53, -93, 56, 97], 15",
"None"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,... | f_gold | POSITIVE_ELEMENTS_EVEN_NEGATIVE_ODD_POSITIONS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
class POSITIVE_ELEMENTS_EVEN_NEGATIVE_ODD_POSITIONS{
static void f_gold ( int a [ ] , int size ) {
int positive = 0 , negative = 1 , temp ;
while ( true ) {
while ( positive < size && a [ positive ] >= 0 ) positive += 2 ;
while ( negative < size && a [ negative ] <= 0 ) negative += 2 ;
if ( positive < size && negative < size ) {
temp = a [ positive ] ;
a [ positive ] = a [ negative ] ;
a [ negative ] = temp ;
}
else break ;
}
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( s ) :
n = len ( s )
auxArr = [ 0 for i in range ( n ) ]
if ( s [ 0 ] == '1' ) :
auxArr [ 0 ] = 1
for i in range ( 0 , n ) :
if ( s [ i ] == '1' ) :
auxArr [ i ] = auxArr [ i - 1 ] + 1
else :
auxArr [ i ] = auxArr [ i - 1 ]
count = 0
for i in range ( n - 1 , - 1 , - 1 ) :
if ( s [ i ] == '1' ) :
count += auxArr [ i ]
return count
| java | [
[
"'OGiOkJF'",
"0"
],
[
"'517376'",
"1"
],
[
"'11'",
"3"
],
[
"'Ze'",
"0"
],
[
"'8763644247018'",
"1"
],
[
"'00111010001'",
"15"
],
[
"'HGwkBKUOVu'",
"0"
],
[
"'652'",
"0"
],
[
"'101000011110'",
"21"
],
[
... | f_gold | NUMBER_OF_SUBSTRINGS_WITH_ODD_DECIMAL_VALUE_IN_A_BINARY_STRING | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_OF_SUBSTRINGS_WITH_ODD_DECIMAL_VALUE_IN_A_BINARY_STRING{
static int f_gold ( String s ) {
int n = s . length ( ) ;
int [ ] auxArr = new int [ n ] ;
if ( s . charAt ( 0 ) == '1' ) auxArr [ 0 ] = 1 ;
for ( int i = 1 ;
i < n ;
i ++ ) {
if ( s . charAt ( i ) == '1' ) auxArr [ i ] = auxArr [ i - 1 ] + 1 ;
else auxArr [ i ] = auxArr [ i - 1 ] ;
}
int count = 0 ;
for ( int i = n - 1 ;
i >= 0 ;
i -- ) if ( s . charAt ( i ) == '1' ) count += auxArr [ i ] ;
return count ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( limit ) :
if ( limit < 2 ) :
return 0
ef1 = 0
ef2 = 2
sm = ef1 + ef2
while ( ef2 <= limit ) :
ef3 = 4 * ef2 + ef1
if ( ef3 > limit ) :
break
ef1 = ef2
ef2 = ef3
sm = sm + ef2
return sm
| java | [
[
"67",
"44"
],
[
"89",
"44"
],
[
"12",
"10"
],
[
"94",
"44"
],
[
"96",
"44"
],
[
"25",
"10"
],
[
"49",
"44"
],
[
"8",
"10"
],
[
"33",
"10"
],
[
"59",
"44"
]
] | f_gold | EVEN_FIBONACCI_NUMBERS_SUM | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class EVEN_FIBONACCI_NUMBERS_SUM{
static int f_gold ( int limit ) {
if ( limit < 2 ) return 0 ;
long ef1 = 0 , ef2 = 2 ;
long sum = ef1 + ef2 ;
while ( ef2 <= limit ) {
long ef3 = 4 * ef2 + ef1 ;
if ( ef3 > limit ) break ;
ef1 = ef2 ;
ef2 = ef3 ;
sum += ef2 ;
}
return ( int ) sum ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
max1 = max ( arr )
min1 = min ( arr )
m = max1 - min1 + 1
if ( m > n ) :
return False
visited = [ 0 ] * m
for i in range ( 0 , n ) :
visited [ arr [ i ] - min1 ] = True
for i in range ( 0 , m ) :
if ( visited [ i ] == False ) :
return False
return True
| java | [
[
"[2, 4, 19, 25, 65, 72, 75, 83, 90, 92], 8",
"False"
],
[
"[46, 2, 28, -44, 74, -36, -8, 30, -96, 60, 52, -58, 16, -38, 78, 38, -28, 16, 26, -42, 48, 40, 6, 72], 14",
"False"
],
[
"[0, 1, 1, 1], 2",
"True"
],
[
"[50, 21, 9, 29, 86, 2, 82, 49, 34, 18, 77, 83, 44, 67, 85, 58,... | f_gold | CHECK_ARRAY_CONTAINS_CONTIGUOUS_INTEGERS_DUPLICATES_ALLOWED | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_ARRAY_CONTAINS_CONTIGUOUS_INTEGERS_DUPLICATES_ALLOWED{
static boolean f_gold ( int arr [ ] , int n ) {
int max = Integer . MIN_VALUE ;
int min = Integer . MAX_VALUE ;
for ( int i = 0 ;
i < n ;
i ++ ) {
max = Math . max ( max , arr [ i ] ) ;
min = Math . min ( min , arr [ i ] ) ;
}
int m = max - min + 1 ;
if ( m > n ) return false ;
boolean visited [ ] = new boolean [ n ] ;
for ( int i = 0 ;
i < n ;
i ++ ) visited [ arr [ i ] - min ] = true ;
for ( int i = 0 ;
i < m ;
i ++ ) if ( visited [ i ] == false ) return false ;
return true ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr1 , arr2 , m , n , x ) :
count , l , r = 0 , 0 , n - 1
while ( l < m and r >= 0 ) :
if ( ( arr1 [ l ] + arr2 [ r ] ) == x ) :
l += 1
r -= 1
count += 1
elif ( ( arr1 [ l ] + arr2 [ r ] ) < x ) :
l += 1
else :
r -= 1
return count
| java | [
[
"[5, 5, 7, 10, 14, 14, 17, 21, 32, 34, 37, 40, 40, 40, 46, 46, 50, 50, 51, 55, 57, 62, 65, 67, 67, 69, 70, 70, 72, 73, 76, 77, 77, 78, 84, 85, 85, 86, 87, 88, 88, 89, 89, 90, 93, 99], [2, 5, 8, 8, 10, 12, 13, 15, 17, 18, 20, 20, 21, 27, 28, 31, 34, 37, 40, 46, 48, 52, 53, 54, 54, 58, 59, 60, 66, 68, 68, 69, 7... | f_gold | COUNT_PAIRS_TWO_SORTED_ARRAYS_WHOSE_SUM_EQUAL_GIVEN_VALUE_X_2 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_PAIRS_TWO_SORTED_ARRAYS_WHOSE_SUM_EQUAL_GIVEN_VALUE_X_2{
static int f_gold ( int arr1 [ ] , int arr2 [ ] , int m , int n , int x ) {
int count = 0 ;
int l = 0 , r = n - 1 ;
while ( l < m && r >= 0 ) {
if ( ( arr1 [ l ] + arr2 [ r ] ) == x ) {
l ++ ;
r -- ;
count ++ ;
}
else if ( ( arr1 [ l ] + arr2 [ r ] ) < x ) l ++ ;
else r -- ;
}
return count ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( x1 , y1 , x2 , y2 ) :
return ( x1 * ( y2 - y1 ) == y1 * ( x2 - x1 ) )
| java | [
[
"1, 28, 2, 56",
"True"
],
[
"10, 0, 20, 0",
"True"
],
[
"0, 1, 0, 17",
"True"
],
[
"1, 1, 10, 10",
"True"
],
[
"82, 86, 19, 4",
"False"
],
[
"78, 86, 11, 6",
"False"
],
[
"13, 46, 33, 33",
"False"
],
[
"18, 29, 95, 12",
"F... | f_gold | CHECK_LINE_PASSES_ORIGIN | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_LINE_PASSES_ORIGIN{
static boolean f_gold ( int x1 , int y1 , int x2 , int y2 ) {
return ( x1 * ( y2 - y1 ) == y1 * ( x2 - x1 ) ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n , k ) :
if ( k <= 0 ) :
return n
return ( n & ~ ( 1 << ( k - 1 ) ) )
| java | [
[
"49, 15",
"49"
],
[
"59, 69",
"59"
],
[
"76, 20",
"76"
],
[
"27, 76",
"27"
],
[
"61, 60",
"61"
],
[
"67, 27",
"67"
],
[
"63, 71",
"63"
],
[
"85, 25",
"85"
],
[
"90, 64",
"90"
],
[
"24, 55",
"24"
]... | f_gold | HOW_TO_TURN_OFF_A_PARTICULAR_BIT_IN_A_NUMBER | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class HOW_TO_TURN_OFF_A_PARTICULAR_BIT_IN_A_NUMBER{
static int f_gold ( int n , int k ) {
if ( k <= 0 ) return n ;
return ( n & ~ ( 1 << ( k - 1 ) ) ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n , k ) :
res = ""
for i in range ( k ) :
res = res + chr ( ord ( 'a' ) + i )
count = 0
for i in range ( n - k ) :
res = res + chr ( ord ( 'a' ) + count )
count += 1
if ( count == k ) :
count = 0 ;
return res
| java | [
[
"60, 71",
"'abcdefghijklmnopqrstuvwxyz{|}~\\x7f\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d\\x8e\\x8f\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b\\x9c\\x9d\\x9e\\x9f\\xa0¡¢£¤¥¦§'"
],
[
"56, 17",
"'abcdefghijklmnopqabcdefghijklmnopqabcdefghijklmnopqabcd... | f_gold | STRING_K_DISTINCT_CHARACTERS_NO_CHARACTERS_ADJACENT | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class STRING_K_DISTINCT_CHARACTERS_NO_CHARACTERS_ADJACENT{
static String f_gold ( int n , int k ) {
String res = "" ;
for ( int i = 0 ;
i < k ;
i ++ ) res = res + ( char ) ( 'a' + i ) ;
int count = 0 ;
for ( int i = 0 ;
i < n - k ;
i ++ ) {
res = res + ( char ) ( 'a' + count ) ;
count ++ ;
if ( count == k ) count = 0 ;
}
return res ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n , k ) :
p = 1
if ( k % 2 ) :
p = - 1
return ( pow ( n - 1 , k ) + p * ( n - 1 ) ) / n
| java | [
[
"27, 59",
"1.1273629712520942e+82"
],
[
"70, 87",
"1.3638696152410012e+158"
],
[
"77, 40",
"2.2184669650003853e+73"
],
[
"83, 26",
"6.919617201200037e+47"
],
[
"16, 2",
"15.0"
],
[
"90, 66",
"5.075723187324977e+126"
],
[
"39, 72",
"1.... | f_gold | NUMBER_WAYS_NODE_MAKE_LOOP_SIZE_K_UNDIRECTED_COMPLETE_CONNECTED_GRAPH_N_NODES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_WAYS_NODE_MAKE_LOOP_SIZE_K_UNDIRECTED_COMPLETE_CONNECTED_GRAPH_N_NODES{
static int f_gold ( int n , int k ) {
int p = 1 ;
if ( k % 2 != 0 ) p = - 1 ;
return ( int ) ( Math . pow ( n - 1 , k ) + p * ( n - 1 ) ) / n ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , l , r , x ) :
if r >= l :
mid = l + ( r - l ) // 2
if arr [ mid ] == x :
return mid
elif arr [ mid ] > x :
return f_gold ( arr , l , mid - 1 , x )
else :
return f_gold ( arr , mid + 1 , r , x )
else :
return - 1
| java | [
[
"[3, 4, 4, 8, 9, 13, 13, 15, 18, 27, 30, 32, 42, 48, 50, 52, 56, 66, 69, 69, 77, 84, 84, 93], 19, 12, 22",
"-1"
],
[
"[52, -58, -22, -80, 44, -52, -34, 94, -34, -74, 42, 60, -62, 70, 98, 32, 10, 94, 26, 56, -48, -50, 42, 2, 46, 28, -68, -16, -96, -12, 66, -46, 74, -60, -52, 28, -92, -78, 32, 28, 1... | f_gold | BINARY_SEARCH | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class BINARY_SEARCH{
static int f_gold ( int arr [ ] , int l , int r , int x ) {
if ( r >= l ) {
int mid = l + ( r - l ) / 2 ;
if ( arr [ mid ] == x ) return mid ;
if ( arr [ mid ] > x ) return f_gold ( arr , l , mid - 1 , x ) ;
return f_gold ( arr , mid + 1 , r , x ) ;
}
return - 1 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( m , n , x ) :
table = [ [ 0 ] * ( x + 1 ) for i in range ( n + 1 ) ]
for j in range ( 1 , min ( m + 1 , x + 1 ) ) :
table [ 1 ] [ j ] = 1
for i in range ( 2 , n + 1 ) :
for j in range ( 1 , x + 1 ) :
for k in range ( 1 , min ( m + 1 , j ) ) :
table [ i ] [ j ] += table [ i - 1 ] [ j - k ]
return table [ - 1 ] [ - 1 ]
| java | [
[
"94, 4, 69",
"50116"
],
[
"7, 12, 33",
"77635844"
],
[
"20, 44, 24",
"0"
],
[
"90, 94, 88",
"0"
],
[
"50, 58, 27",
"0"
],
[
"32, 90, 29",
"0"
],
[
"46, 25, 6",
"0"
],
[
"82, 50, 87",
"2893740668169934025792700"
],
[
... | f_gold | DICE_THROW_PROBLEM | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class DICE_THROW_PROBLEM{
public static long f_gold ( int m , int n , int x ) {
long [ ] [ ] table = new long [ n + 1 ] [ x + 1 ] ;
for ( int j = 1 ;
j <= m && j <= x ;
j ++ ) table [ 1 ] [ j ] = 1 ;
for ( int i = 2 ;
i <= n ;
i ++ ) {
for ( int j = 1 ;
j <= x ;
j ++ ) {
for ( int k = 1 ;
k < j && k <= m ;
k ++ ) table [ i ] [ j ] += table [ i - 1 ] [ j - k ] ;
}
}
return table [ n ] [ x ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
dp = [ 0 for _ in range ( n + 1 ) ]
for i in range ( 1 , n + 1 ) :
if i <= 3 :
dp [ i ] = 1
elif i == 4 :
dp [ i ] = 2
else :
dp [ i ] = dp [ i - 1 ] + dp [ i - 4 ]
return dp [ n ]
| java | [
[
"61",
"188941273"
],
[
"22",
"657"
],
[
"65",
"685792227"
],
[
"57",
"52054840"
],
[
"36",
"59864"
],
[
"25",
"1728"
],
[
"16",
"95"
],
[
"26",
"2385"
],
[
"92",
"4123691589365"
],
[
"5",
"3"
]
] | f_gold | COUNT_NUMBER_OF_WAYS_TO_FILL_A_N_X_4_GRID_USING_1_X_4_TILES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_NUMBER_OF_WAYS_TO_FILL_A_N_X_4_GRID_USING_1_X_4_TILES{
static int f_gold ( int n ) {
int [ ] dp = new int [ n + 1 ] ;
dp [ 0 ] = 0 ;
for ( int i = 1 ;
i <= n ;
i ++ ) {
if ( i >= 1 && i <= 3 ) dp [ i ] = 1 ;
else if ( i == 4 ) dp [ i ] = 2 ;
else {
dp [ i ] = dp [ i - 1 ] + dp [ i - 4 ] ;
}
}
return dp [ n ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n , k ) :
dist_count = 0
for i in range ( n ) :
j = 0
while j < n :
if ( i != j and arr [ j ] == arr [ i ] ) :
break
j += 1
if ( j == n ) :
dist_count += 1
if ( dist_count == k ) :
return arr [ i ]
return - 1
| java | [
[
"[2, 3, 8, 18, 20, 33, 53, 56, 60, 71, 76, 80, 81, 87, 88, 89, 92, 95], 16, 16",
"89"
],
[
"[-78, 6, 32, 52, -12, -32, 22, -40, -82, 24, 30, 10, -40], 8, 6",
"-32"
],
[
"[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1], 7, 5",
"-1"
],
[
"[3, 28, 55, 21, 42, 60, 96, 83, 98, 75, 29, 73, 51,... | f_gold | K_TH_DISTINCT_OR_NON_REPEATING_ELEMENT_IN_AN_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class K_TH_DISTINCT_OR_NON_REPEATING_ELEMENT_IN_AN_ARRAY{
static int f_gold ( int arr [ ] , int n , int k ) {
int dist_count = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
int j ;
for ( j = 0 ;
j < n ;
j ++ ) if ( i != j && arr [ j ] == arr [ i ] ) break ;
if ( j == n ) dist_count ++ ;
if ( dist_count == k ) return arr [ i ] ;
}
return - 1 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
difference = 0
ans = 0
hash_positive = [ 0 ] * ( n + 1 )
hash_negative = [ 0 ] * ( n + 1 )
hash_positive [ 0 ] = 1
for i in range ( n ) :
if ( arr [ i ] & 1 == 1 ) :
difference = difference + 1
else :
difference = difference - 1
if ( difference < 0 ) :
ans += hash_negative [ - difference ]
hash_negative [ - difference ] = hash_negative [ - difference ] + 1
else :
ans += hash_positive [ difference ]
hash_positive [ difference ] = hash_positive [ difference ] + 1
return ans
| java | [
[
"[7, 8, 12, 13, 14, 19, 20, 22, 28, 30, 31, 31, 32, 34, 34, 39, 39, 43, 45, 46, 47, 62, 63, 63, 65, 66, 69, 69, 71, 76, 79, 82, 83, 88, 89, 92, 93, 95, 97, 97], 26",
"50"
],
[
"[20, -98, -44, -82, 28, 20, -76, -16, 42, 0, -88, 74, 56, 6, -68, -30, 28, 88, 58, -78, 46, 2], 15",
"0"
],
[
... | f_gold | COUNT_SUBARRAYS_WITH_SAME_EVEN_AND_ODD_ELEMENTS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_SUBARRAYS_WITH_SAME_EVEN_AND_ODD_ELEMENTS{
static int f_gold ( int [ ] arr , int n ) {
int difference = 0 ;
int ans = 0 ;
int [ ] hash_positive = new int [ n + 1 ] ;
int [ ] hash_negative = new int [ n + 1 ] ;
hash_positive [ 0 ] = 1 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( ( arr [ i ] & 1 ) == 1 ) {
difference ++ ;
}
else {
difference -- ;
}
if ( difference < 0 ) {
ans += hash_negative [ - difference ] ;
hash_negative [ - difference ] ++ ;
}
else {
ans += hash_positive [ difference ] ;
hash_positive [ difference ] ++ ;
}
}
return ans ;
}
| [] | |
null | [] | [] | python | code_translation | import sys
def f_gold ( arr , n , x , y ) :
min_dist = sys.maxsize
for i in range ( n ) :
if arr [ i ] == x or arr [ i ] == y :
prev = i
break
while i < n :
if arr [ i ] == x or arr [ i ] == y :
if arr [ prev ] != arr [ i ] and ( i - prev ) < min_dist :
min_dist = i - prev
prev = i
else :
prev = i
i += 1
return min_dist
| java | [
[
"[4, 7, 7, 8, 11, 14, 16, 25, 34, 35, 36, 36, 38, 40, 41, 43, 45, 47, 57, 60, 64, 72, 73, 74, 75, 82, 83, 83, 84, 84, 84, 92], 22, 7, 40",
"11"
],
[
"[96, 70, 88, -64, -42, 58, 92, 66, -14, 90, -66, 12, 88, -12, 48, -4, 90, 24, 98, 14, 32, 38, 98, 78, 2, 26, 12, -36, 90, 80, 40, 58, 88, 64, 16], 2... | f_gold | FIND_THE_MINIMUM_DISTANCE_BETWEEN_TWO_NUMBERS_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_THE_MINIMUM_DISTANCE_BETWEEN_TWO_NUMBERS_1{
static int f_gold ( int arr [ ] , int n , int x , int y ) {
int i = 0 ;
int min_dist = Integer . MAX_VALUE ;
int prev = 0 ;
for ( i = 0 ;
i < n ;
i ++ ) {
if ( arr [ i ] == x || arr [ i ] == y ) {
prev = i ;
break ;
}
}
for ( ;
i < n ;
i ++ ) {
if ( arr [ i ] == x || arr [ i ] == y ) {
if ( arr [ prev ] != arr [ i ] && ( i - prev ) < min_dist ) {
min_dist = i - prev ;
prev = i ;
}
else prev = i ;
}
}
return min_dist ;
}
| [
"import sys"
] | |
null | [] | [] | python | code_translation | def f_gold ( x , y , z ) :
if ( not ( y / x ) ) :
return y if ( not ( y / z ) ) else z
return x if ( not ( x / z ) ) else z
| java | [
[
"48, 63, 56",
"56"
],
[
"11, 55, 84",
"84"
],
[
"50, 89, 96",
"96"
],
[
"21, 71, 74",
"74"
],
[
"94, 39, 42",
"42"
],
[
"22, 44, 86",
"86"
],
[
"3, 41, 68",
"68"
],
[
"67, 62, 94",
"94"
],
[
"59, 2, 83",
"83"
... | f_gold | SMALLEST_OF_THREE_INTEGERS_WITHOUT_COMPARISON_OPERATORS_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SMALLEST_OF_THREE_INTEGERS_WITHOUT_COMPARISON_OPERATORS_1{
static int f_gold ( int x , int y , int z ) {
if ( ( y / x ) != 1 ) return ( ( y / z ) != 1 ) ? y : z ;
return ( ( x / z ) != 1 ) ? x : z ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( array , m , n ) :
counter = 0
for i in range ( 0 , m ) :
for j in range ( 0 , n ) :
if ( array [ i ] [ j ] == 0 ) :
counter = counter + 1
return ( counter > ( ( m * n ) // 2 ) )
| java | [
[
"[[79, 48, 59, 39, 33, 8, 8, 47, 45, 54, 35, 40, 70, 98, 70, 81, 48, 52, 74, 83, 67, 46, 14, 60, 47, 12], [95, 48, 3, 19, 14, 81, 2, 3, 72, 55, 5, 88, 98, 97, 75, 61, 42, 46, 49, 14, 20, 16, 9, 66, 21, 66], [98, 83, 30, 38, 55, 85, 23, 83, 32, 84, 5, 6, 76, 59, 12, 22, 33, 28, 36, 9, 2, 9, 18, 24, 65, 73], [5... | f_gold | CHECK_GIVEN_MATRIX_SPARSE_NOT | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_GIVEN_MATRIX_SPARSE_NOT{
static boolean f_gold ( int array [ ] [ ] , int m , int n ) {
int counter = 0 ;
for ( int i = 0 ;
i < m ;
++ i ) for ( int j = 0 ;
j < n ;
++ j ) if ( array [ i ] [ j ] == 0 ) ++ counter ;
return ( counter > ( ( m * n ) / 2 ) ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( str ) :
result = 0
for i in range ( len ( str ) ) :
if ( ( i == ord ( str [ i ] ) - ord ( 'a' ) ) or ( i == ord ( str [ i ] ) - ord ( 'A' ) ) ) :
result += 1
return result
| java | [
[
"'lLkhFeZGcb'",
"0"
],
[
"'ABcED'",
"3"
],
[
"'geeksforgeeks'",
"1"
],
[
"'Alphabetical'",
"3"
],
[
"'abababab'",
"2"
],
[
"'bcdefgxyz'",
"0"
],
[
"'cBzaqx L'",
"1"
],
[
"' bcd'",
"3"
],
[
"'11'",
"0"
],
[
... | f_gold | COUNT_CHARACTERS_POSITION_ENGLISH_ALPHABETS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_CHARACTERS_POSITION_ENGLISH_ALPHABETS{
static int f_gold ( String str ) {
int result = 0 ;
for ( int i = 0 ;
i < str . length ( ) ;
i ++ ) {
if ( i == ( str . charAt ( i ) - 'a' ) || i == ( str . charAt ( i ) - 'A' ) ) {
result ++ ;
}
}
return result ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
return ( n * n ) + ( n * n * n )
| java | [
[
"90",
"737100"
],
[
"95",
"866400"
],
[
"22",
"11132"
],
[
"29",
"25230"
],
[
"62",
"242172"
],
[
"40",
"65600"
],
[
"52",
"143312"
],
[
"21",
"9702"
],
[
"33",
"37026"
],
[
"11",
"1452"
]
] | f_gold | N_TH_TERM_SERIES_2_12_36_80_150 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class N_TH_TERM_SERIES_2_12_36_80_150{
public static int f_gold ( int n ) {
return ( n * n ) + ( n * n * n ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
dp = [ [ 0 for j in range ( 27 ) ] for i in range ( n + 1 ) ]
for i in range ( 0 , 26 ) :
dp [ 1 ] [ i ] = 1
for i in range ( 2 , n + 1 ) :
for j in range ( 0 , 26 ) :
if ( j == 0 ) :
dp [ i ] [ j ] = dp [ i - 1 ] [ j + 1 ] ;
else :
dp [ i ] [ j ] = ( dp [ i - 1 ] [ j - 1 ] + dp [ i - 1 ] [ j + 1 ] )
sum = 0
for i in range ( 0 , 26 ) :
sum = sum + dp [ n ] [ i ]
return sum
| java | [
[
"7",
"1468"
],
[
"47",
"1134264891541288"
],
[
"72",
"31916931064603434989256"
],
[
"66",
"519857447751054478104"
],
[
"71",
"16069407891645913779000"
],
[
"56",
"544505079089235836"
],
[
"61",
"16822463903082664816"
],
[
"68"... | f_gold | COUNT_STRINGS_ADJACENT_CHARACTERS_DIFFERENCE_ONE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_STRINGS_ADJACENT_CHARACTERS_DIFFERENCE_ONE{
static long f_gold ( int n ) {
long [ ] [ ] dp = new long [ n + 1 ] [ 27 ] ;
for ( int i = 0 ;
i < n + 1 ;
i ++ ) {
for ( int j = 0 ;
j < 27 ;
j ++ ) {
dp [ i ] [ j ] = 0 ;
}
}
for ( int i = 0 ;
i <= 25 ;
i ++ ) {
dp [ 1 ] [ i ] = 1 ;
}
for ( int i = 2 ;
i <= n ;
i ++ ) {
for ( int j = 0 ;
j <= 25 ;
j ++ ) {
if ( j == 0 ) {
dp [ i ] [ j ] = dp [ i - 1 ] [ j + 1 ] ;
}
else {
dp [ i ] [ j ] = ( dp [ i - 1 ] [ j - 1 ] + dp [ i - 1 ] [ j + 1 ] ) ;
}
}
}
long sum = 0 ;
for ( int i = 0 ;
i <= 25 ;
i ++ ) {
sum = ( sum + dp [ n ] [ i ] ) ;
}
return sum ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( num ) :
if num < 0 :
return f_gold ( - num )
if ( num == 0 or num == 7 ) :
return True
if ( num < 10 ) :
return False
return f_gold ( num / 10 - 2 * ( num - num / 10 * 10 ) )
| java | [
[
"0",
"True"
],
[
"-21",
"False"
],
[
"7",
"True"
],
[
"63",
"False"
],
[
"84",
"False"
],
[
"73",
"False"
],
[
"81",
"False"
],
[
"-10",
"False"
],
[
"47",
"False"
],
[
"23",
"False"
]
] | f_gold | DIVISIBILITY_BY_7 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class DIVISIBILITY_BY_7{
static boolean f_gold ( int num ) {
if ( num < 0 ) return f_gold ( - num ) ;
if ( num == 0 || num == 7 ) return true ;
if ( num < 10 ) return false ;
return f_gold ( num / 10 - 2 * ( num - num / 10 * 10 ) ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , b ) :
if ( a < 0 ) :
a = - a
if ( b < 0 ) :
b = - b
mod = a
while ( mod >= b ) :
mod = mod - b
if ( a < 0 ) :
return - mod
return mod
| java | [
[
"3243.229719038493, 5659.926861939672",
"3243.229719038493"
],
[
"-4362.665881044217, -9196.507113304497",
"4362.665881044217"
],
[
"7255.066257575837, 2623.200060506935",
"2008.6661365619666"
],
[
"-6929.554320261099, -3009.0234530313287",
"911.5074141984414"
],
[
... | f_gold | MODULUS_TWO_FLOAT_DOUBLE_NUMBERS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MODULUS_TWO_FLOAT_DOUBLE_NUMBERS{
static double f_gold ( double a , double b ) {
if ( a < 0 ) a = - a ;
if ( b < 0 ) b = - b ;
double mod = a ;
while ( mod >= b ) mod = mod - b ;
if ( a < 0 ) return - mod ;
return mod ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a1 , a2 , a3 , n1 , n2 , n3 , sum ) :
for i in range ( 0 , n1 ) :
for j in range ( 0 , n2 ) :
for k in range ( 0 , n3 ) :
if ( a1 [ i ] + a2 [ j ] + a3 [ k ] == sum ) :
return True
return False
| java | [
[
"[4, 9, 10, 19, 24, 25, 26, 30, 36, 43, 44, 49, 52, 62, 66, 69, 72, 77, 80, 80, 82, 84, 90, 93, 94, 98], [4, 8, 17, 20, 22, 25, 27, 30, 31, 33, 35, 35, 38, 41, 49, 51, 60, 61, 66, 67, 69, 82, 84, 85, 86, 88], [12, 14, 17, 20, 22, 27, 29, 31, 32, 38, 41, 43, 56, 59, 59, 64, 66, 67, 68, 69, 71, 76, 83, 83, 85, ... | f_gold | FIND_THREE_ELEMENT_FROM_DIFFERENT_THREE_ARRAYS_SUCH_THAT_THAT_A_B_C_K | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_THREE_ELEMENT_FROM_DIFFERENT_THREE_ARRAYS_SUCH_THAT_THAT_A_B_C_K{
static boolean f_gold ( int a1 [ ] , int a2 [ ] , int a3 [ ] , int n1 , int n2 , int n3 , int sum ) {
for ( int i = 0 ;
i < n1 ;
i ++ ) for ( int j = 0 ;
j < n2 ;
j ++ ) for ( int k = 0 ;
k < n3 ;
k ++ ) if ( a1 [ i ] + a2 [ j ] + a3 [ k ] == sum ) return true ;
return false ;
}
| [] | |
null | [] | [] | python | code_translation | import math
def f_gold ( x , y ) :
x = x % 10
if y != 0 :
y = y % 4 + 4
return ( ( ( int ) ( math.pow ( x , y ) ) ) % 10 )
| java | [
[
"37, 17",
"7"
],
[
"70, 52",
"0"
],
[
"26, 23",
"6"
],
[
"9, 96",
"1"
],
[
"82, 71",
"8"
],
[
"95, 36",
"5"
],
[
"43, 40",
"1"
],
[
"7, 27",
"3"
],
[
"19, 56",
"1"
],
[
"49, 28",
"1"
]
] | f_gold | FIND_UNIT_DIGIT_X_RAISED_POWER_Y_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_UNIT_DIGIT_X_RAISED_POWER_Y_1{
static int f_gold ( int x , int y ) {
x = x % 10 ;
if ( y != 0 ) y = y % 4 + 4 ;
return ( ( ( int ) ( Math . pow ( x , y ) ) ) % 10 ) ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | def f_gold ( base ) :
base = ( base - 2 )
base = base / 2
return base * ( base + 1 ) / 2
| java | [
[
"95",
"1104.375"
],
[
"49",
"287.875"
],
[
"10",
"10.0"
],
[
"73",
"647.875"
],
[
"74",
"666.0"
],
[
"40",
"190.0"
],
[
"10",
"10.0"
],
[
"94",
"1081.0"
],
[
"64",
"496.0"
],
[
"16",
"28.0"
]
] | f_gold | MAXIMUM_NUMBER_2X2_SQUARES_CAN_FIT_INSIDE_RIGHT_ISOSCELES_TRIANGLE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_NUMBER_2X2_SQUARES_CAN_FIT_INSIDE_RIGHT_ISOSCELES_TRIANGLE{
public static int f_gold ( int base ) {
base = ( base - 2 ) ;
base = base / 2 ;
return base * ( base + 1 ) / 2 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( p ) :
checkNumber = 2 ** p - 1
nextval = 4 % checkNumber
for i in range ( 1 , p - 1 ) :
nextval = ( nextval * nextval - 2 ) % checkNumber
if ( nextval == 0 ) : return True
else : return False
| java | [
[
"11",
"False"
],
[
"27",
"False"
],
[
"31",
"True"
],
[
"47",
"False"
],
[
"3",
"True"
],
[
"14",
"False"
],
[
"41",
"False"
],
[
"72",
"False"
],
[
"39",
"False"
],
[
"22",
"False"
]
] | f_gold | PRIMALITY_TEST_SET_5USING_LUCAS_LEHMER_SERIES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PRIMALITY_TEST_SET_5USING_LUCAS_LEHMER_SERIES{
static boolean f_gold ( int p ) {
double checkNumber = Math . pow ( 2 , p ) - 1 ;
double nextval = 4 % checkNumber ;
for ( int i = 1 ;
i < p - 1 ;
i ++ ) nextval = ( nextval * nextval - 2 ) % checkNumber ;
return ( nextval == 0 ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( m , n ) :
T = [ [ 0 for i in range ( n + 1 ) ] for i in range ( m + 1 ) ]
for i in range ( m + 1 ) :
for j in range ( n + 1 ) :
if i == 0 or j == 0 :
T [ i ] [ j ] = 0
elif i < j :
T [ i ] [ j ] = 0
elif j == 1 :
T [ i ] [ j ] = i
else :
T [ i ] [ j ] = T [ i - 1 ] [ j ] + T [ i // 2 ] [ j - 1 ]
return T [ m ] [ n ]
| java | [
[
"10, 4",
"4"
],
[
"5, 2",
"6"
],
[
"2, 8",
"0"
],
[
"83, 7",
"330"
],
[
"91, 0",
"0"
],
[
"18, 53",
"0"
],
[
"83, 41",
"0"
],
[
"98, 53",
"0"
],
[
"43, 37",
"0"
],
[
"31, 20",
"0"
]
] | f_gold | SEQUENCES_GIVEN_LENGTH_EVERY_ELEMENT_EQUAL_TWICE_PREVIOUS_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SEQUENCES_GIVEN_LENGTH_EVERY_ELEMENT_EQUAL_TWICE_PREVIOUS_1{
static int f_gold ( int m , int n ) {
int T [ ] [ ] = new int [ m + 1 ] [ n + 1 ] ;
for ( int i = 0 ;
i < m + 1 ;
i ++ ) {
for ( int j = 0 ;
j < n + 1 ;
j ++ ) {
if ( i == 0 || j == 0 ) T [ i ] [ j ] = 0 ;
else if ( i < j ) T [ i ] [ j ] = 0 ;
else if ( j == 1 ) T [ i ] [ j ] = i ;
else T [ i ] [ j ] = T [ i - 1 ] [ j ] + T [ i / 2 ] [ j - 1 ] ;
}
}
return T [ m ] [ n ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( ar1 , ar2 , n ) :
i = 0
j = 0
m1 = - 1
m2 = - 1
count = 0
while count < n + 1 :
count += 1
if i == n :
m1 = m2
m2 = ar2 [ 0 ]
break
elif j == n :
m1 = m2
m2 = ar1 [ 0 ]
break
if ar1 [ i ] < ar2 [ j ] :
m1 = m2
m2 = ar1 [ i ]
i += 1
else :
m1 = m2
m2 = ar2 [ j ]
j += 1
return ( m1 + m2 ) / 2
| java | [
[
"[2, 6, 18, 21, 23, 27, 44, 44, 69, 72, 78, 88, 90, 98], [6, 12, 16, 18, 26, 34, 48, 48, 49, 56, 61, 79, 81, 89], 12",
"39.0"
],
[
"[90, 54, 24, -10, -84, -74, 58, 96, -28, -92, -18, 90, 70, -60, 72, 78, 10, 42, -2, -18, -38, -16, 18, -86, 40, -46, -38, 66, 20, -16, 48], [-72, -62, 14, -58, 70, 54... | f_gold | MEDIAN_OF_TWO_SORTED_ARRAYS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MEDIAN_OF_TWO_SORTED_ARRAYS{
static int f_gold ( int ar1 [ ] , int ar2 [ ] , int n ) {
int i = 0 ;
int j = 0 ;
int count ;
int m1 = - 1 , m2 = - 1 ;
for ( count = 0 ;
count <= n ;
count ++ ) {
if ( i == n ) {
m1 = m2 ;
m2 = ar2 [ 0 ] ;
break ;
}
else if ( j == n ) {
m1 = m2 ;
m2 = ar1 [ 0 ] ;
break ;
}
if ( ar1 [ i ] < ar2 [ j ] ) {
m1 = m2 ;
m2 = ar1 [ i ] ;
i ++ ;
}
else {
m1 = m2 ;
m2 = ar2 [ j ] ;
j ++ ;
}
}
return ( m1 + m2 ) / 2 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , b ) :
if ( a == b ) :
return a
if ( a == 0 ) :
return b
if ( b == 0 ) :
return a
if ( ( ~ a & 1 ) == 1 ) :
if ( ( b & 1 ) == 1 ) :
return f_gold ( a >> 1 , b )
else :
return ( f_gold ( a >> 1 , b >> 1 ) << 1 )
if ( ( ~ b & 1 ) == 1 ) :
return f_gold ( a , b >> 1 )
if ( a > b ) :
return f_gold ( ( a - b ) >> 1 , b )
return f_gold ( ( b - a ) >> 1 , a )
| java | [
[
"52, 29",
"1"
],
[
"36, 94",
"2"
],
[
"12, 6",
"6"
],
[
"69, 7",
"1"
],
[
"45, 11",
"1"
],
[
"7, 51",
"1"
],
[
"45, 55",
"5"
],
[
"62, 86",
"2"
],
[
"96, 63",
"3"
],
[
"89, 12",
"1"
]
] | f_gold | STEINS_ALGORITHM_FOR_FINDING_GCD_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class STEINS_ALGORITHM_FOR_FINDING_GCD_1{
static int f_gold ( int a , int b ) {
if ( a == b ) return a ;
if ( a == 0 ) return b ;
if ( b == 0 ) return a ;
if ( ( ~ a & 1 ) == 1 ) {
if ( ( b & 1 ) == 1 ) return f_gold ( a >> 1 , b ) ;
else return f_gold ( a >> 1 , b >> 1 ) << 1 ;
}
if ( ( ~ b & 1 ) == 1 ) return f_gold ( a , b >> 1 ) ;
if ( a > b ) return f_gold ( ( a - b ) >> 1 , b ) ;
return f_gold ( ( b - a ) >> 1 , a ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n , x ) :
for i in range ( 0 , n - 1 ) :
if ( arr [ i ] > arr [ i + 1 ] ) :
break ;
l = ( i + 1 ) % n
r = i
while ( l != r ) :
if ( arr [ l ] + arr [ r ] == x ) :
return True ;
if ( arr [ l ] + arr [ r ] < x ) :
l = ( l + 1 ) % n ;
else :
r = ( n + r - 1 ) % n ;
return False ;
| java | [
[
"[3, 8, 10, 15, 18, 19, 20, 20, 21, 22, 26, 30, 32, 34, 43, 45, 50, 50, 51, 52, 53, 56, 57, 58, 62, 63, 65, 82, 86, 91, 91, 92, 92, 93, 97], 17, 30",
"False"
],
[
"[30, -34, 86, -30, -26, 2, 90, 8, 26, -8, -8, 0, -86, 68, 22, 72, -76, 48, -24, 90, -22, -58, -54, 90, -12, -12, 88, 72, -58, 68, 84, ... | f_gold | GIVEN_A_SORTED_AND_ROTATED_ARRAY_FIND_IF_THERE_IS_A_PAIR_WITH_A_GIVEN_SUM | 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{
static boolean f_gold ( int arr [ ] , int n , int x ) {
int i ;
for ( i = 0 ;
i < n - 1 ;
i ++ ) if ( arr [ i ] > arr [ i + 1 ] ) break ;
int l = ( i + 1 ) % n ;
int r = i ;
while ( l != r ) {
if ( arr [ l ] + arr [ r ] == x ) return true ;
if ( arr [ l ] + arr [ r ] < x ) l = ( l + 1 ) % n ;
else r = ( n + r - 1 ) % n ;
}
return false ;
}
| [] | |
null | [] | [] | python | code_translation | import math
def f_gold ( r ) :
if ( r <= 0 ) :
return 0
result = 4
for x in range ( 1 , r ) :
ySquare = r * r - x * x
y = int ( math.sqrt ( ySquare ) )
if ( y * y == ySquare ) :
result += 4
return result
| java | [
[
"34",
"12"
],
[
"56",
"4"
],
[
"90",
"12"
],
[
"47",
"4"
],
[
"36",
"4"
],
[
"63",
"4"
],
[
"21",
"4"
],
[
"76",
"4"
],
[
"18",
"4"
],
[
"75",
"20"
]
] | f_gold | CIRCLE_LATTICE_POINTS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CIRCLE_LATTICE_POINTS{
static int f_gold ( int r ) {
if ( r <= 0 ) return 0 ;
int result = 4 ;
for ( int x = 1 ;
x < r ;
x ++ ) {
int ySquare = r * r - x * x ;
int y = ( int ) Math . sqrt ( ySquare ) ;
if ( y * y == ySquare ) result += 4 ;
}
return result ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
hash_map = { } ;
curr_sum = 0 ;
max_len = 0 ;
ending_index = - 1 ;
for i in range ( 0 , n ) :
if ( arr [ i ] == 0 ) :
arr [ i ] = - 1 ;
else :
arr [ i ] = 1 ;
for i in range ( 0 , n ) :
curr_sum = curr_sum + arr [ i ] ;
if ( curr_sum == 0 ) :
max_len = i + 1 ;
ending_index = i ;
if ( curr_sum + n ) in hash_map :
max_len = max ( max_len , i - hash_map [ curr_sum + n ] )
else :
hash_map [ curr_sum ] = i ;
for i in range ( 0 , n ) :
if ( arr [ i ] == - 1 ) :
arr [ i ] = 0 ;
else :
arr [ i ] = 1 ;
print ( ending_index - max_len + 1 , end = " " ) ;
print ( "to" , end = " " ) ;
print ( ending_index ) ;
return max_len ;
| java | [
[
"[1, 1, 1, 1, 1, 1, 1, 1, 1, 42, 60, 66, 69, 70, 70, 73, 74, 80, 99], 9",
"0"
],
[
"[1, -66], 1",
"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], 19",
"0"
],
[
"[1, 1, 1, 1, 1, 1, 1, 1, 26, 44, 32], 8",
"0"
],
[
"[1, 1, 1, ... | f_gold | LARGEST_SUBARRAY_WITH_EQUAL_NUMBER_OF_0S_AND_1S_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class LARGEST_SUBARRAY_WITH_EQUAL_NUMBER_OF_0S_AND_1S_1{
static int f_gold ( int arr [ ] , int n ) {
HashMap < Integer , Integer > hM = new HashMap < Integer , Integer > ( ) ;
int sum = 0 ;
int max_len = 0 ;
int ending_index = - 1 ;
int start_index = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
arr [ i ] = ( arr [ i ] == 0 ) ? - 1 : 1 ;
}
for ( int i = 0 ;
i < n ;
i ++ ) {
sum += arr [ i ] ;
if ( sum == 0 ) {
max_len = i + 1 ;
ending_index = i ;
}
if ( hM . containsKey ( sum + n ) ) {
if ( max_len < i - hM . get ( sum + n ) ) {
max_len = i - hM . get ( sum + n ) ;
ending_index = i ;
}
}
else hM . put ( sum + n , i ) ;
}
for ( int i = 0 ;
i < n ;
i ++ ) {
arr [ i ] = ( arr [ i ] == - 1 ) ? 0 : 1 ;
}
int end = ending_index - max_len + 1 ;
System . out . println ( end + " to " + ending_index ) ;
return max_len ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( A , K ) :
n = len ( A ) ;
pre_sum = [ 0 ] * ( n + 1 ) ;
pre_sum [ 0 ] = 0 ;
for i in range ( n ) :
pre_sum [ i + 1 ] = pre_sum [ i ] + A [ i ] ;
dp = [ 0 ] * n ;
sum = 0 ;
for i in range ( n ) :
dp [ i ] = ( pre_sum [ n ] - pre_sum [ i ] ) / ( n - i ) ;
for k in range ( K - 1 ) :
for i in range ( n ) :
for j in range ( i + 1 , n ) :
dp [ i ] = max ( dp [ i ] , ( pre_sum [ j ] - pre_sum [ i ] ) / ( j - i ) + dp [ j ] ) ;
return int ( dp [ 0 ] ) ;
| java | [
[
"[4, 11, 14, 27, 32, 37, 39, 49, 52, 53, 57, 62, 67, 67, 68, 69, 76, 77, 78, 81, 85, 85, 87, 91, 91, 91, 99, 99, 99], 24",
"1742"
],
[
"[80, 12, 32, 44, 24, 82, -40, 42, 26, 36, 58, 52, -34, 44, 12, -18, -72, 52, 2, -8, 22, -18, 98, -60, 62, 92, -46, 20, 20, -46, 52, 94, 0, -28, -22, 80, 26, -92, ... | f_gold | MAXIMUM_AVERAGE_SUM_PARTITION_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MAXIMUM_AVERAGE_SUM_PARTITION_ARRAY{
static double f_gold ( int [ ] A , int K ) {
int n = A . length ;
double [ ] pre_sum = new double [ n + 1 ] ;
pre_sum [ 0 ] = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) pre_sum [ i + 1 ] = pre_sum [ i ] + A [ i ] ;
double [ ] dp = new double [ n ] ;
double sum = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) dp [ i ] = ( pre_sum [ n ] - pre_sum [ i ] ) / ( n - i ) ;
for ( int k = 0 ;
k < K - 1 ;
k ++ ) for ( int i = 0 ;
i < n ;
i ++ ) for ( int j = i + 1 ;
j < n ;
j ++ ) dp [ i ] = Math . max ( dp [ i ] , ( pre_sum [ j ] - pre_sum [ i ] ) / ( j - i ) + dp [ j ] ) ;
return dp [ 0 ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
a , b , c = 1 , 2 , 0 ;
if ( n <= 2 ) :
return n ;
for i in range ( 3 , n + 1 ) :
c = b + ( i - 1 ) * a ;
a = b ;
b = c ;
return c ;
| java | [
[
"24",
"17492190577600"
],
[
"1",
"1"
],
[
"91",
"18723846887829931303684501424840972787050559847800270957087312926249844736"
],
[
"90",
"1867720278882863552220974741341446038725782674583207163689731410452545536"
],
[
"89",
"1872902956549674194607058520388836... | f_gold | FRIENDS_PAIRING_PROBLEM_2 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FRIENDS_PAIRING_PROBLEM_2{
static int f_gold ( int n ) {
int a = 1 , b = 2 , c = 0 ;
if ( n <= 2 ) {
return n ;
}
for ( int i = 3 ;
i <= n ;
i ++ ) {
c = b + ( i - 1 ) * a ;
a = b ;
b = c ;
}
return c ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , n , k ) :
result = 0
for i in range ( n ) :
if ( a [ i ] != 1 and a [ i ] > k ) :
result = ( result + min ( a [ i ] % k , k - a [ i ] % k ) )
else :
result = result + k - a [ i ]
return result
| java | [
[
"[3, 7, 27, 32, 36, 37, 44, 48, 50, 64, 86], 5, 10",
"19"
],
[
"[-22, 6, -20, 60, -74, 98, 52, -22], 5, 4",
"130"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 23, 29",
"661"
],
[
"[7... | f_gold | MINIMUM_OPERATIONS_MAKE_GCD_ARRAY_MULTIPLE_K | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MINIMUM_OPERATIONS_MAKE_GCD_ARRAY_MULTIPLE_K{
static int f_gold ( int a [ ] , int n , int k ) {
int result = 0 ;
for ( int i = 0 ;
i < n ;
++ i ) {
if ( a [ i ] != 1 && a [ i ] > k ) {
result = result + Math . min ( a [ i ] % k , k - a [ i ] % k ) ;
}
else {
result = result + k - a [ i ] ;
}
}
return result ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( str , n ) :
dp = [ [ 0 for x in range ( n ) ] for y in range ( n ) ]
P = [ [ False for x in range ( n ) ] for y in range ( n ) ]
for i in range ( n ) :
P [ i ] [ i ] = True
for i in range ( n - 1 ) :
if ( str [ i ] == str [ i + 1 ] ) :
P [ i ] [ i + 1 ] = True
dp [ i ] [ i + 1 ] = 1
for gap in range ( 2 , n ) :
for i in range ( n - gap ) :
j = gap + i ;
if ( str [ i ] == str [ j ] and P [ i + 1 ] [ j - 1 ] ) :
P [ i ] [ j ] = True
if ( P [ i ] [ j ] == True ) :
dp [ i ] [ j ] = ( dp [ i ] [ j - 1 ] + dp [ i + 1 ] [ j ] + 1 - dp [ i + 1 ] [ j - 1 ] )
else :
dp [ i ] [ j ] = ( dp [ i ] [ j - 1 ] + dp [ i + 1 ] [ j ] - dp [ i + 1 ] [ j - 1 ] )
return dp [ 0 ] [ n - 1 ]
| java | [
[
"['E', 'E', 'J', 'P', 'T', 'U', 'X', 'Y', 'Z', 'e', 'f', 'h', 'l', 'm', 'n', 'o', 'z'], 11",
"1"
],
[
"['8', '7', '3', '4', '9', '5', '3', '1', '4', '0', '6', '8', '2', '5', '8', '3', '5', '2', '8', '6', '6', '3', '5', '7', '5', '5', '3', '7'], 27",
"3"
],
[
"['0', '0', '0', '0', '0', ... | f_gold | COUNT_PALINDROME_SUB_STRINGS_STRING | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_PALINDROME_SUB_STRINGS_STRING{
static int f_gold ( char str [ ] , int n ) {
int dp [ ] [ ] = new int [ n ] [ n ] ;
boolean P [ ] [ ] = new boolean [ n ] [ n ] ;
for ( int i = 0 ;
i < n ;
i ++ ) P [ i ] [ i ] = true ;
for ( int i = 0 ;
i < n - 1 ;
i ++ ) {
if ( str [ i ] == str [ i + 1 ] ) {
P [ i ] [ i + 1 ] = true ;
dp [ i ] [ i + 1 ] = 1 ;
}
}
for ( int gap = 2 ;
gap < n ;
gap ++ ) {
for ( int i = 0 ;
i < n - gap ;
i ++ ) {
int j = gap + i ;
if ( str [ i ] == str [ j ] && P [ i + 1 ] [ j - 1 ] ) P [ i ] [ j ] = true ;
if ( P [ i ] [ j ] == true ) dp [ i ] [ j ] = dp [ i ] [ j - 1 ] + dp [ i + 1 ] [ j ] + 1 - dp [ i + 1 ] [ j - 1 ] ;
else dp [ i ] [ j ] = dp [ i ] [ j - 1 ] + dp [ i + 1 ] [ j ] - dp [ i + 1 ] [ j - 1 ] ;
}
}
return dp [ 0 ] [ n - 1 ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , b , c ) :
if ( ( a < b and b < c ) or ( c < b and b < a ) ) :
return b ;
if ( ( b < a and a < c ) or ( c < a and a < b ) ) :
return a ;
else :
return c
| java | [
[
"56, 5, 82",
"56"
],
[
"56, 60, 17",
"56"
],
[
"36, 56, 51",
"51"
],
[
"71, 54, 6",
"54"
],
[
"3, 70, 81",
"70"
],
[
"84, 57, 47",
"57"
],
[
"30, 80, 85",
"80"
],
[
"82, 54, 32",
"54"
],
[
"90, 70, 55",
"70"
... | f_gold | MIDDLE_OF_THREE_USING_MINIMUM_COMPARISONS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class MIDDLE_OF_THREE_USING_MINIMUM_COMPARISONS{
public static int f_gold ( int a , int b , int c ) {
if ( ( a < b && b < c ) || ( c < b && b < a ) ) return b ;
else if ( ( b < a && a < c ) || ( c < a && a < b ) ) return a ;
else return c ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( x ) :
return ( ( x & 0x0F ) << 4 | ( x & 0xF0 ) >> 4 )
| java | [
[
"57",
"147"
],
[
"99",
"54"
],
[
"66",
"36"
],
[
"97",
"22"
],
[
"95",
"245"
],
[
"42",
"162"
],
[
"95",
"245"
],
[
"89",
"149"
],
[
"3",
"48"
],
[
"84",
"69"
]
] | f_gold | SWAP_TWO_NIBBLES_BYTE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SWAP_TWO_NIBBLES_BYTE{
static int f_gold ( int x ) {
return ( ( x & 0x0F ) << 4 | ( x & 0xF0 ) >> 4 ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
ans = 0 ; temp = 0 ;
for i in range ( 1 , n + 1 ) :
if temp < n :
temp = i - 1
num = 1
while temp < n :
if temp + i <= n :
ans += i * num
else :
ans += ( n - temp ) * num
temp += i
num += 1
return ans
| java | [
[
"35",
"630"
],
[
"93",
"4371"
],
[
"7",
"28"
],
[
"81",
"3321"
],
[
"80",
"3240"
],
[
"47",
"1128"
],
[
"7",
"28"
],
[
"41",
"861"
],
[
"59",
"1770"
],
[
"34",
"595"
]
] | f_gold | SUM_MATRIX_ELEMENT_ELEMENT_INTEGER_DIVISION_ROW_COLUMN_1 | 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_1{
static int f_gold ( int n ) {
int ans = 0 , temp = 0 , num ;
for ( int i = 1 ;
i <= n && temp < n ;
i ++ ) {
temp = i - 1 ;
num = 1 ;
while ( temp < n ) {
if ( temp + i <= n ) ans += ( i * num ) ;
else ans += ( ( n - temp ) * num ) ;
temp += i ;
num ++ ;
}
}
return ans ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
if ( n <= 0 ) :
return 0
fibo = [ 0 ] * ( n + 1 )
fibo [ 1 ] = 1
sm = fibo [ 0 ] + fibo [ 1 ]
for i in range ( 2 , n + 1 ) :
fibo [ i ] = fibo [ i - 1 ] + fibo [ i - 2 ]
sm = sm + fibo [ i ]
return sm
| java | [
[
"9",
"88"
],
[
"50",
"32951280098"
],
[
"7",
"33"
],
[
"21",
"28656"
],
[
"21",
"28656"
],
[
"91",
"12200160415121876737"
],
[
"11",
"232"
],
[
"25",
"196417"
],
[
"62",
"10610209857722"
],
[
"4",
"... | f_gold | SUM_FIBONACCI_NUMBERS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SUM_FIBONACCI_NUMBERS{
static int f_gold ( int n ) {
if ( n <= 0 ) return 0 ;
int fibo [ ] = new int [ n + 1 ] ;
fibo [ 0 ] = 0 ;
fibo [ 1 ] = 1 ;
int sum = fibo [ 0 ] + fibo [ 1 ] ;
for ( int i = 2 ;
i <= n ;
i ++ ) {
fibo [ i ] = fibo [ i - 1 ] + fibo [ i - 2 ] ;
sum += fibo [ i ] ;
}
return sum ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr1 , n , arr2 , m ) :
table = [ 0 ] * m
for j in range ( m ) :
table [ j ] = 0
for i in range ( n ) :
current = 0
for j in range ( m ) :
if ( arr1 [ i ] == arr2 [ j ] ) :
if ( current + 1 > table [ j ] ) :
table [ j ] = current + 1
if ( arr1 [ i ] > arr2 [ j ] ) :
if ( table [ j ] > current ) :
current = table [ j ]
result = 0
for i in range ( m ) :
if ( table [ i ] > result ) :
result = table [ i ]
return result
| java | [
[
"[1, 7, 9, 35, 43, 51, 51, 66, 88], 5, [10, 21, 38, 50, 65, 67, 87, 93, 99], 8",
"0"
],
[
"[-52, 52, -92, -46, -94, 30, -36, 18, -98, 22, -36, 96, -88, -50, 50], 7, [-58, 40, 56, -62, -92, -94, 40, 18, -2, -76, -78, -14, 44, 84, 4], 10",
"1"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0... | f_gold | LONGEST_COMMON_INCREASING_SUBSEQUENCE_LCS_LIS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class LONGEST_COMMON_INCREASING_SUBSEQUENCE_LCS_LIS{
static int f_gold ( int arr1 [ ] , int n , int arr2 [ ] , int m ) {
int table [ ] = new int [ m ] ;
for ( int j = 0 ;
j < m ;
j ++ ) table [ j ] = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
int current = 0 ;
for ( int j = 0 ;
j < m ;
j ++ ) {
if ( arr1 [ i ] == arr2 [ j ] ) if ( current + 1 > table [ j ] ) table [ j ] = current + 1 ;
if ( arr1 [ i ] > arr2 [ j ] ) if ( table [ j ] > current ) current = table [ j ] ;
}
}
int result = 0 ;
for ( int i = 0 ;
i < m ;
i ++ ) if ( table [ i ] > result ) result = table [ i ] ;
return result ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , low , high ) :
if ( high < low ) :
return 0
if ( high == low ) :
return low
mid = low + ( high - low ) / 2 ;
mid = int ( mid )
if ( mid < high and arr [ mid + 1 ] < arr [ mid ] ) :
return ( mid + 1 )
if ( mid > low and arr [ mid ] < arr [ mid - 1 ] ) :
return mid
if ( arr [ high ] > arr [ mid ] ) :
return f_gold ( arr , low , mid - 1 ) ;
return f_gold ( arr , mid + 1 , high )
| java | [
[
"[4, 16, 38, 39, 48, 74, 79], 6, 6",
"6"
],
[
"[-46, 72, 72, -66, 96, 92, 40, 8, 94, -84, 6, -90, 38, -6, 48, -20, -86, -76, 88, -50, -44, -14, 54, -6, -2, 72, 8, -64, -46, 44, -88, 50, 86, 38, 42, -56], 32, 21",
"0"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1,... | f_gold | FIND_ROTATION_COUNT_ROTATED_SORTED_ARRAY_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_ROTATION_COUNT_ROTATED_SORTED_ARRAY_1{
static int f_gold ( int arr [ ] , int low , int high ) {
if ( high < low ) return 0 ;
if ( high == low ) return low ;
int mid = low + ( high - low ) / 2 ;
if ( mid < high && arr [ mid + 1 ] < arr [ mid ] ) return ( mid + 1 ) ;
if ( mid > low && arr [ mid ] < arr [ mid - 1 ] ) return mid ;
if ( arr [ high ] > arr [ mid ] ) return f_gold ( arr , low , mid - 1 ) ;
return f_gold ( arr , mid + 1 , high ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( set , n ) :
if ( n <= 2 ) :
return n
L = [ [ 0 for x in range ( n ) ] for y in range ( n ) ]
llap = 2
for i in range ( n ) :
L [ i ] [ n - 1 ] = 2
for j in range ( n - 2 , 0 , - 1 ) :
i = j - 1
k = j + 1
while ( i >= 0 and k <= n - 1 ) :
if ( set [ i ] + set [ k ] < 2 * set [ j ] ) :
k += 1
elif ( set [ i ] + set [ k ] > 2 * set [ j ] ) :
L [ i ] [ j ] = 2
i -= 1
else :
L [ i ] [ j ] = L [ j ] [ k ] + 1
llap = max ( llap , L [ i ] [ j ] )
i -= 1
k += 1
while ( i >= 0 ) :
L [ i ] [ j ] = 2
i -= 1
return llap
| java | [
[
"[3, 4, 4, 7, 8, 19, 21, 22, 25, 27, 28, 29, 38, 40, 41, 42, 43, 46, 50, 50, 53, 53, 54, 55, 60, 64, 64, 69, 70, 75, 77, 81, 81, 82, 86, 87, 87, 88, 91, 94, 97], 27",
"4"
],
[
"[40, -6, 50, -18, 42, 78, 38, -90, -44, -42, -86, 78, -68, 2, -32, -20, -44, 54, 80, 54, 70, 26, 82, -14, -74, -20, 74, 8... | f_gold | LENGTH_OF_THE_LONGEST_ARITHMATIC_PROGRESSION_IN_A_SORTED_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class LENGTH_OF_THE_LONGEST_ARITHMATIC_PROGRESSION_IN_A_SORTED_ARRAY{
static int f_gold ( int set [ ] , int n ) {
if ( n <= 2 ) return n ;
int L [ ] [ ] = new int [ n ] [ n ] ;
int llap = 2 ;
for ( int i = 0 ;
i < n ;
i ++ ) L [ i ] [ n - 1 ] = 2 ;
for ( int j = n - 2 ;
j >= 1 ;
j -- ) {
int i = j - 1 , k = j + 1 ;
while ( i >= 0 && k <= n - 1 ) {
if ( set [ i ] + set [ k ] < 2 * set [ j ] ) k ++ ;
else if ( set [ i ] + set [ k ] > 2 * set [ j ] ) {
L [ i ] [ j ] = 2 ;
i -- ;
}
else {
L [ i ] [ j ] = L [ j ] [ k ] + 1 ;
llap = Math . max ( llap , L [ i ] [ j ] ) ;
i -- ;
k ++ ;
}
}
while ( i >= 0 ) {
L [ i ] [ j ] = 2 ;
i -- ;
}
}
return llap ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( x , y ) :
res = 1
for i in range ( y ) :
res = ( res * x ) % 10
return res
| java | [
[
"33, 55",
"7"
],
[
"95, 7",
"5"
],
[
"21, 63",
"1"
],
[
"3, 62",
"9"
],
[
"40, 53",
"0"
],
[
"64, 24",
"6"
],
[
"17, 23",
"3"
],
[
"58, 74",
"4"
],
[
"44, 13",
"4"
],
[
"27, 54",
"9"
]
] | f_gold | FIND_UNIT_DIGIT_X_RAISED_POWER_Y | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_UNIT_DIGIT_X_RAISED_POWER_Y{
static int f_gold ( int x , int y ) {
int res = 1 ;
for ( int i = 0 ;
i < y ;
i ++ ) res = ( res * x ) % 10 ;
return res ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n , m ) :
return ( m * n * ( n + 1 ) * ( m + 1 ) ) // 4
| java | [
[
"86, 70",
"9296385"
],
[
"33, 65",
"1203345"
],
[
"3, 5",
"90"
],
[
"91, 12",
"326508"
],
[
"33, 27",
"212058"
],
[
"13, 75",
"259350"
],
[
"75, 36",
"1898100"
],
[
"58, 64",
"3558880"
],
[
"50, 51",
"1690650"
... | f_gold | NUMBER_RECTANGLES_NM_GRID | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_RECTANGLES_NM_GRID{
public static long f_gold ( int n , int m ) {
return ( m * n * ( n + 1 ) * ( m + 1 ) ) / 4 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( x , y , n ) :
dp = [ 0 for i in range ( n + 1 ) ]
dp [ 0 ] = False
dp [ 1 ] = True
for i in range ( 2 , n + 1 ) :
if ( i - 1 >= 0 and not dp [ i - 1 ] ) :
dp [ i ] = True
elif ( i - x >= 0 and not dp [ i - x ] ) :
dp [ i ] = True
elif ( i - y >= 0 and not dp [ i - y ] ) :
dp [ i ] = True
else :
dp [ i ] = False
return dp [ n ]
| java | [
[
"6, 27, 51",
"False"
],
[
"32, 88, 69",
"True"
],
[
"99, 18, 48",
"False"
],
[
"22, 1, 74",
"True"
],
[
"26, 78, 95",
"False"
],
[
"67, 51, 27",
"True"
],
[
"69, 57, 91",
"True"
],
[
"39, 8, 9",
"False"
],
[
"7, 82... | f_gold | COIN_GAME_WINNER_EVERY_PLAYER_THREE_CHOICES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COIN_GAME_WINNER_EVERY_PLAYER_THREE_CHOICES{
static boolean f_gold ( int x , int y , int n ) {
boolean [ ] dp = new boolean [ n + 1 ] ;
Arrays . fill ( dp , false ) ;
dp [ 0 ] = false ;
dp [ 1 ] = true ;
for ( int i = 2 ;
i <= n ;
i ++ ) {
if ( i - 1 >= 0 && dp [ i - 1 ] == false ) dp [ i ] = true ;
else if ( i - x >= 0 && dp [ i - x ] == false ) dp [ i ] = true ;
else if ( i - y >= 0 && dp [ i - y ] == false ) dp [ i ] = true ;
else dp [ i ] = false ;
}
return dp [ n ] ;
}
| [] | |
null | [] | [] | python | code_translation | import collections
def f_gold ( arr , n ) :
q = collections.deque ( [ ] )
arr.sort ( )
q.append ( arr [ 0 ] )
for i in range ( 1 , n ) :
now = q [ 0 ]
if ( arr [ i ] >= 2 * now ) :
q.popleft ( )
q.append ( arr [ i ] )
return len ( q )
| java | [
[
"[2, 3, 17, 17, 18, 28, 28, 29, 34, 43, 44, 52, 54, 80, 84, 84, 91, 92, 97], 12",
"7"
],
[
"[-94, -90, -90, -78, -34, -26, -10, 4, 24, 28, 64, 70, 72, 74, 80, 82], 10",
"2"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1... | f_gold | NUMBER_VISIBLE_BOXES_PUTTING_ONE_INSIDE_ANOTHER | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_VISIBLE_BOXES_PUTTING_ONE_INSIDE_ANOTHER{
static int f_gold ( int [ ] arr , int n ) {
Queue < Integer > q = new LinkedList < > ( ) ;
Arrays . sort ( arr ) ;
q . add ( arr [ 0 ] ) ;
for ( int i = 1 ;
i < n ;
i ++ ) {
int now = q . element ( ) ;
if ( arr [ i ] >= 2 * now ) q . remove ( ) ;
q . add ( arr [ i ] ) ;
}
return q . size ( ) ;
}
| [
"import collections"
] | |
null | [] | [] | python | code_translation | def f_gold ( k ) :
return k * k * k
| java | [
[
"57",
"185193"
],
[
"96",
"884736"
],
[
"14",
"2744"
],
[
"64",
"262144"
],
[
"24",
"13824"
],
[
"74",
"405224"
],
[
"85",
"614125"
],
[
"27",
"19683"
],
[
"78",
"474552"
],
[
"1",
"1"
]
] | f_gold | SUM_K_TH_GROUP_ODD_POSITIVE_NUMBERS_1 | 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_1{
public static int f_gold ( int k ) {
return k * k * k ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
A = [ 0 ] * ( n + 1 )
B = [ 0 ] * ( n + 1 )
A [ 0 ] = 1
A [ 1 ] = 0
B [ 0 ] = 0
B [ 1 ] = 1
for i in range ( 2 , n + 1 ) :
A [ i ] = A [ i - 2 ] + 2 * B [ i - 1 ]
B [ i ] = A [ i - 1 ] + B [ i - 2 ]
return A [ n ]
| java | [
[
"29",
"0"
],
[
"13",
"0"
],
[
"25",
"0"
],
[
"65",
"0"
],
[
"27",
"0"
],
[
"42",
"808717138331"
],
[
"19",
"0"
],
[
"50",
"156886956080403"
],
[
"59",
"0"
],
[
"13",
"0"
]
] | f_gold | TILING_WITH_DOMINOES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class TILING_WITH_DOMINOES{
static int f_gold ( int n ) {
int [ ] A = new int [ n + 1 ] ;
int [ ] B = new int [ n + 1 ] ;
A [ 0 ] = 1 ;
A [ 1 ] = 0 ;
B [ 0 ] = 0 ;
B [ 1 ] = 1 ;
for ( int i = 2 ;
i <= n ;
i ++ ) {
A [ i ] = A [ i - 2 ] + 2 * B [ i - 1 ] ;
B [ i ] = A [ i - 1 ] + B [ i - 2 ] ;
}
return A [ n ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , b ) :
if a == 0 :
return b
return f_gold ( b % a , a )
| java | [
[
"46, 89",
"1"
],
[
"26, 82",
"2"
],
[
"40, 12",
"4"
],
[
"58, 4",
"2"
],
[
"25, 44",
"1"
],
[
"2, 87",
"1"
],
[
"8, 65",
"1"
],
[
"21, 87",
"3"
],
[
"82, 10",
"2"
],
[
"17, 61",
"1"
]
] | f_gold | BASIC_AND_EXTENDED_EUCLIDEAN_ALGORITHMS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class BASIC_AND_EXTENDED_EUCLIDEAN_ALGORITHMS{
public static int f_gold ( int a , int b ) {
if ( a == 0 ) return b ;
return f_gold ( b % a , a ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n , k ) :
if ( k > n ) :
return - 1
sum = arr [ 0 ]
for i in range ( 1 , k ) :
sum += arr [ i ]
max_sum = sum
max_end = k - 1
for i in range ( k , n ) :
sum = sum + arr [ i ] - arr [ i - k ]
if ( sum > max_sum ) :
max_sum = sum
max_end = i
return max_end - k + 1
| java | [
[
"[2, 5, 11, 37, 41, 49, 49, 63, 98], 8, 7",
"1"
],
[
"[84, -72, 12, 0, 86, -32, -18, 48, 60, 42, 8, -6, -10, -6, -52, -84, -98, 76, -10, -14, -94, -48, 94, -10, -20, 40, -52, 0, 94, -68, 44, -34, -26, -6, -94, 34, -80, -62, -40, 56, 52, -20, 74, -46, -88, -26, 22], 34, 43",
"-1"
],
[
"... | f_gold | FIND_MAXIMUM_AVERAGE_SUBARRAY_OF_K_LENGTH_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_MAXIMUM_AVERAGE_SUBARRAY_OF_K_LENGTH_1{
static int f_gold ( int arr [ ] , int n , int k ) {
if ( k > n ) return - 1 ;
int sum = arr [ 0 ] ;
for ( int i = 1 ;
i < k ;
i ++ ) sum += arr [ i ] ;
int max_sum = sum , max_end = k - 1 ;
for ( int i = k ;
i < n ;
i ++ ) {
sum = sum + arr [ i ] - arr [ i - k ] ;
if ( sum > max_sum ) {
max_sum = sum ;
max_end = i ;
}
}
return max_end - k + 1 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
inc , dcr = dict ( ) , dict ( )
len_inc , len_dcr = [ 0 ] * n , [ 0 ] * n
longLen = 0
for i in range ( n ) :
len = 0
if inc.get ( arr [ i ] - 1 ) in inc.values ( ) :
len = inc.get ( arr [ i ] - 1 )
inc [ arr [ i ] ] = len_inc [ i ] = len + 1
for i in range ( n - 1 , - 1 , - 1 ) :
len = 0
if dcr.get ( arr [ i ] - 1 ) in dcr.values ( ) :
len = dcr.get ( arr [ i ] - 1 )
dcr [ arr [ i ] ] = len_dcr [ i ] = len + 1
for i in range ( n ) :
if longLen < ( len_inc [ i ] + len_dcr [ i ] - 1 ) :
longLen = len_inc [ i ] + len_dcr [ i ] - 1
return longLen
| java | [
[
"[78], 0",
"0"
],
[
"[-6, -18, -48, 58, -54, 76, 80, -56, 86, 58, -86, -86, -88, 32, 12, 58, 58, -16, 86, -24, 84, 86, 36, 18, 30, -32, -4, -36, -72, -4, 42, 94], 18",
"1"
],
[
"[0, 1], 1",
"1"
],
[
"[92, 26, 72, 8, 66, 28, 34, 61, 28], 5",
"1"
],
[
"[-86, -82, ... | f_gold | LENGTH_LONGEST_STRICT_BITONIC_SUBSEQUENCE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class LENGTH_LONGEST_STRICT_BITONIC_SUBSEQUENCE{
static int f_gold ( int arr [ ] , int n ) {
HashMap < Integer , Integer > inc = new HashMap < Integer , Integer > ( ) ;
HashMap < Integer , Integer > dcr = new HashMap < Integer , Integer > ( ) ;
int len_inc [ ] = new int [ n ] ;
int len_dcr [ ] = new int [ n ] ;
int longLen = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
int len = 0 ;
if ( inc . containsKey ( arr [ i ] - 1 ) ) len = inc . get ( arr [ i ] - 1 ) ;
len_inc [ i ] = len + 1 ;
inc . put ( arr [ i ] , len_inc [ i ] ) ;
}
for ( int i = n - 1 ;
i >= 0 ;
i -- ) {
int len = 0 ;
if ( dcr . containsKey ( arr [ i ] - 1 ) ) len = dcr . get ( arr [ i ] - 1 ) ;
len_dcr [ i ] = len + 1 ;
dcr . put ( arr [ i ] , len_dcr [ i ] ) ;
}
for ( int i = 0 ;
i < n ;
i ++ ) if ( longLen < ( len_inc [ i ] + len_dcr [ i ] - 1 ) ) longLen = len_inc [ i ] + len_dcr [ i ] - 1 ;
return longLen ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( A , arr_size , sum ) :
for i in range ( 0 , arr_size - 2 ) :
for j in range ( i + 1 , arr_size - 1 ) :
for k in range ( j + 1 , arr_size ) :
if A [ i ] + A [ j ] + A [ k ] == sum :
print ( "Triplet is" , A [ i ] , ", " , A [ j ] , ", " , A [ k ] )
return True
return False
| java | [
[
"[15, 18, 38, 47, 75, 88], 5, 4",
"False"
],
[
"[28, -2, 62, 38, 86, -86, 56, 58, 96, 6, -28, 8, 68, -16, -80, -4, 98, -92, 4, -4, 58, -62, 46, 64], 22, 18",
"True"
],
[
"[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, ... | f_gold | FIND_A_TRIPLET_THAT_SUM_TO_A_GIVEN_VALUE | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_A_TRIPLET_THAT_SUM_TO_A_GIVEN_VALUE{
static boolean f_gold ( int A [ ] , int arr_size , int sum ) {
int l , r ;
for ( int i = 0 ;
i < arr_size - 2 ;
i ++ ) {
for ( int j = i + 1 ;
j < arr_size - 1 ;
j ++ ) {
for ( int k = j + 1 ;
k < arr_size ;
k ++ ) {
if ( A [ i ] + A [ j ] + A [ k ] == sum ) {
System . out . print ( "Triplet is " + A [ i ] + ", " + A [ j ] + ", " + A [ k ] ) ;
return true ;
}
}
}
}
return false ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
if ( n <= 1 ) :
return False
for i in range ( 2 , n ) :
if ( n % i == 0 ) :
return False
return True
| java | [
[
"2",
"True"
],
[
"74",
"False"
],
[
"46",
"False"
],
[
"38",
"False"
],
[
"51",
"False"
],
[
"48",
"False"
],
[
"6",
"False"
],
[
"14",
"False"
],
[
"31",
"True"
],
[
"10",
"False"
]
] | f_gold | PRIME_NUMBERS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class PRIME_NUMBERS{
static boolean f_gold ( int n ) {
if ( n <= 1 ) return false ;
for ( int i = 2 ;
i < n ;
i ++ ) if ( n % i == 0 ) return false ;
return true ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
return int ( ( n * ( 2 * n - 1 ) * ( 2 * n + 1 ) ) / 3 )
| java | [
[
"84",
"790244"
],
[
"74",
"540274"
],
[
"91",
"1004731"
],
[
"34",
"52394"
],
[
"36",
"62196"
],
[
"28",
"29260"
],
[
"70",
"457310"
],
[
"7",
"455"
],
[
"24",
"18424"
],
[
"47",
"138415"
]
] | f_gold | SUM_SERIES_12_32_52_2N_12_1 | 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_1{
static int f_gold ( int n ) {
return ( n * ( 2 * n - 1 ) * ( 2 * n + 1 ) ) / 3 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
if n < 3 :
return - 1
arr.sort ( )
return max ( arr [ 0 ] * arr [ 1 ] * arr [ n - 1 ] , arr [ n - 1 ] * arr [ n - 2 ] * arr [ n - 3 ] )
| java | [
[
"[5, 8, 14, 15, 18, 21, 21, 21, 27, 29, 30, 33, 34, 34, 35, 37, 40, 41, 44, 44, 46, 49, 54, 58, 60, 61, 61, 63, 66, 69, 69, 70, 81, 82, 82, 90, 90, 90, 91, 92, 92, 96, 97, 99], 39",
"737100"
],
[
"[-98, -98, -90, -88, -76, -66, -60, -58, -56, -52, -50, -32, -32, -22, -2, 12, 18, 28, 32, 48, 50, 56... | f_gold | FIND_MAXIMUM_PRODUCT_OF_A_TRIPLET_IN_ARRAY_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_MAXIMUM_PRODUCT_OF_A_TRIPLET_IN_ARRAY_1{
static int f_gold ( int arr [ ] , int n ) {
if ( n < 3 ) {
return - 1 ;
}
Arrays . sort ( arr ) ;
return Math . max ( arr [ 0 ] * arr [ 1 ] * arr [ n - 1 ] , arr [ n - 1 ] * arr [ n - 2 ] * arr [ n - 3 ] ) ;
}
| [] | |
null | [] | [] | python | code_translation | import math
def f_gold(N):
return math.ceil(math.log2(N + 1)) - 1
| java | [
[
"65",
"6"
],
[
"94",
"6"
],
[
"52",
"5"
],
[
"31",
"4"
],
[
"9",
"3"
],
[
"1",
"0"
],
[
"41",
"5"
],
[
"98",
"6"
],
[
"45",
"5"
],
[
"24",
"4"
]
] | f_gold | HEIGHT_COMPLETE_BINARY_TREE_HEAP_N_NODES | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class HEIGHT_COMPLETE_BINARY_TREE_HEAP_N_NODES{
static int f_gold ( int N ) {
return ( int ) Math . ceil ( Math . log ( N + 1 ) / Math . log ( 2 ) ) - 1 ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | def f_gold ( no ) :
return 0 if no == 0 else int ( no % 10 ) + f_gold ( int ( no / 10 ) )
| java | [
[
"73",
"10"
],
[
"91",
"10"
],
[
"27",
"9"
],
[
"79",
"16"
],
[
"31",
"4"
],
[
"84",
"12"
],
[
"68",
"14"
],
[
"9",
"9"
],
[
"85",
"13"
],
[
"35",
"8"
]
] | f_gold | HOW_CAN_WE_SUM_THE_DIGITS_OF_A_GIVEN_NUMBER_IN_SINGLE_STATEMENT_2 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class HOW_CAN_WE_SUM_THE_DIGITS_OF_A_GIVEN_NUMBER_IN_SINGLE_STATEMENT_2{
static int f_gold ( int no ) {
return no == 0 ? 0 : no % 10 + f_gold ( no / 10 ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
remainder = 0
for i in range ( 0 , n ) :
remainder = ( remainder + arr [ i ] ) % 3
return ( remainder == 0 )
| java | [
[
"[2, 4, 9, 11, 12, 15, 16, 19, 21, 21, 23, 23, 24, 30, 31, 31, 32, 34, 37, 41, 41, 43, 45, 46, 47, 54, 58, 60, 62, 66, 66, 74, 74, 75, 75, 77, 77, 85, 89, 90, 92, 92, 93, 95, 98], 30",
"False"
],
[
"[0, 66, 92, 24, -8, 88, -92, 86, 80, 82, 42, -20, -56, -2, -84, 32], 14",
"False"
],
[
... | f_gold | POSSIBLE_TO_MAKE_A_DIVISIBLE_BY_3_NUMBER_USING_ALL_DIGITS_IN_AN_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class POSSIBLE_TO_MAKE_A_DIVISIBLE_BY_3_NUMBER_USING_ALL_DIGITS_IN_AN_ARRAY{
public static boolean f_gold ( int arr [ ] , int n ) {
int remainder = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) remainder = ( remainder + arr [ i ] ) % 3 ;
return ( remainder == 0 ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , b ) :
m = len ( a )
n = len ( b )
lookup = [ [ 0 ] * ( n + 1 ) for i in range ( m + 1 ) ]
for i in range ( n + 1 ) :
lookup [ 0 ] [ i ] = 0
for i in range ( m + 1 ) :
lookup [ i ] [ 0 ] = 1
for i in range ( 1 , m + 1 ) :
for j in range ( 1 , n + 1 ) :
if a [ i - 1 ] == b [ j - 1 ] :
lookup [ i ] [ j ] = lookup [ i - 1 ] [ j - 1 ] + lookup [ i - 1 ] [ j ]
else :
lookup [ i ] [ j ] = lookup [ i - 1 ] [ j ]
return lookup [ m ] [ n ]
| java | [
[
"'fZOKCdZ Lav', 'fKA'",
"0"
],
[
"'2', '187012'",
"0"
],
[
"'1000001110', '0'",
"6"
],
[
"'IAOyBzgIWHo', 'oA'",
"0"
],
[
"'211806', '10'",
"2"
],
[
"'1', '001011100'",
"0"
],
[
"'CVaQTG', 'CT'",
"1"
],
[
"'6265187228', '628'",... | f_gold | FIND_NUMBER_TIMES_STRING_OCCURS_GIVEN_STRING_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_NUMBER_TIMES_STRING_OCCURS_GIVEN_STRING_1{
static int f_gold ( String a , String b ) {
int m = a . length ( ) ;
int n = b . length ( ) ;
int lookup [ ] [ ] = new int [ m + 1 ] [ n + 1 ] ;
for ( int i = 0 ;
i <= n ;
++ i ) lookup [ 0 ] [ i ] = 0 ;
for ( int i = 0 ;
i <= m ;
++ i ) lookup [ i ] [ 0 ] = 1 ;
for ( int i = 1 ;
i <= m ;
i ++ ) {
for ( int j = 1 ;
j <= n ;
j ++ ) {
if ( a . charAt ( i - 1 ) == b . charAt ( j - 1 ) ) lookup [ i ] [ j ] = lookup [ i - 1 ] [ j - 1 ] + lookup [ i - 1 ] [ j ] ;
else lookup [ i ] [ j ] = lookup [ i - 1 ] [ j ] ;
}
}
return lookup [ m ] [ n ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , size , KthIndex ) :
dict = { }
vect = [ ]
for i in range ( size ) :
if ( arr [ i ] in dict ) :
dict [ arr [ i ] ] = dict [ arr [ i ] ] + 1
else :
dict [ arr [ i ] ] = 1
for i in range ( size ) :
if ( dict [ arr [ i ] ] > 1 ) :
continue
else :
KthIndex = KthIndex - 1
if ( KthIndex == 0 ) :
return arr [ i ]
return - 1
| java | [
[
"[17, 25, 27, 27, 73, 91], 5, 3",
"73"
],
[
"[-86, -74, -88, 28, -32, 20, -34, 32], 5, 6",
"-1"
],
[
"[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], 33, 32",
"-1"
],
[
"[5, 11, 36, 27, 6, 24, 58, 44, 14, 68],... | f_gold | K_TH_DISTINCT_OR_NON_REPEATING_ELEMENT_IN_AN_ARRAY_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class K_TH_DISTINCT_OR_NON_REPEATING_ELEMENT_IN_AN_ARRAY_1{
static int f_gold ( int arr [ ] , int n , int k ) {
Map < Integer , Integer > h = new HashMap < Integer , Integer > ( ) ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( h . containsKey ( arr [ i ] ) ) h . put ( arr [ i ] , h . get ( arr [ i ] ) + 1 ) ;
else h . put ( arr [ i ] , 1 ) ;
}
if ( h . size ( ) < k ) return - 1 ;
int dist_count = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( h . get ( arr [ i ] ) == 1 ) dist_count ++ ;
if ( dist_count == k ) return arr [ i ] ;
}
return - 1 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n ) :
temp = [ 0 ] * n
for i in range ( n ) :
temp [ i ] = arr [ i ]
temp.sort ( )
for front in range ( n ) :
if temp [ front ] != arr [ front ] :
break
for back in range ( n - 1 , - 1 , - 1 ) :
if temp [ back ] != arr [ back ] :
break
if front >= back :
return True
while front != back :
front += 1
if arr [ front - 1 ] < arr [ front ] :
return False
return True
| java | [
[
"[5, 9, 9, 16, 17, 22, 32, 40, 45, 53, 57, 58, 66, 69, 76, 80, 91, 93, 94], 10",
"True"
],
[
"[52, -76, -18, 86, 56], 3",
"False"
],
[
"[0, 0, 1], 1",
"True"
],
[
"[66, 44, 98, 44], 2",
"True"
],
[
"[-96, -62, -56, -46, -44, -38, -38, -26, -22, -22, -16, -12, -6... | f_gold | CHECK_REVERSING_SUB_ARRAY_MAKE_ARRAY_SORTED | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class CHECK_REVERSING_SUB_ARRAY_MAKE_ARRAY_SORTED{
static boolean f_gold ( int arr [ ] , int n ) {
int temp [ ] = new int [ n ] ;
for ( int i = 0 ;
i < n ;
i ++ ) {
temp [ i ] = arr [ i ] ;
}
Arrays . sort ( temp ) ;
int front ;
for ( front = 0 ;
front < n ;
front ++ ) {
if ( temp [ front ] != arr [ front ] ) {
break ;
}
}
int back ;
for ( back = n - 1 ;
back >= 0 ;
back -- ) {
if ( temp [ back ] != arr [ back ] ) {
break ;
}
}
if ( front >= back ) {
return true ;
}
do {
front ++ ;
if ( arr [ front - 1 ] < arr [ front ] ) {
return false ;
}
}
while ( front != back ) ;
return true ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( num ) :
series = [ 1 , 3 , 2 , - 1 , - 3 , - 2 ] ;
series_index = 0 ;
result = 0 ;
for i in range ( ( len ( num ) - 1 ) , - 1 , - 1 ) :
digit = ord ( num [ i ] ) - 48 ;
result += digit * series [ series_index ] ;
series_index = ( series_index + 1 ) % 6 ;
result %= 7 ;
if ( result < 0 ) :
result = ( result + 7 ) % 7 ;
return result ;
| java | [
[
"'K'",
"6"
],
[
"'850076'",
"3"
],
[
"'00111'",
"6"
],
[
"'X'",
"5"
],
[
"'1'",
"1"
],
[
"'10010001100'",
"1"
],
[
"' pgPeLz'",
"0"
],
[
"'53212456821275'",
"3"
],
[
"'101'",
"3"
],
[
"'V'",
"3"
]... | f_gold | REMAINDER_7_LARGE_NUMBERS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class REMAINDER_7_LARGE_NUMBERS{
static int f_gold ( String num ) {
int series [ ] = {
1 , 3 , 2 , - 1 , - 3 , - 2 };
int series_index = 0 ;
int result = 0 ;
for ( int i = num . length ( ) - 1 ;
i >= 0 ;
i -- ) {
int digit = num . charAt ( i ) - '0' ;
result += digit * series [ series_index ] ;
series_index = ( series_index + 1 ) % 6 ;
result %= 7 ;
}
if ( result < 0 ) result = ( result + 7 ) % 7 ;
return result ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
dp = [ 0 for i in range ( n + 1 ) ]
for i in range ( n + 1 ) :
if ( i <= 2 ) :
dp [ i ] = i
else :
dp [ i ] = dp [ i - 1 ] + ( i - 1 ) * dp [ i - 2 ]
return dp [ n ]
| java | [
[
"99",
"2293787513721395580144886572049456639156084025485931929781630885397779219218432000"
],
[
"62",
"1890816383932031941325296356597295736721047552"
],
[
"87",
"1913739316913202783355790595270439314300178051408817240769643782602752"
],
[
"87",
"19137393169132027833557... | f_gold | FRIENDS_PAIRING_PROBLEM | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FRIENDS_PAIRING_PROBLEM{
static int f_gold ( int n ) {
int dp [ ] = new int [ n + 1 ] ;
for ( int i = 0 ;
i <= n ;
i ++ ) {
if ( i <= 2 ) dp [ i ] = i ;
else dp [ i ] = dp [ i - 1 ] + ( i - 1 ) * dp [ i - 2 ] ;
}
return dp [ n ] ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
count = 0
if ( n and ( not ( n & ( n - 1 ) ) ) ) :
while ( n > 1 ) :
n >>= 1
count += 1
if ( count % 2 == 0 ) :
return True
else :
return False
| java | [
[
"1",
"True"
],
[
"4",
"True"
],
[
"64",
"True"
],
[
"-64",
"None"
],
[
"128",
"False"
],
[
"1024",
"True"
],
[
"45",
"None"
],
[
"33",
"None"
],
[
"66",
"None"
],
[
"74",
"None"
]
] | f_gold | FIND_WHETHER_A_GIVEN_NUMBER_IS_A_POWER_OF_4_OR_NOT_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_WHETHER_A_GIVEN_NUMBER_IS_A_POWER_OF_4_OR_NOT_1{
static int f_gold ( int n ) {
int count = 0 ;
int x = n & ( n - 1 ) ;
if ( n > 0 && x == 0 ) {
while ( n > 1 ) {
n >>= 1 ;
count += 1 ;
}
return ( count % 2 == 0 ) ? 1 : 0 ;
}
return 0 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( N ) :
if ( N == 1 ) :
return 4
countB = 1
countS = 1
for i in range ( 2 , N + 1 ) :
prev_countB = countB
prev_countS = countS
countS = prev_countB + prev_countS
countB = prev_countS
result = countS + countB
return ( result * result )
| java | [
[
"17",
"17480761"
],
[
"66",
"5288701670462944237293955881"
],
[
"53",
"19483654655064681378025"
],
[
"97",
"47927278105176659888288635888015429788676"
],
[
"34",
"222915410843904"
],
[
"54",
"51008870112024444436089"
],
[
"9",
"7921"
... | f_gold | COUNT_POSSIBLE_WAYS_TO_CONSTRUCT_BUILDINGS | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class COUNT_POSSIBLE_WAYS_TO_CONSTRUCT_BUILDINGS{
static int f_gold ( int N ) {
if ( N == 1 ) return 4 ;
int countB = 1 , countS = 1 , prev_countB , prev_countS ;
for ( int i = 2 ;
i <= N ;
i ++ ) {
prev_countB = countB ;
prev_countS = countS ;
countS = prev_countB + prev_countS ;
countB = prev_countS ;
}
int result = countS + countB ;
return ( result * result ) ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( n ) :
multiTerms = n * ( n + 1 ) // 2
sm = multiTerms
for i in range ( 2 , n + 1 ) :
multiTerms = multiTerms - ( i - 1 )
sm = sm + multiTerms * i
return sm
| java | [
[
"41",
"382571"
],
[
"50",
"834275"
],
[
"67",
"2645897"
],
[
"18",
"15675"
],
[
"60",
"1711355"
],
[
"6",
"266"
],
[
"27",
"74907"
],
[
"46",
"601036"
],
[
"50",
"834275"
],
[
"20",
"23485"
]
] | f_gold | SUM_PAIRWISE_PRODUCTS_1 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class SUM_PAIRWISE_PRODUCTS_1{
static int f_gold ( int n ) {
int multiTerms = n * ( n + 1 ) / 2 ;
int sum = multiTerms ;
for ( int i = 2 ;
i <= n ;
i ++ ) {
multiTerms = multiTerms - ( i - 1 ) ;
sum = sum + multiTerms * i ;
}
return sum ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , b , n , m ) :
countA = dict ( )
countB = dict ( )
for i in range ( n ) :
countA [ a [ i ] ] = countA.get ( a [ i ] , 0 ) + 1
for i in range ( n ) :
countB [ b [ i ] ] = countB.get ( b [ i ] , 0 ) + 1
res = 0
for x in countA :
if x in countB.keys ( ) :
res += min ( countA [ x ] , countB [ x ] )
return res
| java | [
[
"[4, 7, 10, 12, 12, 24, 29, 38, 45, 51, 53, 54, 59, 68, 72, 73, 85, 86, 88, 92, 92, 95], [7, 9, 17, 23, 25, 26, 29, 32, 35, 56, 56, 58, 59, 59, 62, 63, 72, 82, 85, 86, 95, 97], 15, 13",
"3"
],
[
"[-6, 48, -70, 14, -86, 56, 80, -64, 64, -88, -14, 78, 14, -18, 52, 2, 22, 88], [-62, -58, 60, -30, 42,... | f_gold | REMOVE_MINIMUM_NUMBER_ELEMENTS_NO_COMMON_ELEMENT_EXIST_ARRAY | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class REMOVE_MINIMUM_NUMBER_ELEMENTS_NO_COMMON_ELEMENT_EXIST_ARRAY{
public static int f_gold ( int a [ ] , int b [ ] , int n , int m ) {
HashMap < Integer , Integer > countA = new HashMap < Integer , Integer > ( ) ;
HashMap < Integer , Integer > countB = new HashMap < Integer , Integer > ( ) ;
for ( int i = 0 ;
i < n ;
i ++ ) {
if ( countA . containsKey ( a [ i ] ) ) countA . put ( a [ i ] , countA . get ( a [ i ] ) + 1 ) ;
else countA . put ( a [ i ] , 1 ) ;
}
for ( int i = 0 ;
i < m ;
i ++ ) {
if ( countB . containsKey ( b [ i ] ) ) countB . put ( b [ i ] , countB . get ( b [ i ] ) + 1 ) ;
else countB . put ( b [ i ] , 1 ) ;
}
int res = 0 ;
Set < Integer > s = countA . keySet ( ) ;
for ( int x : s ) if ( countB . containsKey ( x ) ) res += Math . min ( countB . get ( x ) , countA . get ( x ) ) ;
return res ;
}
| [] | |
null | [] | [] | python | code_translation | import math
def f_gold ( n ) :
nthElement = 19 + ( n - 1 ) * 9
outliersCount = int ( math.log10 ( nthElement ) ) - 1
nthElement += 9 * outliersCount
return nthElement
| java | [
[
"68",
"631"
],
[
"70",
"649"
],
[
"69",
"640"
],
[
"93",
"856"
],
[
"99",
"910"
],
[
"44",
"415"
],
[
"91",
"838"
],
[
"8",
"82"
],
[
"83",
"766"
],
[
"51",
"478"
]
] | f_gold | N_TH_NUMBER_WHOSE_SUM_OF_DIGITS_IS_TEN_2 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class N_TH_NUMBER_WHOSE_SUM_OF_DIGITS_IS_TEN_2{
public static int f_gold ( int n ) {
int nthElement = 19 + ( n - 1 ) * 9 ;
int outliersCount = ( int ) Math . log10 ( nthElement ) - 1 ;
nthElement += 9 * outliersCount ;
return nthElement ;
}
| [
"import math"
] | |
null | [] | [] | python | code_translation | def f_gold ( arr , n , k ) :
if k > n :
return - 1
csum = [ 0 ] * n
csum [ 0 ] = arr [ 0 ]
for i in range ( 1 , n ) :
csum [ i ] = csum [ i - 1 ] + arr [ i ] ;
max_sum = csum [ k - 1 ]
max_end = k - 1
for i in range ( k , n ) :
curr_sum = csum [ i ] - csum [ i - k ]
if curr_sum > max_sum :
max_sum = curr_sum
max_end = i
return max_end - k + 1
| java | [
[
"[2, 4, 6, 19, 21, 23, 32, 34, 47, 51, 56, 57, 57, 65, 68, 68, 69, 70, 71, 73, 74, 74, 77, 77, 79, 82, 82, 86, 87, 87, 88, 89, 90, 91, 92], 29, 20",
"9"
],
[
"[24, 62, -32, -28, 42, -46, -96, -70, -68, 60, 44, 34, -30, 96, -26, 92, 62, 42, -46, -38, 44, 54, -94, 52, 66, 68, -96, -58, 84, -2, 66, 3... | f_gold | FIND_MAXIMUM_AVERAGE_SUBARRAY_OF_K_LENGTH | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class FIND_MAXIMUM_AVERAGE_SUBARRAY_OF_K_LENGTH{
static int f_gold ( int [ ] arr , int n , int k ) {
if ( k > n ) return - 1 ;
int [ ] csum = new int [ n ] ;
csum [ 0 ] = arr [ 0 ] ;
for ( int i = 1 ;
i < n ;
i ++ ) csum [ i ] = csum [ i - 1 ] + arr [ i ] ;
int max_sum = csum [ k - 1 ] , max_end = k - 1 ;
for ( int i = k ;
i < n ;
i ++ ) {
int curr_sum = csum [ i ] - csum [ i - k ] ;
if ( curr_sum > max_sum ) {
max_sum = curr_sum ;
max_end = i ;
}
}
return max_end - k + 1 ;
}
| [] | |
null | [] | [] | python | code_translation | def f_gold ( a , n ) :
count = 0
for i in range ( 0 , n ) :
for j in range ( i + 1 , n ) :
if ( a [ i ] & a [ j ] ) == 0 :
count += 2
return count
| java | [
[
"[17, 20, 32, 35, 35, 36, 43, 47, 59, 59, 68, 69, 70, 70, 75, 82, 88, 94, 96, 99], 17",
"54"
],
[
"[-78, -40, 58, -36, 34, -12, -38, 48, -66, 16, 50, -26, -22, 46, -70, -68, -44, -52, -78, -50], 11",
"6"
],
[
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, ... | f_gold | NUMBER_ORDERED_PAIRS_AI_AJ_0 | transcoder-geeksforgeeks |
import java.util. *;
import java.util.stream.*;
import java.lang.*;
import javafx.util.Pair;
public class NUMBER_ORDERED_PAIRS_AI_AJ_0{
static int f_gold ( int a [ ] , int n ) {
int count = 0 ;
for ( int i = 0 ;
i < n ;
i ++ ) {
for ( int j = i + 1 ;
j < n ;
j ++ ) if ( ( a [ i ] & a [ j ] ) == 0 ) count += 2 ;
}
return count ;
}
| [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.