qid stringlengths 1 3 | title stringlengths 9 106 | language stringclasses 1
value | signature stringlengths 24 145 | arguments list | source_py stringlengths 54 989 | source_cpp stringlengths 59 951 | question_info dict |
|---|---|---|---|---|---|---|---|
107 | Count Set Bits In An Integer | C++ | int countSetBitsInAnInteger(int n) { | [
"n"
] | def count_set_bits_in_an_integer(n):
count = 0
while n:
count += (n & 1)
n >>= 1
return count | unsigned int count_set_bits_in_an_integer(unsigned int n) {
unsigned int count = 0;
while ( n ) {
count += n & 1;
n >>= 1;
}
return count;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
108 | Count Set Bits In An Integer 1 | C++ | int countSetBitsInAnInteger1(int n) { | [
"n"
] | def count_set_bits_in_an_integer_1(n):
if (n == 0):
return 0
else:
return ((n & 1) + count_set_bits_in_an_integer_1((n >> 1))) | int count_set_bits_in_an_integer_1(int n) {
if ( n == 0 ) return 0;
else return ( n & 1 ) + count_set_bits_in_an_integer_1 ( n >> 1 );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
109 | Count Set Bits In An Integer 3 | C++ | int countSetBitsInAnInteger3(int n) { | [
"n"
] | def count_set_bits_in_an_integer_3(n):
if (n == 0):
return 0
else:
return (1 + count_set_bits_in_an_integer_3((n & (n - 1)))) | int count_set_bits_in_an_integer_3(int n) {
if ( n == 0 ) return 0;
else return 1 + count_set_bits_in_an_integer_3 ( n & ( n - 1 ) );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
110 | Count Strings Adjacent Characters Difference One | C++ | long long countStringsAdjacentCharactersDifferenceOne(int n) { | [
"n"
] | def count_strings_adjacent_characters_difference_one(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:
... | int count_strings_adjacent_characters_difference_one(int n) {
long int dp [ n + 1 ] [ 27 ];
memset ( dp, 0, sizeof ( dp ) );
for ( int i = 0;
i <= 25;
i ++ ) dp [ 1 ] [ i ] = 1;
for ( int i = 2;
i <= n;
i ++ ) {
for ( int j = 0;
j <= 25;
j ++ ) if ( j == 0 ) dp [ i ] [ j ] = dp [ i - 1 ] [ j... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
111 | Count Strings Can Formed Using B C Given Constraints 1 | C++ | int countStringsCanFormedUsingBCGivenConstraints1(int n) { | [
"n"
] | def count_strings_can_formed_using_b_c_given_constraints_1(n):
return ((1 + (n * 2)) + ((n * ((n * n) - 1)) // 2)) | int count_strings_can_formed_using_b_c_given_constraints_1(int n) {
return 1 + ( n * 2 ) + ( n * ( ( n * n ) - 1 ) / 2 );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
112 | Count Strings With Consecutive 1S | C++ | long long countStringsWithConsecutive1S(int n) { | [
"n"
] | def count_strings_with_consecutive_1s(n):
a = ([0] * n)
b = ([0] * n)
a[0] = b[0] = 1
for i in range(1, n):
a[i] = (a[(i - 1)] + b[(i - 1)])
b[i] = a[(i - 1)]
return (((1 << n) - a[(n - 1)]) - b[(n - 1)]) | int count_strings_with_consecutive_1s(int n) {
int a [ n ], b [ n ];
a [ 0 ] = b [ 0 ] = 1;
for ( int i = 1;
i < n;
i ++ ) {
a [ i ] = a [ i - 1 ] + b [ i - 1 ];
b [ i ] = a [ i - 1 ];
}
return ( 1 << n ) - a [ n - 1 ] - b [ n - 1 ];
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
113 | Count Subarrays Equal Number 1S 0S | C++ | int countSubarraysEqualNumber1S0S(vector<int> arr, int n) { | [
"arr",
"n"
] | def count_subarrays_equal_number_1s_0s(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)... | int count_subarrays_equal_number_1s_0s(vector<int> arr, int n) {
unordered_map < int, int > um;
int curr_sum = 0;
for ( int i = 0;
i < n;
i ++ ) {
curr_sum += ( arr [ i ] == 0 ) ? - 1 : arr [ i ];
um [ curr_sum ] ++;
}
int count = 0;
for ( auto itr = um . begin ( );
itr != um . end ( );
itr ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
114 | Count Subarrays Equal Number 1S 0S 1 | C++ | int countSubarraysEqualNumber1S0S1(vector<int> arr, int n) { | [
"arr",
"n"
] | def count_subarrays_equal_number_1s_0s_1(arr, n):
mp = dict()
Sum = 0
count = 0
for i in range(n):
if (arr[i] == 0):
arr[i] = (- 1)
Sum += arr[i]
if (Sum == 0):
count += 1
if (Sum in mp.keys()):
count += mp[Sum]
mp[Sum] = (mp.ge... | int count_subarrays_equal_number_1s_0s_1(vector<int> arr, int n) {
map < int, int > mp;
int sum = 0;
int count = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == 0 ) arr [ i ] = - 1;
sum += arr [ i ];
if ( sum == 0 ) count ++;
if ( mp [ sum ] ) count += mp [ sum ];
if ( mp [ sum ] =... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
115 | Count Subarrays Total Distinct Elements Original Array | C++ | int countSubarraysTotalDistinctElementsOriginalArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def count_subarrays_total_distinct_elements_original_array(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())... | int count_subarrays_total_distinct_elements_original_array(vector<int> arr, int n) {
unordered_map < int, int > vis;
for ( int i = 0;
i < n;
++ i ) vis [ arr [ i ] ] = 1;
int k = vis . size ( );
vis . clear ( );
int ans = 0, right = 0, window = 0;
for ( int left = 0;
left < n;
++ left ) {
while ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
116 | Count Subarrays With Same Even And Odd Elements | C++ | int countSubarraysWithSameEvenAndOddElements(vector<int> arr, int n) { | [
"arr",
"n"
] | def count_subarrays_with_same_even_and_odd_elements(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:
differen... | int count_subarrays_with_same_even_and_odd_elements(vector<int> arr, int n) {
int difference = 0;
int ans = 0;
int hash_positive [ n + 1 ], hash_negative [ n + 1 ];
fill_n ( hash_positive, n + 1, 0 );
fill_n ( hash_negative, n + 1, 0 );
hash_positive [ 0 ] = 1;
for ( int i = 0;
i < n;
i ++ ) {
if ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
117 | Count Substrings With Same First And Last Characters | C++ | int countSubstringsWithSameFirstAndLastCharacters(string s) { | [
"s"
] | def count_substrings_with_same_first_and_last_characters(s):
result = 0
n = len(s)
for i in range(n):
for j in range(i, n):
if (s[i] == s[j]):
result = (result + 1)
return result | int count_substrings_with_same_first_and_last_characters(string s) {
int result = 0;
int n = s . length ( );
for ( int i = 0;
i < n;
i ++ ) for ( int j = i;
j < n;
j ++ ) if ( s [ i ] == s [ j ] ) result ++;
return result;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
118 | Count Sum Of Digits In Numbers From 1 To N | C++ | int countSumOfDigitsInNumbersFrom1ToN(int n) { | [
"n"
] | def count_sum_of_digits_in_numbers_from_1_to_n(n):
if (n < 10):
return ((n * (n + 1)) / 2)
d = int(math.log10(n))
a = ([0] * (d + 1))
a[0] = 0
a[1] = 45
for i in range(2, (d + 1)):
a[i] = ((a[(i - 1)] * 10) + (45 * int(math.ceil(math.pow(10, (i - 1))))))
p = int(math.ceil(mat... | int count_sum_of_digits_in_numbers_from_1_to_n(int n) {
if ( n < 10 ) return n * ( n + 1 ) / 2;
int d = log10 ( n );
int * a = new int [ d + 1 ];
a [ 0 ] = 0, a [ 1 ] = 45;
for ( int i = 2;
i <= d;
i ++ ) a [ i ] = a [ i - 1 ] * 10 + 45 * ceil ( pow ( 10, i - 1 ) );
int p = ceil ( pow ( 10, d ) );
int... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
119 | Count Total Set Bits In All Numbers From 1 To N | C++ | int countTotalSetBitsInAllNumbersFrom1ToN(int n) { | [
"n"
] | def count_total_set_bits_in_all_numbers_from_1_to_n(n):
i = 0
ans = 0
while ((1 << i) <= n):
k = 0
change = (1 << i)
for j in range(0, (n + 1)):
ans += k
if (change == 1):
k = (not k)
change = (1 << i)
else:
... | int count_total_set_bits_in_all_numbers_from_1_to_n(int n) {
int i = 0;
int ans = 0;
while ( ( 1 << i ) <= n ) {
bool k = 0;
int change = 1 << i;
for ( int j = 0;
j <= n;
j ++ ) {
ans += k;
if ( change == 1 ) {
k = ! k;
change = 1 << i;
}
else {
... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
120 | Count Trailing Zeroes Factorial Number | C++ | int countTrailingZeroesFactorialNumber(int n) { | [
"n"
] | def count_trailing_zeroes_factorial_number(n):
count = 0
i = 5
while ((n / i) >= 1):
count += int((n / i))
i *= 5
return int(count) | int count_trailing_zeroes_factorial_number(int n) {
int count = 0;
for ( int i = 5;
n / i >= 1;
i *= 5 ) count += n / i;
return count;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
121 | Count Ways Build Street Given Constraints | C++ | int countWaysBuildStreetGivenConstraints(int n) { | [
"n"
] | def count_ways_build_street_given_constraints(n):
dp = [([0] * (n + 1)) for i in range(2)]
dp[0][1] = 1
dp[1][1] = 2
for i in range(2, (n + 1)):
dp[0][i] = (dp[0][(i - 1)] + dp[1][(i - 1)])
dp[1][i] = ((dp[0][(i - 1)] * 2) + dp[1][(i - 1)])
return (dp[0][n] + dp[1][n]) | long count_ways_build_street_given_constraints(int n) {
long dp [ 2 ] [ n + 1 ];
dp [ 0 ] [ 1 ] = 1;
dp [ 1 ] [ 1 ] = 2;
for ( int i = 2;
i <= n;
i ++ ) {
dp [ 0 ] [ i ] = dp [ 0 ] [ i - 1 ] + dp [ 1 ] [ i - 1 ];
dp [ 1 ] [ i ] = dp [ 0 ] [ i - 1 ] * 2 + dp [ 1 ] [ i - 1 ];
}
return dp [ 0 ] [ n... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
122 | Count Ways Divide Circle Using N Non Intersecting Chords | C++ | long long countWaysDivideCircleUsingNNonIntersectingChords(int a) { | [
"a"
] | def count_ways_divide_circle_using_n_non_intersecting_chords(A):
n = (2 * A)
dpArray = ([0] * (n + 1))
dpArray[0] = 1
dpArray[2] = 1
for i in range(4, (n + 1), 2):
for j in range(0, (i - 1), 2):
dpArray[i] += (dpArray[j] * dpArray[((i - 2) - j)])
return int(dpArray[n]) | int count_ways_divide_circle_using_n_non_intersecting_chords(int A) {
int n = 2 * A;
int dpArray [ n + 1 ] = {
0 };
dpArray [ 0 ] = 1;
dpArray [ 2 ] = 1;
for ( int i = 4;
i <= n;
i += 2 ) {
for ( int j = 0;
j < i - 1;
j += 2 ) {
dpArray [ i ] += ( dpArray [ j ] * dp... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
123 | Count Words Appear Exactly Two Times Array Words | C++ | int countWordsAppearExactlyTwoTimesArrayWords(vector<string> stri, int n) { | [
"stri",
"n"
] | def count_words_appear_exactly_two_times_array_words(stri, n):
m = dict()
for i in range(n):
m[stri[i]] = (m.get(stri[i], 0) + 1)
res = 0
for i in m.values():
if (i == 2):
res += 1
return res | int count_words_appear_exactly_two_times_array_words(vector<string> str, int n) {
unordered_map < string, int > m;
for ( int i = 0;
i < n;
i ++ ) m [ str [ i ] ] += 1;
int res = 0;
for ( auto it = m . begin ( );
it != m . end ( );
it ++ ) if ( ( it -> second == 2 ) ) res ++;
return res;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
125 | C Program Factorial Number | C++ | int cProgramFactorialNumber(int n) { | [
"n"
] | def c_program_factorial_number(n):
return (1 if ((n == 1) or (n == 0)) else (n * c_program_factorial_number((n - 1)))) | unsigned int c_program_factorial_number(unsigned int n) {
if ( n == 0 ) return 1;
return n * c_program_factorial_number ( n - 1 );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
126 | C Program Factorial Number 1 | C++ | long long cProgramFactorialNumber1(int n) { | [
"n"
] | def c_program_factorial_number_1(n):
return (1 if ((n == 1) or (n == 0)) else (n * c_program_factorial_number_1((n - 1)))) | unsigned int c_program_factorial_number_1(unsigned int n) {
int res = 1, i;
for ( i = 2;
i <= n;
i ++ ) res *= i;
return res;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
127 | C Program Factorial Number 2 | C++ | long long cProgramFactorialNumber2(int n) { | [
"n"
] | def c_program_factorial_number_2(n):
return (1 if ((n == 1) or (n == 0)) else (n * c_program_factorial_number_2((n - 1)))) | int c_program_factorial_number_2(int n) {
return ( n == 1 || n == 0 ) ? 1 : n * c_program_factorial_number_2 ( n - 1 );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
128 | C Program Find Largest Element Array 1 | C++ | int cProgramFindLargestElementArray1(vector<int> arr, int n) { | [
"arr",
"n"
] | def c_program_find_largest_element_array_1(arr, n):
return max(arr) | int c_program_find_largest_element_array_1(vector<int> arr, int n) {
return * max_element(arr.begin(), arr.end());
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
129 | Decimal Binary Conversion Without Using Arithmetic Operators | C++ | string decimalBinaryConversionWithoutUsingArithmeticOperators(int n) { | [
"n"
] | def decimal_binary_conversion_without_using_arithmetic_operators(n):
if (n == 0):
return '0'
bin = ''
while (n > 0):
if ((n & 1) == 0):
bin = ('0' + bin)
else:
bin = ('1' + bin)
n = (n >> 1)
return bin | string decimal_binary_conversion_without_using_arithmetic_operators(int n) {
if ( n == 0 ) return "0";
string bin = "";
while ( n > 0 ) {
bin = ( ( n & 1 ) == 0 ? '0' : '1' ) + bin;
n >>= 1;
}
return bin;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
130 | Decimal Representation Given Binary String Divisible 10 Not | C++ | bool decimalRepresentationGivenBinaryStringDivisible10Not(string bin) { | [
"bin"
] | def decimal_representation_given_binary_string_divisible_10_not(bin):
n = len(bin)
if (bin[(n - 1)] == '1'):
return False
sum = 0
i = (n - 2)
while (i >= 0):
if (bin[i] == '1'):
posFromRight = ((n - i) - 1)
if ((posFromRight % 4) == 1):
sum = (... | bool decimal_representation_given_binary_string_divisible_10_not(string bin) {
int n = bin . size ( );
if ( bin [ n - 1 ] == '1' ) return false;
int sum = 0;
for ( int i = n - 2;
i >= 0;
i -- ) {
if ( bin [ i ] == '1' ) {
int posFromRight = n - i - 1;
if ( posFromRight % 4 == 1 ) sum = sum +... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
131 | Decode Median String Original String | C++ | string decodeMedianStringOriginalString(string s) { | [
"s"
] | def decode_median_string_original_string(s):
l = len(s)
s1 = ''
if ((l % 2) == 0):
isEven = True
else:
isEven = False
for i in range(0, l, 2):
if isEven:
s1 = (s[i] + s1)
s1 += s[(i + 1)]
elif ((l - i) > 1):
s1 += s[i]
s... | string decode_median_string_original_string(string s) {
int l = s . length ( );
string s1 = "";
bool isEven = ( l % 2 == 0 ) ? true : false;
for ( int i = 0;
i < l;
i += 2 ) {
if ( isEven ) {
s1 = s [ i ] + s1;
s1 += s [ i + 1 ];
}
else {
if ( l - i > 1 ) {
s1 += s [ i ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
132 | Detect If Two Integers Have Opposite Signs | C++ | bool detectIfTwoIntegersHaveOppositeSigns(int x, int y) { | [
"x",
"y"
] | def detect_if_two_integers_have_opposite_signs(x, y):
return ((x ^ y) < 0) | bool detect_if_two_integers_have_opposite_signs(int x, int y) {
return ( ( x ^ y ) < 0 );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
133 | Dice Throw Problem | C++ | int diceThrowProblem(int m, int n, int x) { | [
"m",
"n",
"x"
] | def dice_throw_problem(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)][(... | int dice_throw_problem(int m, int n, int x) {
int table [ n + 1 ] [ x + 1 ];
memset ( table, 0, sizeof ( table ) );
for ( int j = 1;
j <= m && j <= x;
j ++ ) table [ 1 ] [ j ] = 1;
for ( int i = 2;
i <= n;
i ++ ) for ( int j = 1;
j <= x;
j ++ ) for ( int k = 1;
k <= m && k < j;
k ++ ) table [ i ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
134 | Dice Throw Problem 1 | C++ | long long diceThrowProblem1(int f, int d, int s) { | [
"f",
"d",
"s"
] | def dice_throw_problem_1(f, d, s):
mem = [[0 for i in range((s + 1))] for j in range((d + 1))]
mem[0][0] = 1
for i in range(1, (d + 1)):
for j in range(1, (s + 1)):
mem[i][j] = (mem[i][(j - 1)] + mem[(i - 1)][(j - 1)])
if (((j - f) - 1) >= 0):
mem[i][j] -= mem... | long dice_throw_problem_1(int f, int d, int s) {
long mem [ d + 1 ] [ s + 1 ];
memset ( mem, 0, sizeof mem );
mem [ 0 ] [ 0 ] = 1;
for ( int i = 1;
i <= d;
i ++ ) {
for ( int j = i;
j <= s;
j ++ ) {
mem [ i ] [ j ] = mem [ i ] [ j - 1 ] + mem [ i - 1 ] [ j - 1 ];
if ( j - f - 1 >= 0 ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
135 | Difference Between Highest And Least Frequencies In An Array | C++ | int differenceBetweenHighestAndLeastFrequenciesInAnArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def difference_between_highest_and_least_frequencies_in_an_array(arr, n):
arr.sort()
count = 0
max_count = 0
min_count = n
for i in range(0, (n - 1)):
if (arr[i] == arr[(i + 1)]):
count += 1
continue
else:
max_count = max(max_count, count)
... | int difference_between_highest_and_least_frequencies_in_an_array(vector<int> arr, int n) {
sort(arr.begin(), arr.end());
int count = 0, max_count = 0, min_count = n;
for ( int i = 0;
i < ( n - 1 );
i ++ ) {
if ( arr [ i ] == arr [ i + 1 ] ) {
count += 1;
continue;
}
else {
max_co... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
136 | Difference Maximum Sum Minimum Sum N M Elementsin Review | C++ | int differenceMaximumSumMinimumSumNMElementsinReview(vector<int> arr, int n, int m) { | [
"arr",
"n",
"m"
] | def difference_maximum_sum_minimum_sum_n_m_elementsin_review(arr, n, m):
max = 0
min = 0
arr.sort()
j = (n - 1)
for i in range(m):
min += arr[i]
max += arr[j]
j = (j - 1)
return (max - min) | int difference_maximum_sum_minimum_sum_n_m_elementsin_review(vector<int> arr, int n, int m) {
int max = 0, min = 0;
sort(arr.begin(), arr.end());
for ( int i = 0, j = n - 1;
i < m;
i ++, j -- ) {
min += arr [ i ];
max += arr [ j ];
}
return ( max - min );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
137 | Distributing Items Person Cannot Take Two Items Type | C++ | bool distributingItemsPersonCannotTakeTwoItemsType(vector<int> arr, int n, int k) { | [
"arr",
"n",
"k"
] | def distributing_items_person_cannot_take_two_items_type(arr, n, k):
for i in range(n):
count = 0
for j in range(n):
if (arr[j] == arr[i]):
count += 1
if (count > (2 * k)):
return False
return True | bool distributing_items_person_cannot_take_two_items_type(vector<int> arr, int n, int k) {
int count;
for ( int i = 0;
i < n;
i ++ ) {
count = 0;
for ( int j = 0;
j < n;
j ++ ) {
if ( arr [ j ] == arr [ i ] ) count ++;
if ( count > 2 * k ) return false;
}
}
return true;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
138 | Distributing M Items Circle Size N Starting K Th Position | C++ | int distributingMItemsCircleSizeNStartingKThPosition(int n, int m, int k) { | [
"n",
"m",
"k"
] | def distributing_m_items_circle_size_n_starting_k_th_position(n, m, k):
if (m <= ((n - k) + 1)):
return ((m + k) - 1)
m = (m - ((n - k) + 1))
if ((m % n) == 0):
return n
else:
return (m % n) | int distributing_m_items_circle_size_n_starting_k_th_position(int n, int m, int k) {
if ( m <= n - k + 1 ) return m + k - 1;
m = m - ( n - k + 1 );
return ( m % n == 0 ) ? n : ( m % n );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
139 | Divisibility 9 Using Bitwise Operators | C++ | bool divisibility9UsingBitwiseOperators(int n) { | [
"n"
] | def divisibility_9_using_bitwise_operators(n):
if ((n == 0) or (n == 9)):
return True
if (n < 9):
return False
return divisibility_9_using_bitwise_operators((int((n >> 3)) - int((n & 7)))) | bool divisibility_9_using_bitwise_operators(int n) {
if ( n == 0 || n == 9 ) return true;
if ( n < 9 ) return false;
return divisibility_9_using_bitwise_operators ( ( int ) ( n >> 3 ) - ( int ) ( n & 7 ) );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
140 | Divisibility By 7 | C++ | bool divisibilityBy7(int num) { | [
"num"
] | def divisibility_by_7(num):
if (num < 0):
return divisibility_by_7((- num))
if ((num == 0) or (num == 7)):
return True
if (num < 10):
return False
return divisibility_by_7(((num / 10) - (2 * (num - ((num / 10) * 10))))) | int divisibility_by_7(int num) {
if ( num < 0 ) return divisibility_by_7 ( - num );
if ( num == 0 || num == 7 ) return 1;
if ( num < 10 ) return 0;
return divisibility_by_7 ( num / 10 - 2 * ( num - num / 10 * 10 ) );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
141 | Double Factorial | C++ | long long doubleFactorial(int n) { | [
"n"
] | def double_factorial(n):
if ((n == 0) or (n == 1)):
return 1
return (n * double_factorial((n - 2))) | unsigned int double_factorial(unsigned int n) {
if ( n == 0 || n == 1 ) return 1;
return n * double_factorial ( n - 2 );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
142 | Double Factorial 1 | C++ | long long doubleFactorial1(int n) { | [
"n"
] | def double_factorial_1(n):
res = 1
for i in range(n, (- 1), (- 2)):
if ((i == 0) or (i == 1)):
return res
else:
res *= i | unsigned int double_factorial_1(unsigned int n) {
int res = 1;
for ( int i = n;
i >= 0;
i = i - 2 ) {
if ( i == 0 || i == 1 ) return res;
else res *= i;
}
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
143 | Dyck Path | C++ | double dyckPath(int n) { | [
"n"
] | def dyck_path(n):
res = 1
for i in range(0, n):
res *= ((2 * n) - i)
res /= (i + 1)
return (res / (n + 1)) | int dyck_path(unsigned int n) {
int res = 1;
for ( int i = 0;
i < n;
++ i ) {
res *= ( 2 * n - i );
res /= ( i + 1 );
}
return res / ( n + 1 );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
144 | Dynamic Programming High Effort Vs Low Effort Tasks Problem | C++ | int dynamicProgrammingHighEffortVsLowEffortTasksProblem(vector<int> high, vector<int> low, int n) { | [
"high",
"low",
"n"
] | def dynamic_programming_high_effort_vs_low_effort_tasks_problem(high, low, n):
if (n <= 0):
return 0
return max((high[(n - 1)] + dynamic_programming_high_effort_vs_low_effort_tasks_problem(high, low, (n - 2))), (low[(n - 1)] + dynamic_programming_high_effort_vs_low_effort_tasks_problem(high, low, (n - 1... | int dynamic_programming_high_effort_vs_low_effort_tasks_problem(vector<int> high, vector<int> low, int n) {
if ( n <= 0 ) return 0;
return max ( high [ n - 1 ] + dynamic_programming_high_effort_vs_low_effort_tasks_problem ( high, low, ( n - 2 ) ), low [ n - 1 ] + dynamic_programming_high_effort_vs_low_effort_tasks_... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
145 | Dynamic Programming Set 14 Maximum Sum Increasing Subsequence | C++ | int dynamicProgrammingSet14MaximumSumIncreasingSubsequence(vector<int> arr, int n) { | [
"arr",
"n"
] | def dynamic_programming_set_14_maximum_sum_increasing_subsequence(arr, n):
max = 0
msis = [0 for x in range(n)]
for i in range(n):
msis[i] = arr[i]
for i in range(1, n):
for j in range(i):
if ((arr[i] > arr[j]) and (msis[i] < (msis[j] + arr[i]))):
msis[i] = (m... | int dynamic_programming_set_14_maximum_sum_increasing_subsequence(vector<int> arr, int n) {
int i, j, max = 0;
int msis [ n ];
for ( i = 0;
i < n;
i ++ ) msis [ i ] = arr [ i ];
for ( i = 1;
i < n;
i ++ ) for ( j = 0;
j < i;
j ++ ) if ( arr [ i ] > arr [ j ] && msis [ i ] < msis [ j ] + arr [ i ] ) ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
146 | Dynamic Programming Set 28 Minimum Insertions To Form A Palindrome | C++ | int dynamicProgrammingSet28MinimumInsertionsToFormAPalindrome(vector<char> str, int l, int h) { | [
"str",
"l",
"h"
] | def dynamic_programming_set_28_minimum_insertions_to_form_a_palindrome(str, l, h):
if (l > h):
return sys.maxsize
if (l == h):
return 0
if (l == (h - 1)):
return (0 if (str[l] == str[h]) else 1)
if (str[l] == str[h]):
return dynamic_programming_set_28_minimum_insertions_t... | int dynamic_programming_set_28_minimum_insertions_to_form_a_palindrome(vector<char> str, int l, int h) {
if ( l > h ) return INT_MAX;
if ( l == h ) return 0;
if ( l == h - 1 ) return ( str [ l ] == str [ h ] ) ? 0 : 1;
return ( str [ l ] == str [ h ] ) ? dynamic_programming_set_28_minimum_insertions_to_form_a_p... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
147 | Dynamic Programming Set 36 Cut A Rope To Maximize Product 1 | C++ | long long dynamicProgrammingSet36CutARopeToMaximizeProduct1(int n) { | [
"n"
] | def dynamic_programming_set_36_cut_a_rope_to_maximize_product_1(n):
if ((n == 2) or (n == 3)):
return (n - 1)
res = 1
while (n > 4):
n -= 3
res *= 3
return (n * res) | int dynamic_programming_set_36_cut_a_rope_to_maximize_product_1(int n) {
if ( n == 2 || n == 3 ) return ( n - 1 );
int res = 1;
while ( n > 4 ) {
n -= 3;
res *= 3;
}
return ( n * res );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
149 | Efficient Search In An Array Where Difference Between Adjacent Is 1 | C++ | int efficientSearchInAnArrayWhereDifferenceBetweenAdjacentIs1(vector<int> arr, int n, int x) { | [
"arr",
"n",
"x"
] | def efficient_search_in_an_array_where_difference_between_adjacent_is_1(arr, n, x):
i = 0
while (i <= (n - 1)):
if (arr[i] == x):
return i
i += abs((arr[i] - x))
return (- 1) | int efficient_search_in_an_array_where_difference_between_adjacent_is_1(vector<int> arr, int n, int x) {
int i = 0;
while ( i <= n - 1 ) {
if ( arr [ i ] == x ) return i;
i += abs ( arr [ i ] - x );
}
return - 1;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
150 | Efficient Way Check Whether N Th Fibonacci Number Multiple 10 | C++ | bool efficientWayCheckWhetherNThFibonacciNumberMultiple10(int n) { | [
"n"
] | def efficient_way_check_whether_n_th_fibonacci_number_multiple_10(n):
return ((n % 15) == 0) | bool efficient_way_check_whether_n_th_fibonacci_number_multiple_10(int n) {
return ( n % 15 == 0 );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
151 | Efficient Way To Multiply With 7 | C++ | int efficientWayToMultiplyWith7(int n) { | [
"n"
] | def efficient_way_to_multiply_with_7(n):
return ((n << 3) - n) | long efficient_way_to_multiply_with_7(long n) {
return ( ( n << 3 ) - n );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
152 | Elements To Be Added So That All Elements Of A Range Are Present In Array | C++ | int elementsToBeAddedSoThatAllElementsOfARangeArePresentInArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def elements_to_be_added_so_that_all_elements_of_a_range_are_present_in_array(arr, n):
count = 0
arr.sort()
for i in range(0, (n - 1)):
if ((arr[i] != arr[(i + 1)]) and (arr[i] != (arr[(i + 1)] - 1))):
count += ((arr[(i + 1)] - arr[i]) - 1)
return count | int elements_to_be_added_so_that_all_elements_of_a_range_are_present_in_array(vector<int> arr, int n) {
int count = 0;
sort(arr.begin(), arr.end());
for ( int i = 0;
i < n - 1;
i ++ ) if ( arr [ i ] != arr [ i + 1 ] && arr [ i ] != arr [ i + 1 ] - 1 ) count += arr [ i + 1 ] - arr [ i ] - 1;
return count;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
153 | Eulerian Number 1 | C++ | int eulerianNumber1(int n, int m) { | [
"n",
"m"
] | def eulerian_number_1(n, m):
dp = [[0 for x in range((m + 1))] for y in range((n + 1))]
for i in range(1, (n + 1)):
for j in range(0, (m + 1)):
if (i > j):
if (j == 0):
dp[i][j] = 1
else:
dp[i][j] = (((i - j) * dp[(i - 1... | int eulerian_number_1(int n, int m) {
int dp [ n + 1 ] [ m + 1 ];
memset ( dp, 0, sizeof ( dp ) );
for ( int i = 1;
i <= n;
i ++ ) {
for ( int j = 0;
j <= m;
j ++ ) {
if ( i > j ) {
if ( j == 0 ) dp [ i ] [ j ] = 1;
else dp [ i ] [ j ] = ( ( i - j ) * dp [ i - 1 ] [ j - 1 ] )... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
154 | Eulers Criterion Check If Square Root Under Modulo P Exists | C++ | bool eulersCriterionCheckIfSquareRootUnderModuloPExists(int n, int p) { | [
"n",
"p"
] | def eulers_criterion_check_if_square_root_under_modulo_p_exists(n, p):
n = (n % p)
for x in range(2, p, 1):
if (((x * x) % p) == n):
return True
return False | bool eulers_criterion_check_if_square_root_under_modulo_p_exists(int n, int p) {
n = n % p;
for ( int x = 2;
x < p;
x ++ ) if ( ( x * x ) % p == n ) return true;
return false;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
155 | Even Fibonacci Numbers Sum | C++ | int evenFibonacciNumbersSum(int limit) { | [
"limit"
] | def even_fibonacci_numbers_sum(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 | int even_fibonacci_numbers_sum(int limit) {
if ( limit < 2 ) return 0;
long long int ef1 = 0, ef2 = 2;
long long int sum = ef1 + ef2;
while ( ef2 <= limit ) {
long long int ef3 = 4 * ef2 + ef1;
if ( ef3 > limit ) break;
ef1 = ef2;
ef2 = ef3;
sum += ef2;
}
return sum;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
156 | Fast Multiplication Method Without Using Multiplication Operator Russian Peasants Algorithm | C++ | int fastMultiplicationMethodWithoutUsingMultiplicationOperatorRussianPeasantsAlgorithm(int a, int b) { | [
"a",
"b"
] | def fast_multiplication_method_without_using_multiplication_operator_russian_peasants_algorithm(a, b):
res = 0
while (b > 0):
if (b & 1):
res = (res + a)
a = (a << 1)
b = (b >> 1)
return res | unsigned int fast_multiplication_method_without_using_multiplication_operator_russian_peasants_algorithm(unsigned int a, unsigned int b) {
int res = 0;
while ( b > 0 ) {
if ( b & 1 ) res = res + a;
a = a << 1;
b = b >> 1;
}
return res;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
157 | Fibonacci Modulo P | C++ | int fibonacciModuloP(int p) { | [
"p"
] | def fibonacci_modulo_p(p):
first = 1
second = 1
number = 2
next = 1
while next:
next = ((first + second) % p)
first = second
second = next
number = (number + 1)
return number | int fibonacci_modulo_p(int p) {
int first = 1, second = 1, number = 2, next = 1;
while ( next ) {
next = ( first + second ) % p;
first = second;
second = next;
number ++;
}
return number;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
158 | Finding Power Prime Number P N | C++ | double findingPowerPrimeNumberPN(int n, int p) { | [
"n",
"p"
] | def finding_power_prime_number_p_n(n, p):
ans = 0
temp = p
while (temp <= n):
ans += (n / temp)
temp = (temp * p)
return ans | int finding_power_prime_number_p_n(int n, int p) {
int ans = 0;
int temp = p;
while ( temp <= n ) {
ans += n / temp;
temp = temp * p;
}
return ans;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
159 | Finding Power Prime Number P N 1 | C++ | int findingPowerPrimeNumberPN1(int n, int p) { | [
"n",
"p"
] | def finding_power_prime_number_p_n_1(n, p):
ans = 0
temp = p
while (temp <= n):
ans += (n / temp)
temp = (temp * p)
return int(ans) | int finding_power_prime_number_p_n_1(int n, int p) {
int ans = 0;
int temp = p;
while ( temp <= n ) {
ans += n / temp;
temp = temp * p;
}
return ans;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
160 | Find A Fixed Point In A Given Array | C++ | int findAFixedPointInAGivenArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_a_fixed_point_in_a_given_array(arr, n):
for i in range(n):
if (arr[i] is i):
return i
return (- 1) | int find_a_fixed_point_in_a_given_array(vector<int> arr, int n) {
int i;
for ( i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == i ) return i;
}
return - 1;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
161 | Find A Rotation With Maximum Hamming Distance | C++ | int findARotationWithMaximumHammingDistance(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_a_rotation_with_maximum_hamming_distance(arr, n):
brr = ([0] * ((2 * n) + 1))
for i in range(n):
brr[i] = arr[i]
for i in range(n):
brr[(n + i)] = arr[i]
maxHam = 0
for i in range(1, n):
currHam = 0
k = 0
for j in range(i, (i + n)):
if (br... | int find_a_rotation_with_maximum_hamming_distance(vector<int> arr, int n) {
int brr [ 2 * n + 1 ];
for ( int i = 0;
i < n;
i ++ ) brr [ i ] = arr [ i ];
for ( int i = 0;
i < n;
i ++ ) brr [ n + i ] = arr [ i ];
int maxHam = 0;
for ( int i = 1;
i < n;
i ++ ) {
int currHam = 0;
for ( int j =... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
162 | Find A Triplet That Sum To A Given Value | C++ | bool findATripletThatSumToAGivenValue(vector<int> a, int arr_size, int sum) { | [
"a",
"arr_size",
"sum"
] | def find_a_triplet_that_sum_to_a_given_value(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])... | bool find_a_triplet_that_sum_to_a_given_value(vector<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 ) ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
163 | Find A Triplet That Sum To A Given Value 1 | C++ | bool findATripletThatSumToAGivenValue1(vector<int> a, int arr_size, int sum) { | [
"a",
"arr_size",
"sum"
] | def find_a_triplet_that_sum_to_a_given_value_1(A, arr_size, sum):
A.sort()
for i in range(0, (arr_size - 2)):
l = (i + 1)
r = (arr_size - 1)
while (l < r):
if (((A[i] + A[l]) + A[r]) == sum):
print('Triplet is', A[i], ', ', A[l], ', ', A[r])
re... | bool find_a_triplet_that_sum_to_a_given_value_1(vector<int> A, int arr_size, int sum) {
int l, r;
sort(A.begin(), A.end());
for ( int i = 0;
i < arr_size - 2;
i ++ ) {
l = i + 1;
r = arr_size - 1;
while ( l < r ) {
if ( A [ i ] + A [ l ] + A [ r ] == sum ) {
return true;
}
... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
164 | Find A Triplet That Sum To A Given Value 2 | C++ | bool findATripletThatSumToAGivenValue2(vector<int> a, int arr_size, int sum) { | [
"a",
"arr_size",
"sum"
] | def find_a_triplet_that_sum_to_a_given_value_2(A, arr_size, sum):
for i in range(0, (arr_size - 1)):
s = set()
curr_sum = (sum - A[i])
for j in range((i + 1), arr_size):
if ((curr_sum - A[j]) in s):
print('Triplet is', A[i], ', ', A[j], ', ', (curr_sum - A[j]))
... | bool find_a_triplet_that_sum_to_a_given_value_2(vector<int> A, int arr_size, int sum) {
for ( int i = 0;
i < arr_size - 2;
i ++ ) {
unordered_set < int > s;
int curr_sum = sum - A [ i ];
for ( int j = i + 1;
j < arr_size;
j ++ ) {
if ( s . find ( curr_sum - A [ j ] ) != s . end ( ) ) {
... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
165 | Find Expression Duplicate Parenthesis Not | C++ | bool findExpressionDuplicateParenthesisNot(string string_arg0) { | [
"string_arg0"
] | def find_expression_duplicate_parenthesis_not(string):
Stack = []
for ch in string:
if (ch == ')'):
top = Stack.pop()
elementsInside = 0
while (top != '('):
elementsInside += 1
top = Stack.pop()
if (elementsInside < 1):
... | bool find_expression_duplicate_parenthesis_not(string str) {
stack < char > Stack;
for ( char ch : str ) {
if ( ch == ')' ) {
char top = Stack . top ( );
Stack . pop ( );
int elementsInside = 0;
while ( top != '(' ) {
elementsInside ++;
top = Stack . top ( );
Stac... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
166 | Find First Natural Number Whose Factorial Divisible X | C++ | int findFirstNaturalNumberWhoseFactorialDivisibleX(int x) { | [
"x"
] | def find_first_natural_number_whose_factorial_divisible_x(x):
i = 1
fact = 1
for i in range(1, x):
fact = (fact * i)
if ((fact % x) == 0):
break
return i | int find_first_natural_number_whose_factorial_divisible_x(int x) {
int i = 1;
int fact = 1;
for ( i = 1;
i < x;
i ++ ) {
fact = fact * i;
if ( fact % x == 0 ) break;
}
return i;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
167 | Find Harmonic Mean Using Arithmetic Mean Geometric Mean | C++ | double findHarmonicMeanUsingArithmeticMeanGeometricMean(int a, int b) { | [
"a",
"b"
] | def find_harmonic_mean_using_arithmetic_mean_geometric_mean(a, b):
AM = ((a + b) / 2)
GM = math.sqrt((a * b))
HM = ((GM * GM) / AM)
return HM | double find_harmonic_mean_using_arithmetic_mean_geometric_mean(int a, int b) {
double AM, GM, HM;
AM = ( a + b ) / 2;
GM = sqrt ( a * b );
HM = ( GM * GM ) / AM;
return HM;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
168 | Find Index Given Fibonacci Number Constant Time | C++ | int findIndexGivenFibonacciNumberConstantTime(int n) { | [
"n"
] | def find_index_given_fibonacci_number_constant_time(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 | int find_index_given_fibonacci_number_constant_time(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;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
169 | Find Index Given Fibonacci Number Constant Time 1 | C++ | int findIndexGivenFibonacciNumberConstantTime1(int n) { | [
"n"
] | def find_index_given_fibonacci_number_constant_time_1(n):
fibo = ((2.078087 * math.log(n)) + 1.672276)
return round(fibo) | int find_index_given_fibonacci_number_constant_time_1(int n) {
float fibo = 2.078087 * log ( n ) + 1.672276;
return round ( fibo );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
170 | Find Index Of An Extra Element Present In One Sorted Array | C++ | int findIndexOfAnExtraElementPresentInOneSortedArray(vector<int> arr1, vector<int> arr2, int n) { | [
"arr1",
"arr2",
"n"
] | def find_index_of_an_extra_element_present_in_one_sorted_array(arr1, arr2, n):
for i in range(0, n):
if (arr1[i] != arr2[i]):
return i
return n | int find_index_of_an_extra_element_present_in_one_sorted_array(vector<int> arr1, vector<int> arr2, int n) {
for ( int i = 0;
i < n;
i ++ ) if ( arr1 [ i ] != arr2 [ i ] ) return i;
return n;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
171 | Find Index Of An Extra Element Present In One Sorted Array 1 | C++ | int findIndexOfAnExtraElementPresentInOneSortedArray1(vector<int> arr1, vector<int> arr2, int n) { | [
"arr1",
"arr2",
"n"
] | def find_index_of_an_extra_element_present_in_one_sorted_array_1(arr1, arr2, n):
index = n
left = 0
right = (n - 1)
while (left <= right):
mid = int(((left + right) / 2))
if (arr2[mid] == arr1[mid]):
left = (mid + 1)
else:
index = mid
right = (... | int find_index_of_an_extra_element_present_in_one_sorted_array_1(vector<int> arr1, vector<int> arr2, int n) {
int index = n;
int left = 0, right = n - 1;
while ( left <= right ) {
int mid = ( left + right ) / 2;
if ( arr2 [ mid ] == arr1 [ mid ] ) left = mid + 1;
else {
index = mid;
right ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
172 | Find Largest D In Array Such That A B C D | C++ | int findLargestDInArraySuchThatABCD(vector<int> s, int n) { | [
"s",
"n"
] | def find_largest_d_in_array_such_that_a_b_c_d(S, n):
found = False
S.sort()
for i in range((n - 1), (- 1), (- 1)):
for j in range(0, n):
if (i == j):
continue
for k in range((j + 1), n):
if (i == k):
continue
... | int find_largest_d_in_array_such_that_a_b_c_d(vector<int> S, int n) {
bool found = false;
sort(S.begin(), S.end());
for ( int i = n - 1;
i >= 0;
i -- ) {
for ( int j = 0;
j < n;
j ++ ) {
if ( i == j ) continue;
for ( int k = j + 1;
k < n;
k ++ ) {
if ( i == k ) cont... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
173 | Find Largest D In Array Such That A B C D 1 | C++ | long long findLargestDInArraySuchThatABCD1(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_largest_d_in_array_such_that_a_b_c_d_1(arr, n):
mp = dict()
for i in range((n - 1)):
for j in range((i + 1), n):
mp[(arr[i] + arr[j])] = (i, j)
d = (- (10 ** 9))
for i in range((n - 1)):
for j in range((i + 1), n):
abs_diff = abs((arr[i] - arr[j]))
... | int find_largest_d_in_array_such_that_a_b_c_d_1(vector<int> arr, int n) {
unordered_map < int, pair < int, int > > mp;
for ( int i = 0;
i < n - 1;
i ++ ) for ( int j = i + 1;
j < n;
j ++ ) mp [ arr [ i ] + arr [ j ] ] = {
i, j };
int d = INT_MIN;
for ( int i = 0;
i < n - 1;
i ++ ) {
... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
174 | Find Largest Prime Factor Number | C++ | int findLargestPrimeFactorNumber(int n) { | [
"n"
] | def find_largest_prime_factor_number(n):
maxPrime = (- 1)
while ((n % 2) == 0):
maxPrime = 2
n >>= 1
for i in range(3, (int(math.sqrt(n)) + 1), 2):
while ((n % i) == 0):
maxPrime = i
n = (n / i)
if (n > 2):
maxPrime = n
return int(maxPrime) | long long find_largest_prime_factor_number(long long n) {
long long maxPrime = - 1;
while ( n % 2 == 0 ) {
maxPrime = 2;
n >>= 1;
}
for ( int i = 3;
i <= sqrt ( n );
i += 2 ) {
while ( n % i == 0 ) {
maxPrime = i;
n = n / i;
}
}
if ( n > 2 ) maxPrime = n;
return maxPrime;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
175 | Find Last Digit Factorial Divides Factorial B | C++ | int findLastDigitFactorialDividesFactorialB(int a, int b) { | [
"a",
"b"
] | def find_last_digit_factorial_divides_factorial_b(A, B):
variable = 1
if (A == B):
return 1
elif ((B - A) >= 5):
return 0
else:
for i in range((A + 1), (B + 1)):
variable = ((variable * (i % 10)) % 10)
return (variable % 10) | int find_last_digit_factorial_divides_factorial_b(long long int A, long long int B) {
int variable = 1;
if ( A == B ) return 1;
else if ( ( B - A ) >= 5 ) return 0;
else {
for ( long long int i = A + 1;
i <= B;
i ++ ) variable = ( variable * ( i % 10 ) ) % 10;
return variable % 10;
}
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
176 | Find Maximum Average Subarray Of K Length | C++ | int findMaximumAverageSubarrayOfKLength(vector<int> arr, int n, int k) { | [
"arr",
"n",
"k"
] | def find_maximum_average_subarray_of_k_length(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 ... | int find_maximum_average_subarray_of_k_length(vector<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... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
177 | Find Maximum Average Subarray Of K Length 1 | C++ | int findMaximumAverageSubarrayOfKLength1(vector<int> arr, int n, int k) { | [
"arr",
"n",
"k"
] | def find_maximum_average_subarray_of_k_length_1(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_su... | int find_maximum_average_subarray_of_k_length_1(vector<int> arr, int n, int k) {
if ( k > n ) return - 1;
int sum = arr [ 0 ];
for ( int i = 1;
i < k;
i ++ ) sum += arr [ i ];
int max_sum = sum, max_end = k - 1;
for ( int i = k;
i < n;
i ++ ) {
int sum = sum + arr [ i ] - arr [ i - k ];
if ( s... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
178 | Find Maximum Dot Product Two Arrays Insertion 0S | C++ | int findMaximumDotProductTwoArraysInsertion0S(vector<int> a, vector<int> b, int m, int n) { | [
"a",
"b",
"m",
"n"
] | def find_maximum_dot_product_two_arrays_insertion_0s(A, B, m, n):
dp = [[0 for i in range((m + 1))] for j in range((n + 1))]
for i in range(1, (n + 1), 1):
for j in range(i, (m + 1), 1):
dp[i][j] = max((dp[(i - 1)][(j - 1)] + (A[(j - 1)] * B[(i - 1)])), dp[i][(j - 1)])
return dp[n][m] | long long int find_maximum_dot_product_two_arrays_insertion_0s(vector<int> A, vector<int> B, int m, int n) {
long long int dp [ n + 1 ] [ m + 1 ];
memset ( dp, 0, sizeof ( dp ) );
for ( int i = 1;
i <= n;
i ++ ) for ( int j = i;
j <= m;
j ++ ) dp [ i ] [ j ] = max ( ( dp [ i - 1 ] [ j - 1 ] + ( A [ j - 1 ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
179 | Find Maximum Height Pyramid From The Given Array Of Objects | C++ | int findMaximumHeightPyramidFromTheGivenArrayOfObjects(vector<int> boxes, int n) { | [
"boxes",
"n"
] | def find_maximum_height_pyramid_from_the_given_array_of_objects(boxes, n):
boxes.sort()
ans = 1
prev_width = boxes[0]
prev_count = 1
curr_count = 0
curr_width = 0
for i in range(1, n):
curr_width += boxes[i]
curr_count += 1
if ((curr_width > prev_width) and (curr_coun... | int find_maximum_height_pyramid_from_the_given_array_of_objects(vector<int> boxes, int n) {
sort(boxes.begin(), boxes.end());
int ans = 1;
int prev_width = boxes [ 0 ];
int prev_count = 1;
int curr_count = 0;
int curr_width = 0;
for ( int i = 1;
i < n;
i ++ ) {
curr_width += boxes [ i ];
curr_... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
180 | Find Maximum Product Of A Triplet In Array | C++ | int findMaximumProductOfATripletInArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_maximum_product_of_a_triplet_in_array(arr, n):
if (n < 3):
return (- 1)
max_product = (- (sys.maxsize - 1))
for i in range(0, (n - 2)):
for j in range((i + 1), (n - 1)):
for k in range((j + 1), n):
max_product = max(max_product, ((arr[i] * arr[j]) * arr[k... | int find_maximum_product_of_a_triplet_in_array(vector<int> arr, int n) {
if ( n < 3 ) return - 1;
int max_product = INT_MIN;
for ( int i = 0;
i < n - 2;
i ++ ) for ( int j = i + 1;
j < n - 1;
j ++ ) for ( int k = j + 1;
k < n;
k ++ ) max_product = max ( max_product, arr [ i ] * arr [ j ] * arr [ k ] )... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
181 | Find Maximum Product Of A Triplet In Array 1 | C++ | int findMaximumProductOfATripletInArray1(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_maximum_product_of_a_triplet_in_array_1(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)])) | int find_maximum_product_of_a_triplet_in_array_1(vector<int> arr, int n) {
if ( n < 3 ) return - 1;
sort(arr.begin(), arr.end());
return max ( arr [ 0 ] * arr [ 1 ] * arr [ n - 1 ], arr [ n - 1 ] * arr [ n - 2 ] * arr [ n - 3 ] );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
182 | Find Maximum Sum Possible Equal Sum Three Stacks | C++ | int findMaximumSumPossibleEqualSumThreeStacks(vector<int> stack1, vector<int> stack2, vector<int> stack3, int n1, int n2, int n3) { | [
"stack1",
"stack2",
"stack3",
"n1",
"n2",
"n3"
] | def find_maximum_sum_possible_equal_sum_three_stacks(stack1, stack2, stack3, n1, n2, n3):
(sum1, sum2, sum3) = (0, 0, 0)
for i in range(n1):
sum1 += stack1[i]
for i in range(n2):
sum2 += stack2[i]
for i in range(n3):
sum3 += stack3[i]
(top1, top2, top3) = (0, 0, 0)
ans = ... | int find_maximum_sum_possible_equal_sum_three_stacks(vector<int> stack1, vector<int> stack2, vector<int> stack3, int n1, int n2, int n3) {
int sum1 = 0, sum2 = 0, sum3 = 0;
for ( int i = 0;
i < n1;
i ++ ) sum1 += stack1 [ i ];
for ( int i = 0;
i < n2;
i ++ ) sum2 += stack2 [ i ];
for ( int i = 0;
i < ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
183 | Find Minimum Difference Pair | C++ | int findMinimumDifferencePair(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_minimum_difference_pair(arr, n):
diff = (10 ** 20)
for i in range((n - 1)):
for j in range((i + 1), n):
if (abs((arr[i] - arr[j])) < diff):
diff = abs((arr[i] - arr[j]))
return diff | int find_minimum_difference_pair(vector<int> arr, int n) {
int diff = INT_MAX;
for ( int i = 0;
i < n - 1;
i ++ ) for ( int j = i + 1;
j < n;
j ++ ) if ( abs ( arr [ i ] - arr [ j ] ) < diff ) diff = abs ( arr [ i ] - arr [ j ] );
return diff;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
184 | Find Minimum Difference Pair 1 | C++ | int findMinimumDifferencePair1(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_minimum_difference_pair_1(arr, n):
arr = sorted(arr)
diff = (10 ** 20)
for i in range((n - 1)):
if ((arr[(i + 1)] - arr[i]) < diff):
diff = (arr[(i + 1)] - arr[i])
return diff | int find_minimum_difference_pair_1(vector<int> arr, int n) {
sort(arr.begin(), arr.end());
int diff = INT_MAX;
for ( int i = 0;
i < n - 1;
i ++ ) if ( arr [ i + 1 ] - arr [ i ] < diff ) diff = arr [ i + 1 ] - arr [ i ];
return diff;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
185 | Find Minimum Element In A Sorted And Rotated Array | C++ | int findMinimumElementInASortedAndRotatedArray(vector<int> arr, int low, int high) { | [
"arr",
"low",
"high"
] | def find_minimum_element_in_a_sorted_and_rotated_array(arr, low, high):
if (high < low):
return arr[0]
if (high == low):
return arr[low]
mid = int(((low + high) / 2))
if ((mid < high) and (arr[(mid + 1)] < arr[mid])):
return arr[(mid + 1)]
if ((mid > low) and (arr[mid] < arr[... | int find_minimum_element_in_a_sorted_and_rotated_array(vector<int> arr, int low, int high) {
if ( high < low ) return arr [ 0 ];
if ( high == low ) return arr [ low ];
int mid = low + ( high - low ) / 2;
if ( mid < high && arr [ mid + 1 ] < arr [ mid ] ) return arr [ mid + 1 ];
if ( mid > low && arr [ mid ] <... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
186 | Find Minimum Number Divided Make Number Perfect Square | C++ | int findMinimumNumberDividedMakeNumberPerfectSquare(int n) { | [
"n"
] | def find_minimum_number_divided_make_number_perfect_square(n):
count = 0
ans = 1
while ((n % 2) == 0):
count += 1
n //= 2
if ((count % 2) is not 0):
ans *= 2
for i in range(3, (int(math.sqrt(n)) + 1), 2):
count = 0
while ((n % i) == 0):
count += 1
... | int find_minimum_number_divided_make_number_perfect_square(int n) {
int count = 0, ans = 1;
while ( n % 2 == 0 ) {
count ++;
n /= 2;
}
if ( count % 2 ) ans *= 2;
for ( int i = 3;
i <= sqrt ( n );
i += 2 ) {
count = 0;
while ( n % i == 0 ) {
count ++;
n /= i;
}
if ( coun... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
187 | Find Minimum Sum Factors Number | C++ | float findMinimumSumFactorsNumber(int num) { | [
"num"
] | def find_minimum_sum_factors_number(num):
sum = 0
i = 2
while ((i * i) <= num):
while ((num % i) == 0):
sum += i
num /= i
i += 1
sum += num
return sum | int find_minimum_sum_factors_number(int num) {
int sum = 0;
for ( int i = 2;
i * i <= num;
i ++ ) {
while ( num % i == 0 ) {
sum += i;
num /= i;
}
}
sum += num;
return sum;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
188 | Find Number Times String Occurs Given String 1 | C++ | int findNumberTimesStringOccursGivenString1(string a, string b) { | [
"a",
"b"
] | def find_number_times_string_occurs_given_string_1(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)):
... | int find_number_times_string_occurs_given_string_1(string a, string b) {
int m = a . length ( );
int n = b . length ( );
int lookup [ m + 1 ] [ n + 1 ] = {
{
0 }
};
for ( int i = 0;
i <= n;
++ i ) lookup [ 0 ] [ i ] = 0;
for ( int i = 0;
i <= m;
++ i ) lookup [ i ] [ 0 ] = 1;... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
189 | Find N Th Element From Sterns Diatomic Series | C++ | int findNThElementFromSternsDiatomicSeries(int n) { | [
"n"
] | def find_n_th_element_from_sterns_diatomic_series(n):
DP = ([0] * (n + 1))
DP[0] = 0
DP[1] = 1
for i in range(2, (n + 1)):
if (int((i % 2)) == 0):
DP[i] = DP[int((i / 2))]
else:
DP[i] = (DP[int(((i - 1) / 2))] + DP[int(((i + 1) / 2))])
return DP[n] | int find_n_th_element_from_sterns_diatomic_series(int n) {
int DP [ n + 1 ];
DP [ 0 ] = 0;
DP [ 1 ] = 1;
for ( int i = 2;
i <= n;
i ++ ) {
if ( i % 2 == 0 ) DP [ i ] = DP [ i / 2 ];
else DP [ i ] = DP [ ( i - 1 ) / 2 ] + DP [ ( i + 1 ) / 2 ];
}
return DP [ n ];
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
191 | Find Pair With Greatest Product In Array | C++ | int findPairWithGreatestProductInArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_pair_with_greatest_product_in_array(arr, n):
result = (- 1)
for i in range(n):
for j in range((n - 1)):
for k in range((j + 1), n):
if ((arr[j] * arr[k]) == arr[i]):
result = max(result, arr[i])
return result | int find_pair_with_greatest_product_in_array(vector<int> arr, int n) {
int result = - 1;
for ( int i = 0;
i < n;
i ++ ) for ( int j = 0;
j < n - 1;
j ++ ) for ( int k = j + 1;
k < n;
k ++ ) if ( arr [ j ] * arr [ k ] == arr [ i ] ) result = max ( result, arr [ i ] );
return result;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
192 | Find Perimeter Cylinder | C++ | int findPerimeterCylinder(int diameter, int height) { | [
"diameter",
"height"
] | def find_perimeter_cylinder(diameter, height):
return (2 * (diameter + height)) | int find_perimeter_cylinder(int diameter, int height) {
return 2 * ( diameter + height );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
193 | Find Position Given Number Among Numbers Made 4 7 | C++ | int findPositionGivenNumberAmongNumbersMade47(string n) { | [
"n"
] | def find_position_given_number_among_numbers_made_4_7(n):
i = 0
j = len(n)
pos = 0
while (i < j):
if (n[i] == '4'):
pos = ((pos * 2) + 1)
if (n[i] == '7'):
pos = ((pos * 2) + 2)
i = (i + 1)
return pos | int find_position_given_number_among_numbers_made_4_7(string n) {
int i = 0, pos = 0;
while ( n [ i ] != '\0' ) {
switch ( n [ i ] ) {
case '4' : pos = pos * 2 + 1;
break;
case '7' : pos = pos * 2 + 2;
break;
}
i ++;
}
return pos;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
194 | Find Repetitive Element 1 N 1 | C++ | int findRepetitiveElement1N1(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_repetitive_element_1_n_1(arr, n):
return (sum(arr) - (((n - 1) * n) // 2)) | int find_repetitive_element_1_n_1(vector<int> arr, int n) {
return accumulate(arr.begin(), arr.end(), 0 ) - ( ( n - 1 ) * n / 2 );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
195 | Find Repetitive Element 1 N 1 2 | C++ | int findRepetitiveElement1N12(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_repetitive_element_1_n_1_2(arr, n):
res = 0
for i in range(0, (n - 1)):
res = ((res ^ (i + 1)) ^ arr[i])
res = (res ^ arr[(n - 1)])
return res | int find_repetitive_element_1_n_1_2(vector<int> arr, int n) {
int res = 0;
for ( int i = 0;
i < n - 1;
i ++ ) res = res ^ ( i + 1 ) ^ arr [ i ];
res = res ^ arr [ n - 1 ];
return res;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
196 | Find Rotation Count Rotated Sorted Array 1 | C++ | int findRotationCountRotatedSortedArray1(vector<int> arr, int low, int high) { | [
"arr",
"low",
"high"
] | def find_rotation_count_rotated_sorted_array_1(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[(... | int find_rotation_count_rotated_sorted_array_1(vector<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 mi... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
197 | Find Smallest Value Represented Sum Subset Given Array | C++ | int findSmallestValueRepresentedSumSubsetGivenArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_smallest_value_represented_sum_subset_given_array(arr, n):
res = 1
for i in range(0, n):
if (arr[i] <= res):
res = (res + arr[i])
else:
break
return res | int find_smallest_value_represented_sum_subset_given_array(vector<int> arr, int n) {
int res = 1;
for ( int i = 0;
i < n && arr [ i ] <= res;
i ++ ) res = res + arr [ i ];
return res;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
198 | Find Subarray With Given Sum | C++ | int findSubarrayWithGivenSum(vector<int> arr, int n, int sum) { | [
"arr",
"n",
"sum"
] | def find_subarray_with_given_sum(arr, n, sum):
for i in range(n):
curr_sum = arr[i]
j = (i + 1)
while (j <= n):
if (curr_sum == sum):
print('Sum found between')
print(('indexes %d and %d' % (i, (j - 1))))
return 1
if ((c... | int find_subarray_with_given_sum(vector<int> arr, int n, int sum) {
int curr_sum, i, j;
for ( i = 0;
i < n;
i ++ ) {
curr_sum = arr [ i ];
for ( j = i + 1;
j <= n;
j ++ ) {
if ( curr_sum == sum ) {
return 1;
}
if ( curr_sum > sum || j == n ) break;
curr_sum = curr... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
199 | Find Subarray With Given Sum 1 | C++ | int findSubarrayWithGivenSum1(vector<int> arr, int n, int sum) { | [
"arr",
"n",
"sum"
] | def find_subarray_with_given_sum_1(arr, n, sum):
curr_sum = arr[0]
start = 0
i = 1
while (i <= n):
while ((curr_sum > sum) and (start < (i - 1))):
curr_sum = (curr_sum - arr[start])
start += 1
if (curr_sum == sum):
print('Sum found between indexes')
... | int find_subarray_with_given_sum_1(vector<int> arr, int n, int sum) {
int curr_sum = arr [ 0 ], start = 0, i;
for ( i = 1;
i <= n;
i ++ ) {
while ( curr_sum > sum && start < i - 1 ) {
curr_sum = curr_sum - arr [ start ];
start ++;
}
if ( curr_sum == sum ) {
return 1;
}
if (... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
200 | Find Sum Even Factors Number | C++ | int findSumEvenFactorsNumber(int n) { | [
"n"
] | def find_sum_even_factors_number(n):
if ((n % 2) != 0):
return 0
res = 1
for i in range(2, (int(math.sqrt(n)) + 1)):
count = 0
curr_sum = 1
curr_term = 1
while ((n % i) == 0):
count = (count + 1)
n = (n // i)
if ((i == 2) and (count... | int find_sum_even_factors_number(int n) {
if ( n % 2 != 0 ) return 0;
int res = 1;
for ( int i = 2;
i <= sqrt ( n );
i ++ ) {
int count = 0, curr_sum = 1, curr_term = 1;
while ( n % i == 0 ) {
count ++;
n = n / i;
if ( i == 2 && count == 1 ) curr_sum = 0;
curr_term *= i;
... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
201 | Find Sum Even Index Binomial Coefficients | C++ | long long findSumEvenIndexBinomialCoefficients(int n) { | [
"n"
] | def find_sum_even_index_binomial_coefficients(n):
C = [[0 for x in range((n + 1))] for y in range((n + 1))]
for i in range(0, (n + 1)):
for j in range(0, min(i, (n + 1))):
if ((j == 0) or (j == i)):
C[i][j] = 1
else:
C[i][j] = (C[(i - 1)][(j - 1)] ... | int find_sum_even_index_binomial_coefficients(int n) {
int C [ n + 1 ] [ n + 1 ];
int i, j;
for ( i = 0;
i <= n;
i ++ ) {
for ( j = 0;
j <= min ( i, n );
j ++ ) {
if ( j == 0 || j == i ) C [ i ] [ j ] = 1;
else C [ i ] [ j ] = C [ i - 1 ] [ j - 1 ] + C [ i - 1 ] [ j ];
}
}
int ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
202 | Find Sum Even Index Binomial Coefficients 1 | C++ | long long findSumEvenIndexBinomialCoefficients1(int n) { | [
"n"
] | def find_sum_even_index_binomial_coefficients_1(n):
return (1 << (n - 1)) | int find_sum_even_index_binomial_coefficients_1(int n) {
return ( 1 << ( n - 1 ) );
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
203 | Find Sum Modulo K First N Natural Number | C++ | int findSumModuloKFirstNNaturalNumber(int n, int k) { | [
"n",
"k"
] | def find_sum_modulo_k_first_n_natural_number(N, K):
ans = 0
for i in range(1, (N + 1)):
ans += (i % K)
return ans | int find_sum_modulo_k_first_n_natural_number(int N, int K) {
int ans = 0;
for ( int i = 1;
i <= N;
i ++ ) ans += ( i % K );
return ans;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
204 | Find Sum Modulo K First N Natural Number 1 | C++ | int findSumModuloKFirstNNaturalNumber1(int n, int k) { | [
"n",
"k"
] | def find_sum_modulo_k_first_n_natural_number_1(N, K):
ans = 0
y = (N / K)
x = (N % K)
ans = ((((K * (K - 1)) / 2) * y) + ((x * (x + 1)) / 2))
return int(ans) | int find_sum_modulo_k_first_n_natural_number_1(int N, int K) {
int ans = 0;
int y = N / K;
int x = N % K;
ans = ( K * ( K - 1 ) / 2 ) * y + ( x * ( x + 1 ) ) / 2;
return ans;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
205 | Find Sum Non Repeating Distinct Elements Array | C++ | int findSumNonRepeatingDistinctElementsArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_sum_non_repeating_distinct_elements_array(arr, n):
s = set()
sum = 0
for i in range(n):
if (arr[i] not in s):
s.add(arr[i])
for i in s:
sum = (sum + i)
return sum | int find_sum_non_repeating_distinct_elements_array(vector<int> arr, int n) {
int sum = 0;
unordered_set < int > s;
for ( int i = 0;
i < n;
i ++ ) {
if ( s . find ( arr [ i ] ) == s . end ( ) ) {
sum += arr [ i ];
s . insert ( arr [ i ] );
}
}
return sum;
} | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
206 | Find Sum Odd Factors Number | C++ | int findSumOddFactorsNumber(int n) { | [
"n"
] | def find_sum_odd_factors_number(n):
res = 1
while ((n % 2) == 0):
n = (n // 2)
for i in range(3, int((math.sqrt(n) + 1))):
count = 0
curr_sum = 1
curr_term = 1
while ((n % i) == 0):
count += 1
n = (n // i)
curr_term *= i
... | int find_sum_odd_factors_number(int n) {
int res = 1;
while ( n % 2 == 0 ) n = n / 2;
for ( int i = 3;
i <= sqrt ( n );
i ++ ) {
int count = 0, curr_sum = 1;
int curr_term = 1;
while ( n % i == 0 ) {
count ++;
n = n / i;
curr_term *= i;
curr_sum += curr_term;
}
res ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
207 | Find Sum Unique Sub Array Sum Given Array | C++ | int findSumUniqueSubArraySumGivenArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_sum_unique_sub_array_sum_given_array(arr, n):
res = 0
m = dict()
for i in range(n):
Sum = 0
for j in range(i, n):
Sum += arr[j]
m[Sum] = (m.get(Sum, 0) + 1)
for x in m:
if (m[x] == 1):
res += x
return res | long long int find_sum_unique_sub_array_sum_given_array(vector<int> arr, int n) {
int res = 0;
unordered_map < int, int > m;
for ( int i = 0;
i < n;
i ++ ) {
int sum = 0;
for ( int j = i;
j < n;
j ++ ) {
sum += arr [ j ];
m [ sum ] ++;
}
}
for ( auto x : m ) if ( x . second... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
208 | Find The Element Before Which All The Elements Are Smaller Than It And After Which All Are Greater Than It | C++ | int findTheElementBeforeWhichAllTheElementsAreSmallerThanItAndAfterWhichAllAreGreaterThanIt(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_the_element_before_which_all_the_elements_are_smaller_than_it_and_after_which_all_are_greater_than_it(arr, n):
leftMax = ([None] * n)
leftMax[0] = float('-inf')
for i in range(1, n):
leftMax[i] = max(leftMax[(i - 1)], arr[(i - 1)])
rightMin = float('inf')
for i in range((n - 1), (- ... | int find_the_element_before_which_all_the_elements_are_smaller_than_it_and_after_which_all_are_greater_than_it(vector<int> arr, int n) {
int leftMax [ n ];
leftMax [ 0 ] = INT_MIN;
for ( int i = 1;
i < n;
i ++ ) leftMax [ i ] = max ( leftMax [ i - 1 ], arr [ i - 1 ] );
int rightMin = INT_MAX;
for ( int i ... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
209 | Find The Element That Appears Once | C++ | int findTheElementThatAppearsOnce(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_the_element_that_appears_once(arr, n):
ones = 0
twos = 0
for i in range(n):
twos = (twos | (ones & arr[i]))
ones = (ones ^ arr[i])
common_bit_mask = (~ (ones & twos))
ones &= common_bit_mask
twos &= common_bit_mask
return ones | int find_the_element_that_appears_once(vector<int> arr, int n) {
int ones = 0, twos = 0;
int common_bit_mask;
for ( int i = 0;
i < n;
i ++ ) {
twos = twos | ( ones & arr [ i ] );
ones = ones ^ arr [ i ];
common_bit_mask = ~ ( ones & twos );
ones &= common_bit_mask;
twos &= common_bit_mask;... | {
"test_code": "#include <algorithm>\n#include <assert.h>\n#include <cstdlib>\n#include <iostream>\n#include <map>\n#include <set>\n#include <string>\n#include <tuple> \n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <cmath>\n#include <bits/stdc++.h>\n#include <numeric>\n#include <functional... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.