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 |
|---|---|---|---|---|---|---|---|
210 | Find The First Missing Number | C++ | int findTheFirstMissingNumber(vector<int> array, int start, int end_arg2) { | [
"array",
"start",
"end_arg2"
] | def find_the_first_missing_number(array, start, end):
if (start > end):
return (end + 1)
if (start != array[start]):
return start
mid = int(((start + end) / 2))
if (array[mid] == mid):
return find_the_first_missing_number(array, (mid + 1), end)
return find_the_first_missing_n... | int find_the_first_missing_number(vector<int> array, int start, int end) {
if ( start > end ) return end + 1;
if ( start != array [ start ] ) return start;
int mid = ( start + end ) / 2;
if ( array [ mid ] == mid ) return find_the_first_missing_number ( array, mid + 1, end );
return find_the_first_missing_num... | {
"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... |
211 | Find The Maximum Element In An Array Which Is First Increasing And Then Decreasing | C++ | int findTheMaximumElementInAnArrayWhichIsFirstIncreasingAndThenDecreasing(vector<int> arr, int low, int high) { | [
"arr",
"low",
"high"
] | def find_the_maximum_element_in_an_array_which_is_first_increasing_and_then_decreasing(arr, low, high):
max = arr[low]
i = low
for i in range((high + 1)):
if (arr[i] > max):
max = arr[i]
return max | int find_the_maximum_element_in_an_array_which_is_first_increasing_and_then_decreasing(vector<int> arr, int low, int high) {
int max = arr [ low ];
int i;
for ( i = low + 1;
i <= high;
i ++ ) {
if ( arr [ i ] > max ) max = arr [ i ];
else break;
}
return max;
} | {
"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... |
212 | Find The Maximum Subarray Xor In A Given Array | C++ | int findTheMaximumSubarrayXorInAGivenArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def find_the_maximum_subarray_xor_in_a_given_array(arr, n):
ans = (- 2147483648)
for i in range(n):
curr_xor = 0
for j in range(i, n):
curr_xor = (curr_xor ^ arr[j])
ans = max(ans, curr_xor)
return ans | int find_the_maximum_subarray_xor_in_a_given_array(vector<int> arr, int n) {
int ans = INT_MIN;
for ( int i = 0;
i < n;
i ++ ) {
int curr_xor = 0;
for ( int j = i;
j < n;
j ++ ) {
curr_xor = curr_xor ^ arr [ j ];
ans = max ( ans, curr_xor );
}
}
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... |
213 | Find The Minimum Distance Between Two Numbers | C++ | int findTheMinimumDistanceBetweenTwoNumbers(vector<int> arr, int n, int x, int y) { | [
"arr",
"n",
"x",
"y"
] | def find_the_minimum_distance_between_two_numbers(arr, n, x, y):
min_dist = 99999999
for i in range(n):
for j in range((i + 1), n):
if ((((x == arr[i]) and (y == arr[j])) or ((y == arr[i]) and (x == arr[j]))) and (min_dist > abs((i - j)))):
min_dist = abs((i - j))
ret... | int find_the_minimum_distance_between_two_numbers(vector<int> arr, int n, int x, int y) {
int i, j;
int min_dist = INT_MAX;
for ( i = 0;
i < n;
i ++ ) {
for ( j = i + 1;
j < n;
j ++ ) {
if ( ( x == arr [ i ] && y == arr [ j ] || y == arr [ i ] && x == arr [ j ] ) && min_dist > abs ( i - 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... |
214 | Find The Minimum Distance Between Two Numbers 1 | C++ | int findTheMinimumDistanceBetweenTwoNumbers1(vector<int> arr, int n, int x, int y) { | [
"arr",
"n",
"x",
"y"
] | def find_the_minimum_distance_between_two_numbers_1(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) <... | int find_the_minimum_distance_between_two_numbers_1(vector<int> arr, int n, int x, int y) {
int i = 0;
int min_dist = INT_MAX;
int prev;
for ( i = 0;
i < n;
i ++ ) {
if ( arr [ i ] == x || arr [ i ] == y ) {
prev = i;
break;
}
}
for (;
i < n;
i ++ ) {
if ( arr [ i ] == x || a... | {
"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... |
215 | Find The Missing Number 1 | C++ | int findTheMissingNumber1(vector<int> a, int n) { | [
"a",
"n"
] | def find_the_missing_number_1(a, n):
(i, total) = (0, 1)
for i in range(2, (n + 2)):
total += i
total -= a[(i - 2)]
return total | int find_the_missing_number_1(vector<int> a, int n) {
int i, total = 1;
for ( i = 2;
i <= ( n + 1 );
i ++ ) {
total += i;
total -= a [ i - 2 ];
}
return total;
} | {
"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... |
216 | Find The Missing Number 2 | C++ | int findTheMissingNumber2(vector<int> a, int n) { | [
"a",
"n"
] | def find_the_missing_number_2(a, n):
x1 = a[0]
x2 = 1
for i in range(1, n):
x1 = (x1 ^ a[i])
for i in range(2, (n + 2)):
x2 = (x2 ^ i)
return (x1 ^ x2) | int find_the_missing_number_2(vector<int> a, int n) {
int x1 = a [ 0 ];
int x2 = 1;
for ( int i = 1;
i < n;
i ++ ) x1 = x1 ^ a [ i ];
for ( int i = 2;
i <= n + 1;
i ++ ) x2 = x2 ^ i;
return ( x1 ^ x2 );
} | {
"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... |
217 | Find The Number Occurring Odd Number Of Times | C++ | int findTheNumberOccurringOddNumberOfTimes(vector<int> arr, int arr_size) { | [
"arr",
"arr_size"
] | def find_the_number_occurring_odd_number_of_times(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if (arr[i] == arr[j]):
count += 1
if ((count % 2) != 0):
return arr[i]
return (- 1) | int find_the_number_occurring_odd_number_of_times(vector<int> arr, int arr_size) {
for ( int i = 0;
i < arr_size;
i ++ ) {
int count = 0;
for ( int j = 0;
j < arr_size;
j ++ ) {
if ( arr [ i ] == arr [ j ] ) count ++;
}
if ( count % 2 != 0 ) return arr [ 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... |
218 | Find The Number Occurring Odd Number Of Times 1 | C++ | int findTheNumberOccurringOddNumberOfTimes1(vector<int> arr, int size) { | [
"arr",
"size"
] | def find_the_number_occurring_odd_number_of_times_1(arr, size):
Hash = dict()
for i in range(size):
Hash[arr[i]] = (Hash.get(arr[i], 0) + 1)
for i in Hash:
if ((Hash[i] % 2) != 0):
return i
return (- 1) | int find_the_number_occurring_odd_number_of_times_1(vector<int> arr, int size) {
unordered_map < int, int > hash;
for ( int i = 0;
i < size;
i ++ ) {
hash [ arr [ i ] ] ++;
}
for ( auto i : hash ) {
if ( i . second % 2 != 0 ) {
return i . first;
}
}
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... |
219 | Find Three Element From Different Three Arrays Such That That A B C K | C++ | bool findThreeElementFromDifferentThreeArraysSuchThatThatABCK(vector<int> a1, vector<int> a2, vector<int> a3, int n1, int n2, int n3, int sum) { | [
"a1",
"a2",
"a3",
"n1",
"n2",
"n3",
"sum"
] | def find_three_element_from_different_three_arrays_such_that_that_a_b_c_k(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 | bool find_three_element_from_different_three_arrays_such_that_that_a_b_c_k(vector<int> a1, vector<int> a2, vector<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 ... | {
"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... |
220 | Find Three Element From Different Three Arrays Such That That A B C K 1 | C++ | bool findThreeElementFromDifferentThreeArraysSuchThatThatABCK1(vector<int> a1, vector<int> a2, vector<int> a3, int n1, int n2, int n3, int sum) { | [
"a1",
"a2",
"a3",
"n1",
"n2",
"n3",
"sum"
] | def find_three_element_from_different_three_arrays_such_that_that_a_b_c_k_1(a1, a2, a3, n1, n2, n3, sum):
s = set()
for i in range(n1):
s.add(a1[i])
for i in range(n2):
for j in range(n3):
if (((sum - a2[i]) - a3[j]) in s):
return True
return False | bool find_three_element_from_different_three_arrays_such_that_that_a_b_c_k_1(vector<int> a1, vector<int> a2, vector<int> a3, int n1, int n2, int n3, int sum) {
unordered_set < int > s;
for ( int i = 0;
i < n1;
i ++ ) s . insert ( a1 [ i ] );
for ( int i = 0;
i < n2;
i ++ ) {
for ( int j = 0;
j < 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... |
221 | Find Unit Digit X Raised Power Y | C++ | int findUnitDigitXRaisedPowerY(int x, int y) { | [
"x",
"y"
] | def find_unit_digit_x_raised_power_y(x, y):
res = 1
for i in range(y):
res = ((res * x) % 10)
return res | int find_unit_digit_x_raised_power_y(int x, int y) {
int res = 1;
for ( int i = 0;
i < y;
i ++ ) res = ( res * x ) % 10;
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... |
222 | Find Unit Digit X Raised Power Y 1 | C++ | int findUnitDigitXRaisedPowerY1(int x, int y) { | [
"x",
"y"
] | def find_unit_digit_x_raised_power_y_1(x, y):
x = (x % 10)
if (y != 0):
y = ((y % 4) + 4)
return (int(math.pow(x, y)) % 10) | int find_unit_digit_x_raised_power_y_1(int x, int y) {
x = x % 10;
if ( y != 0 ) y = y % 4 + 4;
return ( ( ( int ) ( pow ( x, y ) ) ) % 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... |
223 | Find Value Of Y Mod 2 Raised To Power X | C++ | int findValueOfYMod2RaisedToPowerX(int y, int x) { | [
"y",
"x"
] | def find_value_of_y_mod_2_raised_to_power_x(y, x):
return (y % pow(2, x)) | long long int find_value_of_y_mod_2_raised_to_power_x(long long int y, long long int x) {
if ( log2 ( y ) < x ) return y;
if ( x > 63 ) return y;
return ( y % ( 1 << x ) );
} | {
"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... |
224 | Find Whether An Array Is Subset Of Another Array Set 1 | C++ | int findWhetherAnArrayIsSubsetOfAnotherArraySet1(vector<int> arr1, vector<int> arr2, int m, int n) { | [
"arr1",
"arr2",
"m",
"n"
] | def find_whether_an_array_is_subset_of_another_array_set_1(arr1, arr2, m, n):
i = 0
j = 0
for i in range(n):
for j in range(m):
if (arr2[i] == arr1[j]):
break
if (j == m):
return 0
return 1 | bool find_whether_an_array_is_subset_of_another_array_set_1(vector<int> arr1, vector<int> arr2, int m, int n) {
int i = 0;
int j = 0;
for ( i = 0;
i < n;
i ++ ) {
for ( j = 0;
j < m;
j ++ ) {
if ( arr2 [ i ] == arr1 [ j ] ) break;
}
if ( j == m ) return 0;
}
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... |
226 | Find Whether A Given Number Is A Power Of 4 Or Not 1 | C++ | bool findWhetherAGivenNumberIsAPowerOf4OrNot1(int n) { | [
"n"
] | def find_whether_a_given_number_is_a_power_of_4_or_not_1(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 | bool find_whether_a_given_number_is_a_power_of_4_or_not_1(unsigned int n) {
int count = 0;
if ( n && ! ( n & ( n - 1 ) ) ) {
while ( n > 1 ) {
n >>= 1;
count += 1;
}
return ( count % 2 == 0 ) ? 1 : 0;
}
return 0;
} | {
"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... |
227 | Find Whether A Given Number Is A Power Of 4 Or Not 2 | C++ | bool findWhetherAGivenNumberIsAPowerOf4OrNot2(int n) { | [
"n"
] | def find_whether_a_given_number_is_a_power_of_4_or_not_2(n):
return ((n != 0) and ((n & (n - 1)) == 0) and (not (n & 2863311530))) | bool find_whether_a_given_number_is_a_power_of_4_or_not_2(unsigned int n) {
return n != 0 && ( ( n & ( n - 1 ) ) == 0 ) && ! ( n & 0xAAAAAAAA );
} | {
"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... |
228 | Find Whether Given Integer Power 3 Not | C++ | bool findWhetherGivenIntegerPower3Not(int n) { | [
"n"
] | def find_whether_given_integer_power_3_not(n):
return ((1162261467 % n) == 0) | bool find_whether_given_integer_power_3_not(int n) {
return 1162261467 % n == 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... |
229 | First Element Occurring K Times Array | C++ | int firstElementOccurringKTimesArray(vector<int> arr, int n, int k) { | [
"arr",
"n",
"k"
] | def first_element_occurring_k_times_array(arr, n, k):
count_map = {
}
for i in range(0, n):
if (arr[i] in count_map.keys()):
count_map[arr[i]] += 1
else:
count_map[arr[i]] = 1
i += 1
for i in range(0, n):
if (count_map[arr[i]] == k):
... | int first_element_occurring_k_times_array(vector<int> arr, int n, int k) {
unordered_map < int, int > count_map;
for ( int i = 0;
i < n;
i ++ ) count_map [ arr [ i ] ] ++;
for ( int i = 0;
i < n;
i ++ ) if ( count_map [ arr [ i ] ] == k ) return arr [ 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... |
231 | Floor In A Sorted Array 1 | C++ | int floorInASortedArray1(vector<int> arr, int low, int high, int x) { | [
"arr",
"low",
"high",
"x"
] | def floor_in_a_sorted_array_1(arr, low, high, x):
if (low > high):
return (- 1)
if (x >= arr[high]):
return high
mid = int(((low + high) / 2))
if (arr[mid] == x):
return mid
if ((mid > 0) and (arr[(mid - 1)] <= x) and (x < arr[mid])):
return (mid - 1)
if (x < arr[... | int floor_in_a_sorted_array_1(vector<int> arr, int low, int high, int x) {
if ( low > high ) return - 1;
if ( x >= arr [ high ] ) return high;
int mid = ( low + high ) / 2;
if ( arr [ mid ] == x ) return mid;
if ( mid > 0 && arr [ mid - 1 ] <= x && x < arr [ mid ] ) return mid - 1;
if ( x < arr [ mid ] ) re... | {
"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... |
232 | Form Minimum Number From Given Sequence 1 | C++ | string formMinimumNumberFromGivenSequence1(string seq) { | [
"seq"
] | def form_minimum_number_from_given_sequence_1(seq):
n = len(seq)
if (n >= 9):
return '-1'
result = ([None] * (n + 1))
count = 1
for i in range((n + 1)):
if ((i == n) or (seq[i] == 'I')):
for j in range((i - 1), (- 2), (- 1)):
result[(j + 1)] = int(('0' + s... | string form_minimum_number_from_given_sequence_1(string seq) {
int n = seq . length ( );
if ( n >= 9 ) return "-1";
string result ( n + 1, ' ' );
int count = 1;
for ( int i = 0;
i <= n;
i ++ ) {
if ( i == n || seq [ i ] == 'I' ) {
for ( int j = i - 1;
j >= - 1;
j -- ) {
resul... | {
"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... |
233 | Form Smallest Number Using One Swap Operation | C++ | string formSmallestNumberUsingOneSwapOperation(string num) { | [
"num"
] | def form_smallest_number_using_one_swap_operation(num):
num = list(num)
n = len(num)
rightMin = ([0] * n)
right = 0
rightMin[(n - 1)] = (- 1)
right = (n - 1)
for i in range((n - 2), 0, (- 1)):
if (num[i] > num[right]):
rightMin[i] = right
else:
rightMi... | string form_smallest_number_using_one_swap_operation(string num) {
int n = num . size ( );
int rightMin [ n ], right;
rightMin [ n - 1 ] = - 1;
right = n - 1;
for ( int i = n - 2;
i >= 1;
i -- ) {
if ( num [ i ] >= num [ right ] ) rightMin [ i ] = right;
else {
if ( num [ i ] == num [ i + 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... |
234 | Frequent Element Array | C++ | int frequentElementArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def frequent_element_array(arr, n):
arr.sort()
max_count = 1
res = arr[0]
curr_count = 1
for i in range(1, n):
if (arr[i] == arr[(i - 1)]):
curr_count += 1
else:
if (curr_count > max_count):
max_count = curr_count
res = arr[(i -... | int frequent_element_array(vector<int> arr, int n) {
sort(arr.begin(), arr.end());
int max_count = 1, res = arr [ 0 ], curr_count = 1;
for ( int i = 1;
i < n;
i ++ ) {
if ( arr [ i ] == arr [ i - 1 ] ) curr_count ++;
else {
if ( curr_count > max_count ) {
max_count = curr_count;
... | {
"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... |
235 | Frequent Element Array 1 | C++ | int frequentElementArray1(vector<int> arr, int n) { | [
"arr",
"n"
] | def frequent_element_array_1(arr, n):
Hash = dict()
for i in range(n):
if (arr[i] in Hash.keys()):
Hash[arr[i]] += 1
else:
Hash[arr[i]] = 1
max_count = 0
res = (- 1)
for i in Hash:
if (max_count < Hash[i]):
res = i
max_count = H... | int frequent_element_array_1(vector<int> arr, int n) {
unordered_map < int, int > hash;
for ( int i = 0;
i < n;
i ++ ) hash [ arr [ i ] ] ++;
int max_count = 0, res = - 1;
for ( auto i : hash ) {
if ( max_count < i . second ) {
res = i . first;
max_count = i . second;
}
}
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... |
237 | Friends Pairing Problem 2 | C++ | long long friendsPairingProblem2(int n) { | [
"n"
] | def friends_pairing_problem_2(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 | int friends_pairing_problem_2(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;
} | {
"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... |
239 | Gcd Elements Given Range | C++ | int gcdElementsGivenRange(int n, int m) { | [
"n",
"m"
] | def gcd_elements_given_range(n, m):
return (n if (n == m) else 1) | int gcd_elements_given_range(int n, int m) {
return ( n == m ) ? 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... |
240 | Given A Sorted And Rotated Array Find If There Is A Pair With A Given Sum | C++ | bool givenASortedAndRotatedArrayFindIfThereIsAPairWithAGivenSum(vector<int> arr, int n, int x) { | [
"arr",
"n",
"x"
] | def given_a_sorted_and_rotated_array_find_if_there_is_a_pair_with_a_given_sum(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]) <... | bool given_a_sorted_and_rotated_array_find_if_there_is_a_pair_with_a_given_sum(vector<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... | {
"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... |
241 | Given A Sorted And Rotated Array Find If There Is A Pair With A Given Sum 1 | C++ | int givenASortedAndRotatedArrayFindIfThereIsAPairWithAGivenSum1(vector<int> arr, int n, int x) { | [
"arr",
"n",
"x"
] | def given_a_sorted_and_rotated_array_find_if_there_is_a_pair_with_a_given_sum_1(arr, n, x):
for i in range(n):
if (arr[i] > arr[(i + 1)]):
break
l = ((i + 1) % n)
r = i
cnt = 0
while (l != r):
if ((arr[l] + arr[r]) == x):
cnt += 1
if (l == (((r - 1... | int given_a_sorted_and_rotated_array_find_if_there_is_a_pair_with_a_given_sum_1(vector<int> arr, int n, int x) {
int i;
for ( i = 0;
i < n - 1;
i ++ ) if ( arr [ i ] > arr [ i + 1 ] ) break;
int l = ( i + 1 ) % n;
int r = i;
int cnt = 0;
while ( l != r ) {
if ( arr [ l ] + arr [ r ] == x ) {
c... | {
"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... |
242 | Google Case Given Sentence | C++ | string googleCaseGivenSentence(string s) { | [
"s"
] | def google_case_given_sentence(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 | string google_case_given_sentence(string s) {
int n = s . length ( );
s [ 0 ] = tolower ( s [ 0 ] );
for ( int i = 1;
i < n;
i ++ ) {
if ( s [ i ] == ' ' && i < n ) {
s [ i + 1 ] = tolower ( s [ i + 1 ] );
i ++;
}
else s [ i ] = toupper ( s [ i ] );
}
return 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... |
243 | Hardy Ramanujan Theorem | C++ | int hardyRamanujanTheorem(int n) { | [
"n"
] | def hardy_ramanujan_theorem(n):
count = 0
if ((n % 2) == 0):
count = (count + 1)
while ((n % 2) == 0):
n = int((n / 2))
i = 3
while (i <= int(math.sqrt(n))):
if ((n % i) == 0):
count = (count + 1)
while ((n % i) == 0):
n = int((... | int hardy_ramanujan_theorem(int n) {
int count = 0;
if ( n % 2 == 0 ) {
count ++;
while ( n % 2 == 0 ) n = n / 2;
}
for ( int i = 3;
i <= sqrt ( n );
i = i + 2 ) {
if ( n % i == 0 ) {
count ++;
while ( n % i == 0 ) n = n / i;
}
}
if ( n > 2 ) count ++;
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... |
244 | Height Complete Binary Tree Heap N Nodes | C++ | int heightCompleteBinaryTreeHeapNNodes(int n) { | [
"n"
] | def height_complete_binary_tree_heap_n_nodes(N):
return (math.ceil(math.log2((N + 1))) - 1) | int height_complete_binary_tree_heap_n_nodes(int N) {
return ceil ( log2 ( N + 1 ) ) - 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... |
245 | Hexagonal Number | C++ | int hexagonalNumber(int n) { | [
"n"
] | def hexagonal_number(n):
return (n * ((2 * n) - 1)) | int hexagonal_number(int n) {
return n * ( 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... |
246 | Highway Billboard Problem | C++ | int highwayBillboardProblem(int m, vector<int> x, vector<int> revenue, int n, int t) { | [
"m",
"x",
"revenue",
"n",
"t"
] | def highway_billboard_problem(m, x, revenue, n, t):
maxRev = ([0] * (m + 1))
nxtbb = 0
for i in range(1, (m + 1)):
if (nxtbb < n):
if (x[nxtbb] != i):
maxRev[i] = maxRev[(i - 1)]
else:
if (i <= t):
maxRev[i] = max(maxRev[(i ... | int highway_billboard_problem(int m, vector<int> x, vector<int> revenue, int n, int t) {
int maxRev [ m + 1 ];
memset ( maxRev, 0, sizeof ( maxRev ) );
int nxtbb = 0;
for ( int i = 1;
i <= m;
i ++ ) {
if ( nxtbb < n ) {
if ( x [ nxtbb ] != i ) maxRev [ i ] = maxRev [ i - 1 ];
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... |
247 | Horners Method Polynomial Evaluation | C++ | long long hornersMethodPolynomialEvaluation(vector<int> poly, int n, int x) { | [
"poly",
"n",
"x"
] | def horners_method_polynomial_evaluation(poly, n, x):
result = poly[0]
for i in range(1, n):
result = ((result * x) + poly[i])
return result | int horners_method_polynomial_evaluation(vector<int> poly, int n, int x) {
int result = poly [ 0 ];
for ( int i = 1;
i < n;
i ++ ) result = result * x + poly [ 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... |
248 | How To Check If A Given Array Represents A Binary Heap | C++ | bool howToCheckIfAGivenArrayRepresentsABinaryHeap(vector<int> arr, int i, int n) { | [
"arr",
"i",
"n"
] | def how_to_check_if_a_given_array_represents_a_binary_heap(arr, i, n):
if (i > int(((n - 2) / 2))):
return True
if ((arr[i] >= arr[((2 * i) + 1)]) and (arr[i] >= arr[((2 * i) + 2)]) and how_to_check_if_a_given_array_represents_a_binary_heap(arr, ((2 * i) + 1), n) and how_to_check_if_a_given_array_repres... | bool how_to_check_if_a_given_array_represents_a_binary_heap(vector<int> arr, int i, int n) {
if ( i > ( n - 2 ) / 2 ) return true;
if ( arr [ i ] >= arr [ 2 * i + 1 ] && arr [ i ] >= arr [ 2 * i + 2 ] && how_to_check_if_a_given_array_represents_a_binary_heap ( arr, 2 * i + 1, n ) && how_to_check_if_a_given_array_re... | {
"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... |
249 | How To Check If A Given Array Represents A Binary Heap 1 | C++ | bool howToCheckIfAGivenArrayRepresentsABinaryHeap1(vector<int> arr, int n) { | [
"arr",
"n"
] | def how_to_check_if_a_given_array_represents_a_binary_heap_1(arr, n):
for i in range((int(((n - 2) / 2)) + 1)):
if (arr[((2 * i) + 1)] > arr[i]):
return False
if ((((2 * i) + 2) < n) and (arr[((2 * i) + 2)] > arr[i])):
return False
return True | bool how_to_check_if_a_given_array_represents_a_binary_heap_1(vector<int> arr, int n) {
for ( int i = 0;
i <= ( n - 2 ) / 2;
i ++ ) {
if ( arr [ 2 * i + 1 ] > arr [ i ] ) return false;
if ( 2 * i + 2 < n && arr [ 2 * i + 2 ] > arr [ i ] ) 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... |
250 | How To Print Maximum Number Of A Using Given Four Keys | C++ | long long howToPrintMaximumNumberOfAUsingGivenFourKeys(int n) { | [
"n"
] | def how_to_print_maximum_number_of_a_using_given_four_keys(N):
if (N <= 6):
return N
screen = ([0] * N)
for n in range(1, 7):
screen[(n - 1)] = n
for n in range(7, (N + 1)):
screen[(n - 1)] = max((2 * screen[(n - 4)]), max((3 * screen[(n - 5)]), (4 * screen[(n - 6)])))
return... | int how_to_print_maximum_number_of_a_using_given_four_keys(int N) {
if ( N <= 6 ) return N;
int screen [ N ];
int b;
int n;
for ( n = 1;
n <= 6;
n ++ ) screen [ n - 1 ] = n;
for ( n = 7;
n <= N;
n ++ ) {
screen [ n - 1 ] = max ( 2 * screen [ n - 4 ], max ( 3 * screen [ n - 5 ], 4 * screen [ 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... |
251 | How To Turn Off A Particular Bit In A Number | C++ | int howToTurnOffAParticularBitInANumber(int n, int k) { | [
"n",
"k"
] | def how_to_turn_off_a_particular_bit_in_a_number(n, k):
if (k <= 0):
return n
return (n & (~ (1 << (k - 1)))) | int how_to_turn_off_a_particular_bit_in_a_number(int n, int k) {
if ( k <= 0 ) return n;
return ( n & ~ ( 1 << ( k - 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... |
252 | Hypercube Graph | C++ | long long hypercubeGraph(int n) { | [
"n"
] | def hypercube_graph(n):
if (n == 1):
return 2
return (2 * hypercube_graph((n - 1))) | int hypercube_graph(int n) {
if ( n == 1 ) return 2;
return 2 * hypercube_graph ( 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... |
253 | Integer Positive Value Positive Negative Value Array | C++ | int integerPositiveValuePositiveNegativeValueArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def integer_positive_value_positive_negative_value_array(arr, n):
hash = dict()
maximum = 0
for i in arr:
if (i < 0):
if (abs(i) not in hash.keys()):
hash[abs(i)] = (- 1)
else:
hash[abs(i)] -= 1
else:
hash[i] = (hash.get(i, ... | int integer_positive_value_positive_negative_value_array(vector<int> arr, int n) {
unordered_map < int, int > hash;
int maximum = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] < 0 ) hash [ abs ( arr [ i ] ) ] -= 1;
else hash [ arr [ i ] ] += 1;
}
for ( int i = 0;
i < n;
i ++ ) if ( hash [... | {
"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... |
254 | Integer Positive Value Positive Negative Value Array 1 | C++ | double integerPositiveValuePositiveNegativeValueArray1(vector<int> arr, int n) { | [
"arr",
"n"
] | def integer_positive_value_positive_negative_value_array_1(arr, n):
neg = 0
pos = 0
sum = 0
for i in range(0, n):
sum += arr[i]
if (arr[i] < 0):
neg += 1
else:
pos += 1
return (sum / abs((neg - pos))) | int integer_positive_value_positive_negative_value_array_1(vector<int> arr, int n) {
int neg = 0, pos = 0;
int sum = 0;
for ( int i = 0;
i < n;
i ++ ) {
sum += arr [ i ];
if ( arr [ i ] < 0 ) neg ++;
else pos ++;
}
return ( sum / abs ( neg - 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... |
255 | K Numbers Difference Maximum Minimum K Number Minimized | C++ | long long kNumbersDifferenceMaximumMinimumKNumberMinimized(vector<int> arr, int n, int k) { | [
"arr",
"n",
"k"
] | def k_numbers_difference_maximum_minimum_k_number_minimized(arr, n, k):
result = (+ 2147483647)
arr.sort()
for i in range(((n - k) + 1)):
result = int(min(result, (arr[((i + k) - 1)] - arr[i])))
return result | int k_numbers_difference_maximum_minimum_k_number_minimized(vector<int> arr, int n, int k) {
int result = INT_MAX;
sort(arr.begin(), arr.end());
for ( int i = 0;
i <= n - k;
i ++ ) result = min ( result, arr [ i + k - 1 ] - 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... |
256 | K Th Digit Raised Power B | C++ | double kThDigitRaisedPowerB(int a, int b, int k) { | [
"a",
"b",
"k"
] | def k_th_digit_raised_power_b(a, b, k):
p = (a ** b)
count = 0
while ((p > 0) and (count < k)):
rem = (p % 10)
count = (count + 1)
if (count == k):
return rem
p = (p / 10) | int k_th_digit_raised_power_b(int a, int b, int k) {
int p = pow ( a, b );
int count = 0;
while ( p > 0 && count < k ) {
int rem = p % 10;
count ++;
if ( count == k ) return rem;
p = p / 10;
}
return 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... |
257 | K Th Distinct Or Non Repeating Element In An Array | C++ | int kThDistinctOrNonRepeatingElementInAnArray(vector<int> arr, int n, int k) { | [
"arr",
"n",
"k"
] | def k_th_distinct_or_non_repeating_element_in_an_array(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):
... | int k_th_distinct_or_non_repeating_element_in_an_array(vector<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... | {
"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... |
258 | K Th Distinct Or Non Repeating Element In An Array 1 | C++ | int kThDistinctOrNonRepeatingElementInAnArray1(vector<int> arr, int size, int kthindex) { | [
"arr",
"size",
"kthindex"
] | def k_th_distinct_or_non_repeating_element_in_an_array_1(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)... | int k_th_distinct_or_non_repeating_element_in_an_array_1(vector<int> arr, int n, int k) {
unordered_map < int, int > h;
for ( int i = 0;
i < n;
i ++ ) h [ arr [ i ] ] ++;
if ( h . size ( ) < k ) return - 1;
int dist_count = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( h [ arr [ i ] ] == 1 ) dist_count... | {
"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... |
259 | K Th Element Two Sorted Arrays | C++ | int kThElementTwoSortedArrays(vector<int> arr1, vector<int> arr2, int m, int n, int k) { | [
"arr1",
"arr2",
"m",
"n",
"k"
] | def k_th_element_two_sorted_arrays(arr1, arr2, m, n, k):
sorted1 = ([0] * (m + n))
i = 0
j = 0
d = 0
while ((i < m) and (j < n)):
if (arr1[i] < arr2[j]):
sorted1[d] = arr1[i]
i += 1
else:
sorted1[d] = arr2[j]
j += 1
d += 1
w... | int k_th_element_two_sorted_arrays(vector<int> arr1, vector<int> arr2, int m, int n, int k) {
int sorted1 [ m + n ];
int i = 0, j = 0, d = 0;
while ( i < m && j < n ) {
if ( arr1 [ i ] < arr2 [ j ] ) sorted1 [ d ++ ] = arr1 [ i ++ ];
else sorted1 [ d ++ ] = arr2 [ j ++ ];
}
while ( i < m ) sorted1 [ d... | {
"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... |
260 | K Th Largest Sum Contiguous Subarray | C++ | int kThLargestSumContiguousSubarray(vector<int> arr, int n, int k) { | [
"arr",
"n",
"k"
] | def k_th_largest_sum_contiguous_subarray(arr, n, k):
sum = []
sum.append(0)
sum.append(arr[0])
for i in range(2, (n + 1)):
sum.append((sum[(i - 1)] + arr[(i - 1)]))
Q = []
heapq.heapify(Q)
for i in range(1, (n + 1)):
for j in range(i, (n + 1)):
x = (sum[j] - sum[(... | int k_th_largest_sum_contiguous_subarray(vector<int> arr, int n, int k) {
int sum [ n + 1 ];
sum [ 0 ] = 0;
sum [ 1 ] = arr [ 0 ];
for ( int i = 2;
i <= n;
i ++ ) sum [ i ] = sum [ i - 1 ] + arr [ i - 1 ];
priority_queue < int, vector < int >, greater < int > > Q;
for ( int i = 1;
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... |
261 | K Th Prime Factor Given Number | C++ | float kThPrimeFactorGivenNumber(int n, int k) { | [
"n",
"k"
] | def k_th_prime_factor_given_number(n, k):
while ((n % 2) == 0):
k = (k - 1)
n = (n / 2)
if (k == 0):
return 2
i = 3
while (i <= math.sqrt(n)):
while ((n % i) == 0):
if (k == 1):
return i
k = (k - 1)
n = (n / i)
... | int k_th_prime_factor_given_number(int n, int k) {
while ( n % 2 == 0 ) {
k --;
n = n / 2;
if ( k == 0 ) return 2;
}
for ( int i = 3;
i <= sqrt ( n );
i = i + 2 ) {
while ( n % i == 0 ) {
if ( k == 1 ) return i;
k --;
n = n / i;
}
}
if ( n > 2 && k == 1 ) 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... |
263 | Largest Subarray With Equal Number Of 0S And 1S 1 | C++ | int largestSubarrayWithEqualNumberOf0SAnd1S1(vector<int> arr, int n) { | [
"arr",
"n"
] | def largest_subarray_with_equal_number_of_0s_and_1s_1(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_... | int largest_subarray_with_equal_number_of_0s_and_1s_1(vector<int> arr, int n) {
unordered_map < int, int > hM;
int sum = 0;
int max_len = 0;
int ending_index = - 1;
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = ( arr [ i ] == 0 ) ? - 1 : 1;
for ( int i = 0;
i < n;
i ++ ) {
sum += arr [ i ];
if ... | {
"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... |
264 | Largest Subsequence Gcd Greater 1 | C++ | int largestSubsequenceGcdGreater1(vector<int> arr, int n) { | [
"arr",
"n"
] | def largest_subsequence_gcd_greater_1(arr, n):
ans = 0
maxele = max(arr)
for i in range(2, (maxele + 1)):
count = 0
for j in range(n):
if ((arr[j] % i) == 0):
count += 1
ans = max(ans, count)
return ans | int largest_subsequence_gcd_greater_1(vector<int> arr, int n) {
int ans = 0;
int maxele = * max_element(arr.begin(), arr.end());
for ( int i = 2;
i <= maxele;
++ i ) {
int count = 0;
for ( int j = 0;
j < n;
++ j ) {
if ( arr [ j ] % i == 0 ) ++ count;
}
ans = max ( ans, 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... |
265 | Largest Sum Contiguous Subarray 2 | C++ | int largestSumContiguousSubarray2(vector<int> a, int size) { | [
"a",
"size"
] | def largest_sum_contiguous_subarray_2(a, size):
max_so_far = a[0]
curr_max = a[0]
for i in range(1, size):
curr_max = max(a[i], (curr_max + a[i]))
max_so_far = max(max_so_far, curr_max)
return max_so_far | int largest_sum_contiguous_subarray_2(vector<int> a, int size) {
int max_so_far = a [ 0 ];
int curr_max = a [ 0 ];
for ( int i = 1;
i < size;
i ++ ) {
curr_max = max ( a [ i ], curr_max + a [ i ] );
max_so_far = max ( max_so_far, curr_max );
}
return max_so_far;
} | {
"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... |
266 | Lcs Formed Consecutive Segments Least Length K | C++ | int lcsFormedConsecutiveSegmentsLeastLengthK(int k, string s1, string s2) { | [
"k",
"s1",
"s2"
] | def lcs_formed_consecutive_segments_least_length_k(k, s1, s2):
n = len(s1)
m = len(s2)
lcs = [[0 for x in range((m + 1))] for y in range((n + 1))]
cnt = [[0 for x in range((m + 1))] for y in range((n + 1))]
for i in range(1, (n + 1)):
for j in range(1, (m + 1)):
lcs[i][j] = max(l... | int lcs_formed_consecutive_segments_least_length_k(int k, string s1, string s2) {
int n = s1 . length ( );
int m = s2 . length ( );
int lcs [ n + 1 ] [ m + 1 ];
int cnt [ n + 1 ] [ m + 1 ];
memset ( lcs, 0, sizeof ( lcs ) );
memset ( cnt, 0, sizeof ( cnt ) );
for ( int i = 1;
i <= n;
i ++ ) {
for ... | {
"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... |
267 | Length Longest Strict Bitonic Subsequence | C++ | int lengthLongestStrictBitonicSubsequence(vector<int> arr, int n) { | [
"arr",
"n"
] | def length_longest_strict_bitonic_subsequence(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] = (... | int length_longest_strict_bitonic_subsequence(vector<int> arr, int n) {
unordered_map < int, int > inc, dcr;
int len_inc [ n ], len_dcr [ n ];
int longLen = 0;
for ( int i = 0;
i < n;
i ++ ) {
int len = 0;
if ( inc . find ( arr [ i ] - 1 ) != inc . end ( ) ) len = inc [ arr [ i ] - 1 ];
inc [ ar... | {
"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... |
268 | Length Longest Sub String Can Make Removed | C++ | int lengthLongestSubStringCanMakeRemoved(string s) { | [
"s"
] | def length_longest_sub_string_can_make_removed(S):
arr = []
arr.append(['@', (- 1)])
maxlen = 0
for i in range(len(S)):
arr.append([S[i], i])
while ((len(arr) >= 3) and (arr[(len(arr) - 3)][0] == '1') and (arr[(len(arr) - 2)][0] == '0') and (arr[(len(arr) - 1)][0] == '0')):
a... | int length_longest_sub_string_can_make_removed(string str) {
vector < pair < char, int > > arr;
arr . push_back ( {
'@', - 1 }
);
int maxlen = 0;
for ( int i = 0;
i < str . length ( );
++ i ) {
arr . push_back ( {
str [ i ], i }
);
while ( arr . size ( ) >= 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... |
269 | Length Of The Longest Arithmatic Progression In A Sorted Array | C++ | int lengthOfTheLongestArithmaticProgressionInASortedArray(vector<int> set_arg0, int n) { | [
"set_arg0",
"n"
] | def length_of_the_longest_arithmatic_progression_in_a_sorted_array(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 >... | int length_of_the_longest_arithmatic_progression_in_a_sorted_array(vector<int> set, int n) {
if ( n <= 2 ) return n;
int L [ n ] [ n ];
int llap = 2;
for ( int i = 0;
i < n;
i ++ ) L [ i ] [ n - 1 ] = 2;
for ( int j = n - 2;
j >= 1;
j -- ) {
int i = j - 1, k = j + 1;
while ( i >= 0 && k <= n -... | {
"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... |
270 | Leonardo Number 1 | C++ | long long leonardoNumber1(int n) { | [
"n"
] | def leonardo_number_1(n):
dp = []
dp.append(1)
dp.append(1)
for i in range(2, (n + 1)):
dp.append(((dp[(i - 1)] + dp[(i - 2)]) + 1))
return dp[n] | int leonardo_number_1(int n) {
int dp [ n + 1 ];
dp [ 0 ] = dp [ 1 ] = 1;
for ( int i = 2;
i <= n;
i ++ ) dp [ i ] = dp [ i - 1 ] + dp [ i - 2 ] + 1;
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... |
271 | Lexicographically Minimum String Rotation | C++ | string lexicographicallyMinimumStringRotation(string str_) { | [
"str_"
] | def lexicographically_minimum_string_rotation(str_):
n = len(str_)
arr = ([0] * n)
concat = (str_ + str_)
for i in range(n):
arr[i] = concat[i:(n + i)]
arr.sort()
return arr[0] | string lexicographically_minimum_string_rotation(string str) {
int n = str . length ( );
string arr [ n ];
string concat = str + str;
for ( int i = 0;
i < n;
i ++ ) arr [ i ] = concat . substr ( i, n );
sort ( arr, arr + n );
return arr [ 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... |
272 | Lexicographically Next String | C++ | string lexicographicallyNextString(string s) { | [
"s"
] | def lexicographically_next_string(s):
if (s == ' '):
return 'a'
i = (len(s) - 1)
while ((s[i] == 'z') and (i >= 0)):
i -= 1
if (i == (- 1)):
s = (s + 'a')
else:
s = s.replace(s[i], chr((ord(s[i]) + 1)), 1)
return s | string lexicographically_next_string(string s) {
if ( s == "" ) return "a";
int i = s . length ( ) - 1;
while ( s [ i ] == 'z' && i >= 0 ) i --;
if ( i == - 1 ) s = s + 'a';
else s [ i ] ++;
return 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... |
273 | Lexicographical Concatenation Substrings String | C++ | string lexicographicalConcatenationSubstringsString(string s) { | [
"s"
] | def lexicographical_concatenation_substrings_string(s):
n = len(s)
sub_count = ((n * (n + 1)) // 2)
arr = ([0] * sub_count)
index = 0
for i in range(n):
for j in range(1, ((n - i) + 1)):
arr[index] = s[i:(i + j)]
index += 1
arr.sort()
res = ''
for i in ran... | string lexicographical_concatenation_substrings_string(string s) {
int n = s . length ( );
int sub_count = n * ( n + 1 ) / 2;
string arr [ sub_count ];
int index = 0;
for ( int i = 0;
i < n;
i ++ ) for ( int len = 1;
len <= n - i;
len ++ ) arr [ index ++ ] = s . substr ( i, len );
sort ( arr, arr + ... | {
"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... |
275 | Longest Common Increasing Subsequence Lcs Lis | C++ | int longestCommonIncreasingSubsequenceLcsLis(vector<int> arr1, int n, vector<int> arr2, int m) { | [
"arr1",
"n",
"arr2",
"m"
] | def longest_common_increasing_subsequence_lcs_lis(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] = ... | int longest_common_increasing_subsequence_lcs_lis(vector<int> arr1, int n, vector<int> arr2, int m) {
int table [ m ];
for ( int j = 0;
j < m;
j ++ ) table [ j ] = 0;
for ( int i = 0;
i < n;
i ++ ) {
int current = 0;
for ( int j = 0;
j < m;
j ++ ) {
if ( arr1 [ i ] == arr2 [ j ] ) if... | {
"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... |
276 | Longest Increasing Odd Even Subsequence | C++ | int longestIncreasingOddEvenSubsequence(vector<int> arr, int n) { | [
"arr",
"n"
] | def longest_increasing_odd_even_subsequence(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... | int longest_increasing_odd_even_subsequence(vector<int> arr, int n) {
int lioes [ 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... | {
"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... |
277 | Longest Palindrome Subsequence Space | C++ | int longestPalindromeSubsequenceSpace(string s) { | [
"s"
] | def longest_palindrome_subsequence_space(s):
n = len(s)
a = ([0] * n)
for i in range((n - 1), (- 1), (- 1)):
back_up = 0
for j in range(i, n):
if (j == i):
a[j] = 1
elif (s[i] == s[j]):
temp = a[j]
a[j] = (back_up + 2)
... | int longest_palindrome_subsequence_space(string & s) {
int n = s . length ( );
int a [ n ];
for ( int i = n - 1;
i >= 0;
i -- ) {
int back_up = 0;
for ( int j = i;
j < n;
j ++ ) {
if ( j == i ) a [ j ] = 1;
else if ( s [ i ] == s [ j ] ) {
int temp = a [ j ];
a [ 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... |
278 | Longest Prefix Also Suffix 1 | C++ | int longestPrefixAlsoSuffix1(string s) { | [
"s"
] | def longest_prefix_also_suffix_1(s):
n = len(s)
lps = ([0] * n)
l = 0
i = 1
while (i < n):
if (s[i] == s[l]):
l = (l + 1)
lps[i] = l
i = (i + 1)
elif (l != 0):
l = lps[(l - 1)]
else:
lps[i] = 0
i = (i + 1... | int longest_prefix_also_suffix_1(string s) {
int n = s . length ( );
int lps [ n ];
lps [ 0 ] = 0;
int len = 0;
int i = 1;
while ( i < n ) {
if ( s [ i ] == s [ len ] ) {
len ++;
lps [ i ] = len;
i ++;
}
else {
if ( len != 0 ) {
len = lps [ len - 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... |
279 | Longest Repeated Subsequence 1 | C++ | string longestRepeatedSubsequence1(string str) { | [
"str"
] | def longest_repeated_subsequence_1(str):
n = len(str)
dp = [[0 for i in range((n + 1))] for j in range((n + 1))]
for i in range(1, (n + 1)):
for j in range(1, (n + 1)):
if ((str[(i - 1)] == str[(j - 1)]) and (i != j)):
dp[i][j] = (1 + dp[(i - 1)][(j - 1)])
els... | string longest_repeated_subsequence_1(string str) {
int n = str . length ( );
int dp [ n + 1 ] [ n + 1 ];
for ( int i = 0;
i <= n;
i ++ ) for ( int j = 0;
j <= n;
j ++ ) dp [ i ] [ j ] = 0;
for ( int i = 1;
i <= n;
i ++ ) for ( int j = 1;
j <= n;
j ++ ) if ( str [ i - 1 ] == str [ j - 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... |
280 | Longest Repeating And Non Overlapping Substring | C++ | string longestRepeatingAndNonOverlappingSubstring(string str) { | [
"str"
] | def longest_repeating_and_non_overlapping_substring(str):
n = len(str)
LCSRe = [[0 for x in range((n + 1))] for y in range((n + 1))]
res = ''
res_length = 0
index = 0
for i in range(1, (n + 1)):
for j in range((i + 1), (n + 1)):
if ((str[(i - 1)] == str[(j - 1)]) and (LCSRe[(... | string longest_repeating_and_non_overlapping_substring(string str) {
int n = str . length ( );
int LCSRe [ n + 1 ] [ n + 1 ];
memset ( LCSRe, 0, sizeof ( LCSRe ) );
string res;
int res_length = 0;
int i, index = 0;
for ( i = 1;
i <= n;
i ++ ) {
for ( int j = i + 1;
j <= n;
j ++ ) {
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... |
281 | Longest Repeating Subsequence | C++ | int longestRepeatingSubsequence(string str) { | [
"str"
] | def longest_repeating_subsequence(str):
n = len(str)
dp = ([([0] * (n + 1))] * (n + 1))
for i in range(1, (n + 1)):
for j in range(1, (n + 1)):
if ((str[(i - 1)] == str[(j - 1)]) and (i != j)):
dp[i][j] = (1 + dp[(i - 1)][(j - 1)])
else:
dp[i][... | int longest_repeating_subsequence(string str) {
int n = str . length ( );
int dp [ n + 1 ] [ n + 1 ];
for ( int i = 0;
i <= n;
i ++ ) for ( int j = 0;
j <= n;
j ++ ) dp [ i ] [ j ] = 0;
for ( int i = 1;
i <= n;
i ++ ) {
for ( int j = 1;
j <= n;
j ++ ) {
if ( str [ i - 1 ] == str [ ... | {
"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... |
282 | Longest Subarray Count 1S One Count 0S | C++ | int longestSubarrayCount1SOneCount0S(vector<int> arr, int n) { | [
"arr",
"n"
] | def longest_subarray_count_1s_one_count_0s(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[... | int longest_subarray_count_1s_one_count_0s(vector<int> arr, int n) {
unordered_map < int, int > um;
int sum = 0, maxLen = 0;
for ( int i = 0;
i < n;
i ++ ) {
sum += arr [ i ] == 0 ? - 1 : 1;
if ( sum == 1 ) maxLen = i + 1;
else if ( um . find ( sum ) == um . end ( ) ) um [ sum ] = i;
if ( um .... | {
"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... |
283 | Longest Subsequence Such That Difference Between Adjacents Is One | C++ | int longestSubsequenceSuchThatDifferenceBetweenAdjacentsIsOne(vector<int> arr, int n) { | [
"arr",
"n"
] | def longest_subsequence_such_that_difference_between_adjacents_is_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == (arr[j] + 1)) or (arr[i] == (arr[j] - 1))):
dp[i] = max(dp[i], (dp[j] + 1))
result = 1
for i in range(n):
... | int longest_subsequence_such_that_difference_between_adjacents_is_one(vector<int> arr, int n) {
int dp [ n ];
for ( int i = 0;
i < n;
i ++ ) dp [ i ] = 1;
for ( int i = 1;
i < n;
i ++ ) {
for ( int j = 0;
j < i;
j ++ ) {
if ( ( arr [ i ] == arr [ j ] + 1 ) || ( arr [ i ] == arr [ 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... |
284 | Lower Insertion Point | C++ | int lowerInsertionPoint(vector<int> arr, int n, int x) { | [
"arr",
"n",
"x"
] | def lower_insertion_point(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 lowerPn... | int lower_insertion_point(vector<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... | {
"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... |
285 | Making Elements Of Two Arrays Same With Minimum Incrementdecrement | C++ | int makingElementsOfTwoArraysSameWithMinimumIncrementdecrement(vector<int> a, vector<int> b, int n) { | [
"a",
"b",
"n"
] | def making_elements_of_two_arrays_same_with_minimum_incrementdecrement(a, b, n):
a.sort(reverse=False)
b.sort(reverse=False)
result = 0
for i in range(0, n, 1):
if (a[i] > b[i]):
result = (result + abs((a[i] - b[i])))
elif (a[i] < b[i]):
result = (result + abs((a[... | int making_elements_of_two_arrays_same_with_minimum_incrementdecrement(vector<int> a, vector<int> b, int n) {
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int result = 0;
for ( int i = 0;
i < n;
++ i ) {
result = result + abs ( a [ i ] - b [ 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... |
286 | Maximize Sum Arrii | C++ | int maximizeSumArrii(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximize_sum_arrii(arr, n):
arr.sort()
sum = 0
for i in range(n):
sum += (arr[i] * i)
return sum | int maximize_sum_arrii(vector<int> arr, int n) {
sort(arr.begin(), arr.end());
int sum = 0;
for ( int i = 0;
i < n;
i ++ ) sum += ( arr [ i ] * 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... |
287 | Maximize Sum Consecutive Differences Circular Array | C++ | int maximizeSumConsecutiveDifferencesCircularArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximize_sum_consecutive_differences_circular_array(arr, n):
sum = 0
arr.sort()
for i in range(0, int((n / 2))):
sum -= (2 * arr[i])
sum += (2 * arr[((n - i) - 1)])
return sum | int maximize_sum_consecutive_differences_circular_array(vector<int> arr, int n) {
int sum = 0;
sort(arr.begin(), arr.end());
for ( int i = 0;
i < n / 2;
i ++ ) {
sum -= ( 2 * arr [ i ] );
sum += ( 2 * arr [ n - i - 1 ] );
}
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... |
288 | Maximize Volume Cuboid Given Sum Sides | C++ | int maximizeVolumeCuboidGivenSumSides(int s) { | [
"s"
] | def maximize_volume_cuboid_given_sum_sides(s):
maxvalue = 0
i = 1
for i in range((s - 1)):
j = 1
for j in range(s):
k = ((s - i) - j)
maxvalue = max(maxvalue, ((i * j) * k))
return maxvalue | int maximize_volume_cuboid_given_sum_sides(int s) {
int maxvalue = 0;
for ( int i = 1;
i <= s - 2;
i ++ ) {
for ( int j = 1;
j <= s - 1;
j ++ ) {
int k = s - i - j;
maxvalue = max ( maxvalue, i * j * k );
}
}
return maxvalue;
} | {
"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... |
289 | Maximize Volume Cuboid Given Sum Sides 1 | C++ | int maximizeVolumeCuboidGivenSumSides1(int s) { | [
"s"
] | def maximize_volume_cuboid_given_sum_sides_1(s):
length = int((s / 3))
s -= length
breadth = (s / 2)
height = (s - breadth)
return int(((length * breadth) * height)) | int maximize_volume_cuboid_given_sum_sides_1(int s) {
int length = s / 3;
s -= length;
int breadth = s / 2;
int height = s - breadth;
return length * breadth * 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... |
290 | Maximum Area Rectangle Picking Four Sides Array | C++ | int maximumAreaRectanglePickingFourSidesArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximum_area_rectangle_picking_four_sides_array(arr, n):
arr.sort(reverse=True)
dimension = [0, 0]
i = 0
j = 0
while ((i < (n - 1)) and (j < 2)):
if (arr[i] == arr[(i + 1)]):
dimension[j] = arr[i]
j += 1
i += 1
i += 1
return (dimension[0] *... | int maximum_area_rectangle_picking_four_sides_array(vector<int> arr, int n) {
sort(arr.begin(), arr.end(), greater < int > ( ) );
int dimension [ 2 ] = {
0, 0 };
for ( int i = 0, j = 0;
i < n - 1 && j < 2;
i ++ ) if ( arr [ i ] == arr [ i + 1 ] ) dimension [ j ++ ] = arr [ i ++ ];
return ( dimen... | {
"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... |
291 | Maximum Area Rectangle Picking Four Sides Array 1 | C++ | int maximumAreaRectanglePickingFourSidesArray1(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximum_area_rectangle_picking_four_sides_array_1(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):... | int maximum_area_rectangle_picking_four_sides_array_1(vector<int> arr, int n) {
unordered_set < int > s;
int first = 0, second = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( s . find ( arr [ i ] ) == s . end ( ) ) {
s . insert ( arr [ i ] );
continue;
}
if ( arr [ i ] > first ) {
sec... | {
"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... |
292 | Maximum Average Sum Partition Array | C++ | int maximumAverageSumPartitionArray(vector<int> a, int k) { | [
"a",
"k"
] | def maximum_average_sum_partition_array(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)):
... | double maximum_average_sum_partition_array(vector < int > & A, int K) {
int n = A . size ( );
double pre_sum [ n + 1 ];
pre_sum [ 0 ] = 0;
for ( int i = 0;
i < n;
i ++ ) pre_sum [ i + 1 ] = pre_sum [ i ] + A [ i ];
double dp [ n ] = {
0 };
double sum = 0;
for ( int i = 0;
i < n;
i ++ )... | {
"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... |
293 | Maximum Binomial Coefficient Term Value | C++ | long long maximumBinomialCoefficientTermValue(int n) { | [
"n"
] | def maximum_binomial_coefficient_term_value(n):
C = [[0 for x in range((n + 1))] for y in range((n + 1))]
for i in range((n + 1)):
for j in range((min(i, n) + 1)):
if ((j == 0) or (j == i)):
C[i][j] = 1
else:
C[i][j] = (C[(i - 1)][(j - 1)] + C[(i -... | int maximum_binomial_coefficient_term_value(int n) {
int C [ n + 1 ] [ n + 1 ];
for ( int i = 0;
i <= n;
i ++ ) {
for ( int 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 maxval... | {
"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... |
294 | Maximum Consecutive Numbers Present Array | C++ | int maximumConsecutiveNumbersPresentArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximum_consecutive_numbers_present_array(arr, n):
S = set()
for i in range(n):
S.add(arr[i])
ans = 0
for i in range(n):
if S.__contains__(arr[i]):
j = arr[i]
while S.__contains__(j):
j += 1
ans = max(ans, (j - arr[i]))
return a... | int maximum_consecutive_numbers_present_array(vector<int> arr, int n) {
unordered_set < int > S;
for ( int i = 0;
i < n;
i ++ ) S . insert ( arr [ i ] );
int ans = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( S . find ( arr [ i ] - 1 ) == S . end ( ) ) {
int j = arr [ i ];
while ( S . find (... | {
"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... |
297 | Maximum Distance Two Occurrences Element Array | C++ | int maximumDistanceTwoOccurrencesElementArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximum_distance_two_occurrences_element_array(arr, n):
mp = {
}
maxDict = 0
for i in range(n):
if (arr[i] not in mp.keys()):
mp[arr[i]] = i
else:
maxDict = max(maxDict, (i - mp[arr[i]]))
return maxDict | int maximum_distance_two_occurrences_element_array(vector<int> arr, int n) {
unordered_map < int, int > mp;
int max_dist = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( mp . find ( arr [ i ] ) == mp . end ( ) ) mp [ arr [ i ] ] = i;
else max_dist = max ( max_dist, i - mp [ arr [ i ] ] );
}
return max_d... | {
"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... |
298 | Maximum Equlibrium Sum Array | C++ | int maximumEqulibriumSumArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximum_equlibrium_sum_array(arr, n):
res = ((- sys.maxsize) - 1)
for i in range(n):
prefix_sum = arr[i]
for j in range(i):
prefix_sum += arr[j]
suffix_sum = arr[i]
j = (n - 1)
while (j > i):
suffix_sum += arr[j]
j -= 1
if (... | int maximum_equlibrium_sum_array(vector<int> arr, int n) {
int res = INT_MIN;
for ( int i = 0;
i < n;
i ++ ) {
int prefix_sum = arr [ i ];
for ( int j = 0;
j < i;
j ++ ) prefix_sum += arr [ j ];
int suffix_sum = arr [ i ];
for ( int j = n - 1;
j > i;
j -- ) suffix_sum += arr [ 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... |
299 | Maximum Games Played Winner | C++ | int maximumGamesPlayedWinner(int n) { | [
"n"
] | def maximum_games_played_winner(N):
dp = [0 for i in range(N)]
dp[0] = 1
dp[1] = 2
i = 1
while (dp[i] <= N):
i = (i + 1)
dp[i] = (dp[(i - 1)] + dp[(i - 2)])
return (i - 1) | int maximum_games_played_winner(int N) {
int dp [ N ];
dp [ 0 ] = 1;
dp [ 1 ] = 2;
int i = 2;
do {
dp [ i ] = dp [ i - 1 ] + dp [ i - 2 ];
}
while ( dp [ i ++ ] <= N );
return ( i - 2 );
} | {
"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... |
300 | Maximum Height Of Triangular Arrangement Of Array Values | C++ | int maximumHeightOfTriangularArrangementOfArrayValues(vector<int> a, int n) { | [
"a",
"n"
] | def maximum_height_of_triangular_arrangement_of_array_values(a, n):
result = 1
for i in range(1, n):
y = ((i * (i + 1)) / 2)
if (y < n):
result = i
else:
break
return result | int maximum_height_of_triangular_arrangement_of_array_values(vector<int> a, int n) {
int result = 1;
for ( int i = 1;
i <= n;
++ i ) {
long long y = ( i * ( i + 1 ) ) / 2;
if ( y < n ) result = i;
else break;
}
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... |
301 | Maximum Height Of Triangular Arrangement Of Array Values 1 | C++ | int maximumHeightOfTriangularArrangementOfArrayValues1(vector<int> a, int n) { | [
"a",
"n"
] | def maximum_height_of_triangular_arrangement_of_array_values_1(a, n):
return (((- 1) + int(math.sqrt((1 + (8 * n))))) // 2) | int maximum_height_of_triangular_arrangement_of_array_values_1(vector<int> a, int n) {
return floor ( ( - 1 + sqrt ( 1 + ( 8 * 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... |
303 | Maximum Length Subsequence Difference Adjacent Elements Either 0 1 | C++ | int maximumLengthSubsequenceDifferenceAdjacentElementsEither01(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximum_length_subsequence_difference_adjacent_elements_either_0_1(arr, n):
mls = []
max = 0
for i in range(n):
mls.append(1)
for i in range(n):
for j in range(i):
if ((abs((arr[i] - arr[j])) <= 1) and (mls[i] < (mls[j] + 1))):
mls[i] = (mls[j] + 1)
fo... | int maximum_length_subsequence_difference_adjacent_elements_either_0_1(vector<int> arr, int n) {
int mls [ n ], max = 0;
for ( int i = 0;
i < n;
i ++ ) mls [ i ] = 1;
for ( int i = 1;
i < n;
i ++ ) for ( int j = 0;
j < i;
j ++ ) if ( abs ( arr [ i ] - arr [ j ] ) <= 1 && mls [ i ] < mls [ j ] + 1 ) ml... | {
"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... |
304 | Maximum Number 2X2 Squares Can Fit Inside Right Isosceles Triangle | C++ | float maximumNumber2X2SquaresCanFitInsideRightIsoscelesTriangle(int base_arg0) { | [
"base_arg0"
] | def maximum_number_2x2_squares_can_fit_inside_right_isosceles_triangle(base):
base = (base - 2)
base = (base / 2)
return ((base * (base + 1)) / 2) | int maximum_number_2x2_squares_can_fit_inside_right_isosceles_triangle(int base) {
base = ( base - 2 );
base = base / 2;
return base * ( base + 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... |
305 | Maximum Number Characters Two Character String | C++ | int maximumNumberCharactersTwoCharacterString(string str) { | [
"str"
] | def maximum_number_characters_two_character_string(str):
n = len(str)
res = (- 1)
for i in range(0, (n - 1)):
for j in range((i + 1), n):
if (str[i] == str[j]):
res = max(res, abs(((j - i) - 1)))
return res | int maximum_number_characters_two_character_string(string & str) {
int n = str . length ( );
int res = - 1;
for ( int i = 0;
i < n - 1;
i ++ ) for ( int j = i + 1;
j < n;
j ++ ) if ( str [ i ] == str [ j ] ) res = max ( res, abs ( j - i - 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... |
306 | Maximum Number Chocolates Distributed Equally Among K Students | C++ | int maximumNumberChocolatesDistributedEquallyAmongKStudents(vector<int> arr, int n, int k) { | [
"arr",
"n",
"k"
] | def maximum_number_chocolates_distributed_equally_among_k_students(arr, n, k):
(um, curr_rem, maxSum) = ({
}, 0, 0)
sm = ([0] * n)
sm[0] = arr[0]
for i in range(1, n):
sm[i] = (sm[(i - 1)] + arr[i])
for i in range(n):
curr_rem = (sm[i] % k)
if ((not curr_rem) and... | int maximum_number_chocolates_distributed_equally_among_k_students(vector<int> arr, int n, int k) {
unordered_map < int, int > um;
int sum [ n ], curr_rem;
int maxSum = 0;
sum [ 0 ] = arr [ 0 ];
for ( int i = 1;
i < n;
i ++ ) sum [ i ] = sum [ i - 1 ] + arr [ i ];
for ( int i = 0;
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... |
307 | Maximum Number Of Squares That Can Be Fit In A Right Angle Isosceles Triangle | C++ | double maximumNumberOfSquaresThatCanBeFitInARightAngleIsoscelesTriangle(int b, int m) { | [
"b",
"m"
] | def maximum_number_of_squares_that_can_be_fit_in_a_right_angle_isosceles_triangle(b, m):
return ((((b / m) - 1) * (b / m)) / 2) | int maximum_number_of_squares_that_can_be_fit_in_a_right_angle_isosceles_triangle(int b, int m) {
return ( b / m - 1 ) * ( b / m ) / 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... |
308 | Maximum Number Segments Lengths B C | C++ | int maximumNumberSegmentsLengthsBC(int n, int a, int b, int c) { | [
"n",
"a",
"b",
"c"
] | def maximum_number_segments_lengths_b_c(n, a, b, c):
dp = ([(- 1)] * (n + 10))
dp[0] = 0
for i in range(0, n):
if (dp[i] != (- 1)):
if ((i + a) <= n):
dp[(i + a)] = max((dp[i] + 1), dp[(i + a)])
if ((i + b) <= n):
dp[(i + b)] = max((dp[i] + 1),... | int maximum_number_segments_lengths_b_c(int n, int a, int b, int c) {
int dp [ n + 1 ];
memset ( dp, - 1, sizeof ( dp ) );
dp [ 0 ] = 0;
for ( int i = 0;
i < n;
i ++ ) {
if ( dp [ i ] != - 1 ) {
if ( i + a <= n ) dp [ i + a ] = max ( dp [ i ] + 1, dp [ i + a ] );
if ( i + b <= n ) dp [ i + b... | {
"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... |
309 | Maximum Points Intersection N Circles | C++ | int maximumPointsIntersectionNCircles(int n) { | [
"n"
] | def maximum_points_intersection_n_circles(n):
return (n * (n - 1)) | int maximum_points_intersection_n_circles(int n) {
return 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... |
310 | Maximum Possible Difference Two Subsets Array | C++ | int maximumPossibleDifferenceTwoSubsetsArray(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximum_possible_difference_two_subsets_array(arr, n):
SubsetSum_1 = 0
SubsetSum_2 = 0
for i in range(0, n):
isSingleOccurance = True
for j in range((i + 1), n):
if (arr[i] == arr[j]):
isSingleOccurance = False
arr[i] = arr[j] = 0
... | int maximum_possible_difference_two_subsets_array(vector<int> arr, int n) {
int SubsetSum_1 = 0, SubsetSum_2 = 0;
for ( int i = 0;
i <= n - 1;
i ++ ) {
bool isSingleOccurance = true;
for ( int j = i + 1;
j <= n - 1;
j ++ ) {
if ( arr [ i ] == arr [ j ] ) {
isSingleOccurance = 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... |
311 | Maximum Possible Sum Window Array Elements Window Array Unique | C++ | int maximumPossibleSumWindowArrayElementsWindowArrayUnique(vector<int> a, vector<int> b, int n) { | [
"a",
"b",
"n"
] | def maximum_possible_sum_window_array_elements_window_array_unique(A, B, n):
mp = set()
result = 0
curr_sum = curr_begin = 0
for i in range(0, n):
while (A[i] in mp):
mp.remove(A[curr_begin])
curr_sum -= B[curr_begin]
curr_begin += 1
mp.add(A[i])
... | int maximum_possible_sum_window_array_elements_window_array_unique(vector<int> A, vector<int> B, int n) {
unordered_set < int > mp;
int result = 0;
int curr_sum = 0, curr_begin = 0;
for ( int i = 0;
i < n;
++ i ) {
while ( mp . find ( A [ i ] ) != mp . end ( ) ) {
mp . erase ( A [ curr_begin ] );
... | {
"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... |
313 | Maximum Product Subset Array | C++ | long long maximumProductSubsetArray(vector<int> a, int n) { | [
"a",
"n"
] | def maximum_product_subset_array(a, n):
if (n == 1):
return a[0]
max_neg = (- 999999999999)
count_neg = 0
count_zero = 0
prod = 1
for i in range(n):
if (a[i] == 0):
count_zero += 1
continue
if (a[i] < 0):
count_neg += 1
max_... | int maximum_product_subset_array(vector<int> a, int n) {
if ( n == 1 ) return a [ 0 ];
int max_neg = INT_MIN;
int count_neg = 0, count_zero = 0;
int prod = 1;
for ( int i = 0;
i < n;
i ++ ) {
if ( a [ i ] == 0 ) {
count_zero ++;
continue;
}
if ( a [ i ] < 0 ) {
count_neg ++;
... | {
"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... |
314 | Maximum Profit By Buying And Selling A Share At Most K Times 1 | C++ | int maximumProfitByBuyingAndSellingAShareAtMostKTimes1(vector<int> price, int n, int k) { | [
"price",
"n",
"k"
] | def maximum_profit_by_buying_and_selling_a_share_at_most_k_times_1(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... | int maximum_profit_by_buying_and_selling_a_share_at_most_k_times_1(vector<int> price, int n, int k) {
int profit [ 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 = 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... |
315 | Maximum Profit By Buying And Selling A Share At Most Twice | C++ | int maximumProfitByBuyingAndSellingAShareAtMostTwice(vector<int> price, int n) { | [
"price",
"n"
] | def maximum_profit_by_buying_and_selling_a_share_at_most_twice(price, n):
profit = ([0] * n)
max_price = price[(n - 1)]
for i in range((n - 2), 0, (- 1)):
if (price[i] > max_price):
max_price = price[i]
profit[i] = max(profit[(i + 1)], (max_price - price[i]))
min_price = pric... | int maximum_profit_by_buying_and_selling_a_share_at_most_twice(vector<int> price, int n) {
int * profit = new int [ n ];
for ( int i = 0;
i < n;
i ++ ) profit [ i ] = 0;
int max_price = price [ n - 1 ];
for ( int i = n - 2;
i >= 0;
i -- ) {
if ( price [ i ] > max_price ) max_price = price [ i ];
... | {
"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... |
316 | Maximum Removal From Array When Removal Time Waiting Time | C++ | int maximumRemovalFromArrayWhenRemovalTimeWaitingTime(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximum_removal_from_array_when_removal_time_waiting_time(arr, n):
count = 0
cummulative_sum = 0
arr.sort()
for i in range(n):
if (arr[i] >= cummulative_sum):
count += 1
cummulative_sum += arr[i]
return count | int maximum_removal_from_array_when_removal_time_waiting_time(vector<int> arr, int n) {
int count = 0;
int cummulative_sum = 0;
sort(arr.begin(), arr.end());
for ( int i = 0;
i < n;
i ++ ) {
if ( arr [ i ] >= cummulative_sum ) {
count ++;
cummulative_sum += arr [ i ];
}
}
return 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... |
317 | Maximum Subarray Sum Array Created Repeated Concatenation | C++ | long long maximumSubarraySumArrayCreatedRepeatedConcatenation(vector<int> a, int n, int k) { | [
"a",
"n",
"k"
] | def maximum_subarray_sum_array_created_repeated_concatenation(a, n, k):
max_so_far = (- 2147483648)
max_ending_here = 0
for i in range((n * k)):
max_ending_here = (max_ending_here + a[(i % n)])
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending... | int maximum_subarray_sum_array_created_repeated_concatenation(vector<int> a, int n, int k) {
int max_so_far = INT_MIN, max_ending_here = 0;
for ( int i = 0;
i < n * k;
i ++ ) {
max_ending_here = max_ending_here + a [ i % n ];
if ( max_so_far < max_ending_here ) max_so_far = max_ending_here;
if ( max... | {
"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... |
318 | Maximum Subarray Sum Using Prefix Sum | C++ | int maximumSubarraySumUsingPrefixSum(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximum_subarray_sum_using_prefix_sum(arr, n):
min_prefix_sum = 0
res = (- math.inf)
prefix_sum = []
prefix_sum.append(arr[0])
for i in range(1, n):
prefix_sum.append((prefix_sum[(i - 1)] + arr[i]))
for i in range(n):
res = max(res, (prefix_sum[i] - min_prefix_sum))
m... | int maximum_subarray_sum_using_prefix_sum(vector<int> arr, int n) {
int min_prefix_sum = 0;
int res = numeric_limits < int > :: min ( );
int prefix_sum [ n ];
prefix_sum [ 0 ] = arr [ 0 ];
for ( int i = 1;
i < n;
i ++ ) prefix_sum [ i ] = prefix_sum [ i - 1 ] + arr [ i ];
for ( int i = 0;
i < n;
i +... | {
"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... |
319 | Maximum Subsequence Sum Such That No Three Are Consecutive | C++ | int maximumSubsequenceSumSuchThatNoThreeAreConsecutive(vector<int> arr, int n) { | [
"arr",
"n"
] | def maximum_subsequence_sum_such_that_no_three_are_consecutive(arr, n):
sum = [0 for k in range(n)]
if (n >= 1):
sum[0] = arr[0]
if (n >= 2):
sum[1] = (arr[0] + arr[1])
if (n > 2):
sum[2] = max(sum[1], max((arr[1] + arr[2]), (arr[0] + arr[2])))
for i in range(3, n):
s... | int maximum_subsequence_sum_such_that_no_three_are_consecutive(vector<int> arr, int n) {
int sum [ n ];
if ( n >= 1 ) sum [ 0 ] = arr [ 0 ];
if ( n >= 2 ) sum [ 1 ] = arr [ 0 ] + arr [ 1 ];
if ( n > 2 ) sum [ 2 ] = max ( sum [ 1 ], max ( arr [ 1 ] + arr [ 2 ], arr [ 0 ] + arr [ 2 ] ) );
for ( int i = 3;
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... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.