id stringlengths 9 106 | d_with_params stringlengths 426 57.5k |
|---|---|
MINIMUM_XOR_VALUE_PAIR | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, -96, 0, 0, 0, 0, 0, -96, 0, 0];
int [] [] param0 = [[4, 5, 7, 10, 10, 11, 14, 19, 21, 24, 27, 27, 27, 28, 28, 28, 33, 34, 41, 42, 43, 48, 52, 53, 53, 59, 62, 64, 66, 71, 77, 78, 78, 79, 80, 8... |
MINIMUM_TIME_WRITE_CHARACTERS_USING_INSERT_DELETE_COPY_OPERATION | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [351, 382, 195, 76, 460, 147, 405, 392, 694, 244];
int [] param0 = [59, 66, 98, 63, 99, 45, 60, 11, 96, 54];
int [] param1 = [75, 68, 55, 4, 37, 28, 53, 96, 95, 6];
int [] param2 = [12, 3... |
CONVERTING_ONE_STRING_USING_APPEND_DELETE_LAST_OPERATIONS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, false, true, true, true, true, false, false, true, true];
string [] param0 = ["znhgro", "382880806774", "0", "lxhtrfctsq", "6399914758", "01100011100000", "wkgqlob", "46974006151", "1001... |
MAXIMUM_TRIPLET_SUM_ARRAY_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [284, 230, 3, 281, 244, 3, 285, 234, 3, 225];
int [] [] param0 = [[6, 8, 18, 18, 27, 33, 33, 38, 42, 43, 44, 47, 52, 58, 64, 65, 67, 68, 71, 75, 85, 89, 91, 94, 94, 95, 95], [-88, -84, -82, -58, ... |
COUNT_PAIRS_WHOSE_PRODUCTS_EXIST_IN_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 6, 946, 18, 15, 153, 0, 0, 496, 0];
int [] [] param0 = [[3, 7, 26, 40, 46, 89, 99], [98, 42, -24, -60, 74, 86, 6, 8, 72, -58, 38, -20, 6, -6, 8, 48, -34, 30, 60, 66, 38, -54, 8, -94, -8, 0, -... |
LONGEST_PALINDROME_SUBSEQUENCE_SPACE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 7, 5, 3, 1, 8, 1, 7, 1, 1];
string [] param0 = [" e", "0845591950", "00101011", "plsvlwracvfaot", "7246", "1010101100000", "obpkclsfp", "914757557818", "1", "pkvuwiq"];
int n_success = 0... |
MAXIMUM_XOR_VALUE_MATRIX | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [126, 126, 1, 126, 92, 1, 127, 122, 1, 125];
int [] [] [] param0 = [[[2, 2, 3, 9, 9, 10, 12, 13, 17, 19, 26, 28, 28, 30, 30, 32, 32, 39, 40, 41, 42, 52, 52, 54, 54, 55, 56, 59, 62, 63, 69, 71, 72... |
MAXIMUM_SUM_IARRI_AMONG_ROTATIONS_GIVEN_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [3035, 592, 392, 10714, 7026, 19, 5149, 4226, 46, 16847];
int [] [] param0 = [[11, 12, 16, 26, 29, 40, 54, 59, 65, 70, 71, 73, 78, 81, 87, 87, 88, 90, 95, 97], [-46, -32, 54, 96, -72, -58, -36, -... |
SUM_DIVISORS_1_N_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [4406, 1384, 1098, 660, 1987, 491, 5977, 2846, 5561, 1342];
int [] param0 = [73, 41, 36, 28, 49, 24, 85, 59, 82, 40];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
HEXAGONAL_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2850, 3828, 6670, 190, 1891, 5565, 17578, 8128, 10011, 6903];
int [] param0 = [38, 44, 58, 10, 31, 53, 94, 64, 71, 59];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
MINIMUM_ROTATIONS_REQUIRED_GET_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [14, 2, 12, 13, 2, 3, 5, 1, 1, 2];
string [] param0 = ["vdevdndqsopptj", "ababab", "100010101011", "tldovjhaymllu", "06", "101", "dygtu", "4", "00", "dt"];
int n_success = 0;
for (int i... |
REPLACE_CHARACTER_C1_C2_C2_C1_STRING_S | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["iztsmw j", "7288334", "010110000", "b gjx", "734", "1", "xcaukdha", "4370992544981", "10101", "znifgshawa"];
string [] param0 = ["iztsmw j", "7288334", "010110000", "b gjx", "734", "1", "xca... |
COUNT_PAIRS_TWO_SORTED_ARRAYS_WHOSE_SUM_EQUAL_GIVEN_VALUE_X | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 5, 0, 0, 0, 0, 0, 0, 0, 0];
int [] [] param0 = [[11, 13, 16, 23, 26, 28, 31, 34, 37, 39, 44, 48, 56, 59, 79, 91, 96, 98], [50, 14, -98, 14, 90, 36, 66, 44, 10, -98, -24, -36, -32, -50], [0, 0... |
PROGRAM_FOR_FACTORIAL_OF_A_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [362880, 120, 24, 479001600, 2, 5040, 3628800, 6, 2, 720];
int [] param0 = [9, 5, 4, 12, 2, 7, 10, 3, 2, 6];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (resu... |
CHECK_WHETHER_TRIANGLE_VALID_NOT_SIDES_GIVEN | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 0, 0, 1, 0, 1, 0, 0, 0];
int [] param0 = [29, 83, 48, 59, 56, 68, 63, 95, 2, 11];
int [] param1 = [19, 34, 14, 12, 39, 85, 36, 34, 90, 16];
int [] param2 = [52, 49, 65, 94, 22, 9, ... |
PRINT_MAXIMUM_SHORTEST_DISTANCE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1000000000, 1000000000, 1000000000, 1000000000, 1000000000, 1000000000, 1000000000, 4, 1000000000, 1000000000];
int [] [] param0 = [[2, 27, 66, 89, 96, 96], [84, -38, -56, -20, -98, -40, -16, 22... |
COUNT_SUBARRAYS_EQUAL_NUMBER_1S_0S | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 1, 3, 0, 0, 1, 0, 2, 0, 0];
int [] [] param0 = [[2, 12, 18, 19, 19, 20, 20, 21, 25, 29, 38, 54, 54, 71, 72, 72, 74, 75, 77, 78, 80, 80, 81, 84, 97, 97], [10, 70, 24, -38, 32, -68, 88, -28, -2... |
WAYS_REMOVE_ONE_ELEMENT_BINARY_STRING_XOR_BECOMES_ZERO | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [7, 1, 2, 9, 1, 5, 12, 1, 4, 9];
string [] param0 = ["kfctjnp", "05312505872", "100111", "tdeehkxrq", "50824233019", "10001110010", "t sezanm myq", "838415739", "01110100", "wyqiaey h"];
int... |
MAXIMUM_PRODUCT_OF_4_ADJACENT_ELEMENTS_IN_MATRIX | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [85791650, 32184672, 1, 37003392, 81397232, 1, 49595568, 26455296, 1, 56796795];
int [] [] [] param0 = [[[1, 2, 5, 6, 7, 11, 12, 14, 15, 16, 19, 19, 24, 25, 32, 34, 36, 36, 38, 38, 39, 43, 43, 45... |
LEXICOGRAPHICAL_CONCATENATION_SUBSTRINGS_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["ggogoiooiiqqgqgoqgoissqsqgsqgosqgoi", "04484854858485805585808888084848848584858848580858588580", "00000000000000010010010011001100110001100001100100111001110001110000111001001110011001110011000... |
FIND_SUM_MODULO_K_FIRST_N_NATURAL_NUMBER_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [820, 1081, 913, 0, 2146, 920, 1158, 1891, 1921, 1171];
int [] param0 = [40, 46, 97, 63, 92, 60, 67, 61, 74, 67];
int [] param1 = [90, 64, 20, 1, 52, 35, 40, 62, 61, 41];
int n_success =... |
COUNT_NATURAL_NUMBERS_WHOSE_PERMUTATION_GREATER_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [48, 48, 52, 7, 45, 28, 20, 31, 27, 18];
int [] param0 = [69, 72, 88, 7, 66, 34, 23, 37, 33, 21];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f... |
MAXIMUM_POINTS_INTERSECTION_N_CIRCLES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [870, 600, 4692, 1482, 182, 3540, 7832, 702, 812, 812];
int [] param0 = [30, 25, 69, 39, 14, 60, 89, 27, 29, 29];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if ... |
MAXIMUM_AREA_RECTANGLE_PICKING_FOUR_SIDES_ARRAY_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2397, 0, 1, 0, 0, 1, 0, 0, 0, 0];
int [] [] param0 = [[4, 6, 7, 8, 12, 13, 14, 15, 18, 18, 19, 19, 26, 26, 32, 32, 33, 34, 34, 36, 41, 43, 47, 47, 51, 51, 52, 53, 55, 56, 57, 60, 61, 71, 74, 75,... |
SEARCH_INSERT_AND_DELETE_IN_A_SORTED_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1];
int [] [] param0 = [[2, 10, 73, 91, 98], [30, 24, 24, -8, 64, 50, 46, -76, 26, 8, -92, -78, 40, -86, 96, 14, 60, 38, 6, -72, -6, -20, 26, -26, 0, 2], [0,... |
FIND_WHETHER_A_GIVEN_NUMBER_IS_A_POWER_OF_4_OR_NOT_2 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, true, false, false, true, false, false, false, false];
int [] param0 = [1, 4, 64, -64, 128, 1024, 97, 86, 14, 99];
int n_success = 0;
for (int i = 0; i < param0.length; i+... |
CHECK_REVERSING_SUB_ARRAY_MAKE_ARRAY_SORTED | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, false, true, true, true, false, true, false, true, false];
int [] [] param0 = [[5, 9, 9, 16, 17, 22, 32, 40, 45, 53, 57, 58, 66, 69, 76, 80, 91, 93, 94], [52, -76, -18, 86, 56], [0, 0, 1]... |
SUM_SERIES_12_32_52_2N_12 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [3654, 302621, 67525, 848046, 138415, 1254890, 457310, 18424, 585276, 18424];
int [] param0 = [14, 61, 37, 86, 47, 98, 70, 24, 76, 24];
int n_success = 0;
for (int i = 0; i < param0.len... |
BASIC_AND_EXTENDED_EUCLIDEAN_ALGORITHMS_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 3, 1, 4, 16, 1, 1, 1, 1, 1];
int [] param0 = [44, 33, 39, 52, 64, 45, 53, 86, 57, 11];
int [] param1 = [17, 81, 77, 96, 48, 32, 88, 19, 67, 86];
int [] param2 = [10, 67, 21, 23, 17, 8... |
FLOOR_IN_A_SORTED_ARRAY_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [-1, 28, -1, -1, -1, -1, -1, 31, 29, -1];
int [] [] param0 = [[5, 11, 20, 42, 42, 55, 58, 98, 99], [50, -90, -38, -46, -10, -22, -66, 72, -52, 38, 90, 34, -12, -44, -6, 0, -20, -38, 86, 26, 64, -... |
K_TH_MISSING_ELEMENT_INCREASING_SEQUENCE_NOT_PRESENT_GIVEN_SEQUENCE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [-1, -1, -1, 37, -1, -1, 87, -82, -1, -1];
int [] [] param0 = [[2, 9, 9, 13, 38, 41, 50, 59, 64, 64, 72, 78, 79, 80, 84, 92, 94, 98, 99], [-54, -80, -62, 98, -68, 42, 98, 80, -8, -6, 26, 0, -60, ... |
RECURSIVELY_BREAK_NUMBER_3_PARTS_GET_MAXIMUM_SUM | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [41, 87, 7, 87, 57, 19, 63, 17, 41, 5];
int [] param0 = [39, 79, 7, 76, 48, 18, 58, 17, 36, 5];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_f... |
SEARCHING_ARRAY_ADJACENT_DIFFER_K | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [6, -1, -1, -1, -1, -1, -1, -1, -1, 0];
int [] [] param0 = [[1, 5, 9, 11, 14, 18, 19, 21, 26, 32, 38, 38, 43, 47, 49, 52, 55, 61, 65, 67, 69, 73, 74, 79, 84, 90, 91, 91, 92, 93, 94, 99], [12, -86... |
FIND_SUM_EVEN_INDEX_BINOMIAL_COEFFICIENTS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [536870912, 67108864, 8388608, 1048576, 131072, 16384, 2048, 256, 32, 4];
int [] param0 = [30, 27, 24, 21, 18, 15, 12, 9, 6, 3];
int n_success = 0;
for (int i = 0; i < param0.length; i+... |
TAIL_RECURSION_FIBONACCI | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [18, 104, 327, 176, 8, 120, 14, 568, 1385, 4];
int [] param0 = [4, 6, 9, 7, 2, 8, 3, 10, 12, 1];
int [] param1 = [3, 8, 1, 9, 8, 6, 0, 7, 1, 3];
int [] param2 = [4, 8, 9, 8, 0, 2, 7, 6, 9... |
PROGRAM_TO_FIND_THE_AREA_OF_PENTAGON | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
float [] results = [6944120.6857642615, 3771147.371815937, 220240.9998483103, 111222537.30911414, 25130647.008061722, 80508515.3102342, 4532163.809416133, 162347573.54592204, 26389745.561382204, 770176.1075446572];
... |
FIND_VALUE_OF_Y_MOD_2_RAISED_TO_POWER_X | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [57, 80, 84, 35, 3, 42, 3, 99, 13, 44];
long [] param0 = [57, 80, 84, 35, 3, 42, 7, 99, 13, 44];
long [] param1 = [76, 46, 96, 16, 84, 79, 2, 83, 61, 8];
int n_success = 0;
for (in... |
PROGRAM_CIRCUMFERENCE_PARALLELOGRAM | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
float [] results = [2515.4971893573984, -22592.18785519679, 27237.242036312673, -26538.168540307313, 15509.335106518702, -16933.889441987998, 26208.62444090405, -18155.585669713404, 19258.60615615351, -26966.87935977... |
MODULUS_TWO_FLOAT_DOUBLE_NUMBERS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
double [] results = [3243.229719038493, 4362.665881044217, 2008.6661365619666, 911.5074141984414, 3569.942027998315, 56.49596323882673, 368.98245607783906, 2856.1752826258803, 108.4901262723597, 1722.873699288031];
... |
FIND_UNIT_DIGIT_X_RAISED_POWER_Y_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [7, 0, 6, 1, 8, 5, 1, 3, 1, 1];
int [] param0 = [37, 70, 26, 9, 82, 95, 43, 7, 19, 49];
int [] param1 = [17, 52, 23, 96, 71, 36, 40, 27, 56, 28];
int n_success = 0;
for (int i = 0; ... |
MAXIMUM_SUM_SUBSEQUENCE_LEAST_K_DISTANT_ELEMENTS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [98, 90, 0, 96, 26, 1, 72, 80, 1, 155];
int [] [] param0 = [[3, 5, 20, 21, 23, 26, 27, 31, 33, 38, 39, 41, 48, 48, 50, 51, 56, 57, 64, 68, 69, 70, 71, 74, 76, 86, 97], [32, 34, -40, 90, -82, -70,... |
FREQUENT_ELEMENT_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [51, 96, 0, 31, -52, 0, 9, -42, 0, 4];
int [] [] param0 = [[1, 1, 3, 11, 11, 11, 18, 20, 26, 26, 27, 30, 33, 39, 39, 42, 42, 48, 51, 51, 51, 51, 60, 66, 66, 68, 68, 69, 71, 72, 73, 76, 76, 77, 77... |
DYCK_PATH | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [742900, 208012, 58786, 16796, 429, 14, 1];
int [] param0 = [13, 12, 11, 10, 7, 4, 1];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_filled(par... |
FIND_PERIMETER_CYLINDER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [296, 286, 150, 234, 332, 170, 336, 212, 142, 204];
int [] param0 = [70, 97, 49, 56, 87, 64, 75, 90, 55, 73];
int [] param1 = [78, 46, 26, 61, 79, 21, 93, 16, 16, 29];
int n_success = 0;... |
FIND_EXPRESSION_DUPLICATE_PARENTHESIS_NOT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, true, false, false, false, false, false, false, false];
string [] param0 = ["((a+b)+((c+d)))", "(((a+(b)))+(c+d))", "(((a+(b))+c+d))", "((a+b)+(c+d))", "(8582007)", "((a+(b))+(c+d))... |
TOTAL_NUMBER_OF_NON_DECREASING_NUMBERS_WITH_N_DIGITS_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [2054455634, 167960, 2509710226100, 293052087900, 5005, 293052087900, 42757703560, 2054455634, 97082021465, 125595622175];
int [] param0 = [40, 11, 94, 73, 6, 73, 58, 40, 64, 66];
int n_suc... |
MINIMUM_CHARACTERS_ADDED_FRONT_MAKE_STRING_PALINDROME | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, false, true, false, false, false, true, false, false, false];
string [] param0 = ["aadaa", "2674377254", "11", "0011000 ", "26382426486138", "111010111010", "abccba", "5191", "1110101101"... |
PROGRAM_COUNT_OCCURRENCE_GIVEN_CHARACTER_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 3, 1, 1, 0, 0, 0, 0, 1, 0];
string [] param0 = ["mhjnkfd", "716662107", "01", "wphsxibnhakgro", "721106", "111", "tibfu", "0", "10", "lqq"];
char [] param1 = ['l', '6', '1', 'n', '8', '0'... |
MINIMUM_COST_SORT_MATRIX_NUMBERS_0_N2_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2436, 0, 14929, 18771, 5844, 41068, 147, 231, 41068, 19143];
int [] [] [] param0 = [[[4, 7, 10, 11, 14, 22, 27, 43, 45, 47, 48, 48, 49, 49, 51, 54, 56, 57, 59, 62, 63, 64, 66, 79, 82, 83, 87, 96... |
LONGEST_REPEATING_AND_NON_OVERLAPPING_SUBSTRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["f", "2", "001", "", "4", "0", "d", "1", "1", "i"];
string [] param0 = ["fbfhtje", "09285256323", "0011000101110", "ue jkvztt", "48387612426300", "010", "ddrruz", "1049162633793", "100011", "... |
DYNAMIC_PROGRAMMING_HIGH_EFFORT_VS_LOW_EFFORT_TASKS_PROBLEM | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [537, 452, 0, 1261, -56, 15, 784, 268, 5, 453];
int [] [] param0 = [[1, 3, 9, 10, 13, 14, 15, 15, 17, 22, 23, 28, 30, 31, 37, 42, 45, 62, 62, 68, 68, 68, 78, 79, 82, 84, 87, 90, 99], [-78, -12, 2... |
PROGRAM_FOR_FACTORIAL_OF_A_NUMBER_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [5040, 40320, 6, 362880, 2, 24, 1, 120, 720, 3628800];
int [] param0 = [7, 8, 3, 9, 2, 4, 1, 5, 6, 10];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i... |
FIND_PAIR_WITH_GREATEST_PRODUCT_IN_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [-1, 76, 1, -1, -1, 0, 60, -1, 1, 40];
int [] [] param0 = [[4, 78, 84], [-54, 64, 60, 14, 18, -68, -54, -58, 38, -72, -84, 46, 74, 76, 28, -2, 54, 24, 18, -74, -78, 14, -38, -70, 26, -54, -36, -9... |
CHECK_LINE_PASSES_ORIGIN | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, true, true, false, false, false, false, false, false];
int [] param0 = [1, 10, 0, 1, 82, 78, 13, 18, 42, 29];
int [] param1 = [28, 0, 1, 1, 86, 86, 46, 29, 35, 17];
int [] p... |
SQUARE_PYRAMIDAL_NUMBER_SUM_SQUARES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 2, 3, 7, 8, -1, 11, -1, -1, -1];
int [] param0 = [1, 5, 14, 140, 204, 3, 506, 42, 4, 87];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fil... |
FIND_SUM_EVEN_FACTORS_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 112, 0, 78, 0, 0, 0, 96, 144, 0];
int [] param0 = [71, 78, 39, 36, 49, 17, 53, 66, 92, 71];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_f... |
FIND_SUM_MODULO_K_FIRST_N_NATURAL_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [21, 666, 876, 0, 2211, 237, 3, 2701, 388, 465];
int [] param0 = [11, 36, 71, 74, 66, 38, 2, 73, 79, 30];
int [] param1 = [5, 69, 28, 1, 84, 14, 11, 87, 11, 55];
int n_success = 0;
... |
HORNERS_METHOD_POLYNOMIAL_EVALUATION | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [837, 537, 40, 1];
int [] [] param0 = [[3, 4, 5], [6, 7, 8, 9], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1], [1]];
int [] param1 = [3, 4, 11, 1];
int [] param2 = [16, 4, 3, 26];
int n_success ... |
FIRST_ELEMENT_OCCURRING_K_TIMES_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [4, -1, -1, 38, -8, 0, 49, -1, -1, -1];
int [] [] param0 = [[2, 3, 4, 4, 7, 18, 20, 23, 27, 30, 31, 31, 32, 35, 36, 43, 45, 46, 49, 50, 53, 55, 59, 60, 64, 64, 65, 68, 78, 80, 80, 85, 95], [-26, ... |
MINIMUM_LENGTH_SUBARRAY_SUM_GREATER_GIVEN_VALUE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 1, 9, 1, 18, 12, 1, 43, 26, 1];
int [] [] param0 = [[6, 11, 11, 14, 18, 19, 21, 22, 22, 23, 26, 27, 28, 28, 29, 30, 31, 34, 39, 42, 42, 44, 45, 49, 49, 53, 57, 61, 65, 66, 67, 70, 71, 73, 74,... |
SUM_MATRIX_ELEMENT_ABSOLUTE_DIFFERENCE_ROW_COLUMN_NUMBERS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [71980, 28380, 124392, 242970, 323400, 30360, 6552, 440, 91520, 46852];
int [] param0 = [60, 44, 72, 90, 99, 45, 27, 11, 65, 52];
int n_success = 0;
for (int i = 0; i < param0.length; i... |
PROGRAM_TO_FIND_REMAINDER_WITHOUT_USING_MODULO_OR_OPERATOR_2 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [5, 2, 4, 34, 18, 6, 79, 12, 26, 82];
int [] param0 = [70, 77, 77, 88, 96, 6, 79, 44, 26, 82];
int [] param1 = [13, 3, 73, 54, 39, 10, 95, 32, 86, 91];
int n_success = 0;
for (int i... |
LONGEST_COMMON_SUBSTRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 3, 29, 1, 1, 1, 3, 2, 7, 1];
char [] [] param0 = [['a', 'd', 'e', 'e', 'l', 'l', 't', 'r', 'x'], ['9', '3', '4', '8', '7', '6', '3', '8', '3', '3', '5', '3', '5', '4', '2', '5', '5', '3', '6'... |
MAXIMUM_SUBARRAY_SUM_ARRAY_CREATED_REPEATED_CONCATENATION | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [15540, 218, 522, 29070, 18, 300, 2570, 134, -2147483648, -2147483648];
int [] [] param0 = [[5, 6, 12, 20, 23, 28, 33, 37, 47, 51, 53, 56, 63, 65, 65, 68, 69, 76, 76, 78, 83], [68, 10, 52, -44, 3... |
ADD_1_TO_A_GIVEN_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [97, 67, 68, 14, 76, 79, 2, 84, 28, 66];
int [] param0 = [96, 66, 67, 13, 75, 78, 1, 83, 27, 65];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f... |
MINIMUM_LENGTH_SUBARRAY_SUM_GREATER_GIVEN_VALUE_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 1, 43, 1, 2, 13, 1, 1, 11, 1];
int [] [] param0 = [[2, 4, 5, 10, 14, 15, 16, 20, 23, 28, 31, 35, 36, 36, 43, 48, 49, 55, 57, 57, 58, 61, 64, 64, 68, 70, 70, 73, 74, 76, 76, 77, 81, 81, 82, 87... |
SEARCH_INSERT_AND_DELETE_IN_AN_UNSORTED_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 1, 0, 8, -1, -1, -1, -1, -1, -1];
int [] [] param0 = [[4, 8, 11, 23, 55, 57, 73, 74, 77, 79, 93], [-88, 12, -62, -66, -24, 18, 12, 22, 94, 30, -50, -42, -94, 18, 76, -6, -48, -68, 48, 36, -78... |
SQUARE_ROOT_OF_AN_INTEGER_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [6, 3, 6, 7, 1, 8, 8, 3, 8, 3];
int [] param0 = [40, 10, 46, 54, 1, 67, 64, 10, 75, 11];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_filled(p... |
COIN_GAME_WINNER_EVERY_PLAYER_THREE_CHOICES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, true, false, true, false, true, true, false, true, true];
int [] param0 = [6, 32, 99, 22, 26, 67, 69, 39, 7, 91];
int [] param1 = [27, 88, 18, 1, 78, 51, 57, 8, 82, 56];
int [] p... |
FIND_WHETHER_A_GIVEN_NUMBER_IS_A_POWER_OF_4_OR_NOT_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 1, 1, 0, 0, 1, 0, 0, 0, 0];
int [] param0 = [1, 4, 64, -64, 128, 1024, 45, 33, 66, 74];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fille... |
C_PROGRAM_FACTORIAL_NUMBER_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600];
int [] param0 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
int n_success = 0;
for (int i = 0; i < param0.length... |
CALCULATE_MAXIMUM_VALUE_USING_SIGN_TWO_NUMBERS_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2176, 368, 1, 25621500, 6272, 4, -303, 5670, 0, 66];
string [] param0 = ["pr", "9518", "1", "nnmci", "3170487", "0100101010", "z roncuqwb", "00419297", "00", "r"];
int n_success = 0;
f... |
FIND_INDEX_OF_AN_EXTRA_ELEMENT_PRESENT_IN_ONE_SORTED_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 0, 0, 0, 2, 0, 0, 24, 0];
int [] [] param0 = [[1, 6, 7, 10, 11, 12, 12, 16, 17, 29, 32, 33, 35, 35, 45, 49, 52, 56, 57, 58, 61, 62, 63, 64, 68, 71, 71, 77, 79, 79, 81, 82, 82, 83, 83, 89, ... |
FIND_POSITION_GIVEN_NUMBER_AMONG_NUMBERS_MADE_4_7 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 5, 7, 1, 5, 2, 8, 0, 0, 0];
string [] param0 = ["7", "305745689", "444", "4", "2074", "27", "447", "255", "10000111111011", "fakcsdrtnz"];
int n_success = 0;
for (int i = 0; i < par... |
MINIMUM_ROTATIONS_UNLOCK_CIRCULAR_LOCK | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [8, 8, 8, 4, 6, 8, 7, 8, 1, 7];
int [] param0 = [71, 90, 28, 41, 32, 39, 33, 89, 50, 92];
int [] param1 = [46, 65, 84, 23, 58, 82, 58, 32, 51, 77];
int n_success = 0;
for (int i = 0... |
SUM_NODES_K_TH_LEVEL_TREE_REPRESENTED_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [14, 9, 12, 16, 0, 0, 9, 0, 0, 0];
string [] param0 = ["(0(5(6()())(4()(9()())))(7(1()())(3()())))", "(8(3(2()())(6(5()())()))(5(10()())(7(13()())())))", "(0(5(6()())(4()(9()())))(7(1()())(3()())... |
COUNT_STRINGS_ADJACENT_CHARACTERS_DIFFERENCE_ONE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [50, 98, 744, 2896, 22356, 87492, 1344762, 20736556, 81501768, 320481188];
int [] param0 = [2, 3, 6, 8, 11, 13, 17, 21, 23, 25];
int n_success = 0;
for (int i = 0; i < param0.length; i... |
ANALYSIS_OF_ALGORITHMS_SET_2_ASYMPTOTIC_ANALYSIS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, -1, 0, 2, -1, -1, 1, -1, -1, -1];
int [] [] param0 = [[4, 5, 5, 11, 13, 14, 15, 19, 22, 22, 23, 26, 29, 29, 36, 44, 48, 49, 65, 65, 67, 68, 70, 76, 79, 79, 81, 85, 88, 91, 91, 92, 92, 97], [-... |
COMPUTE_NCR_P_SET_1_INTRODUCTION_AND_DYNAMIC_PROGRAMMING_SOLUTION | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [50, 80, 0, 0, 0, 2, 0, 0, 0, 12];
int [] param0 = [82, 45, 44, 88, 90, 98, 80, 60, 52, 71];
int [] param1 = [5, 24, 68, 24, 75, 55, 54, 75, 73, 26];
int [] param2 = [94, 95, 61, 43, 57, ... |
COUNT_SET_BITS_IN_AN_INTEGER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [4, 4, 3, 3, 2, 3, 4, 3, 1, 3];
int [] param0 = [58, 92, 73, 52, 24, 14, 58, 11, 8, 52];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_filled(p... |
MAXIMUM_TRIPLET_SUM_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [176, 276, 3, 290, 158, 3, 242, 288, 2, 276];
int [] [] param0 = [[6, 10, 14, 19, 24, 29, 42, 43, 44, 47, 47, 55, 57, 59, 60, 61, 76, 76, 77, 81, 84, 92, 92, 93, 95, 97], [-98, 72, 52, -62, 74, -... |
CHECK_REVERSING_SUB_ARRAY_MAKE_ARRAY_SORTED_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, false, true, false, true, true, true, false, true, false];
int [] [] param0 = [[1, 2, 5, 4, 3], [1, 2, 4, 5, 3], [1, 1, 0, 0], [5, 99, 40, 33, 61, 4, 64, 92, 28, 27, 21, 35, 40, 79, 10, ... |
COUNT_CHARACTERS_POSITION_ENGLISH_ALPHABETS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 3, 1, 3, 2, 0, 1, 3, 0, 0];
string [] param0 = ["llkhfezgcb", "abced", "geeksforgeeks", "alphabetical", "abababab", "bcdefgxyz", "cbzaqx l", " bcd", "11", "mqqky"];
int n_success = 0;
... |
FIND_MINIMUM_ELEMENT_IN_A_SORTED_AND_ROTATED_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [68, 88, 0, 26, 46, 1, 81, 4, 1, 3];
int [] [] param0 = [[16, 22, 50, 64, 68, 79, 84, 88, 89], [88, -38, 46, 24, -52, -12, -90, 28, 18, 14, -72, 58, -98, 28, -84, 44, -42, -32, -22, -22, -82, -30... |
COUNT_FACTORIAL_NUMBERS_IN_A_GIVEN_RANGE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 0, 0, 0, 0, 0, 2, 0, 0];
int [] param0 = [57, 57, 31, 62, 49, 82, 31, 5, 76, 55];
int [] param1 = [79, 21, 37, 87, 98, 76, 45, 52, 43, 6];
int n_success = 0;
for (int i = 0; ... |
MINIMUM_COST_MAKE_ARRAY_SIZE_1_REMOVING_LARGER_PAIRS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [38, -6, 0, 185, -2640, 0, 48, -2112, 0, 66];
int [] [] param0 = [[1, 2, 3, 4, 7, 8, 10, 10, 16, 20, 22, 22, 23, 23, 23, 27, 29, 32, 35, 39, 41, 46, 51, 53, 54, 59, 59, 60, 61, 69, 70, 70, 79, 79... |
PRINT_WORDS_STRING_REVERSE_ORDER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["yz dm m", "71 57 48 65", "010 01", "vhbyi mt", "1 9 44 19", "0", " vui z", "055 9 36643 591 7", "01", "ygaijpy ti"];
string [] param0 = ["m dm yz", "65 48 57 71", "01 010", "mt vhbyi", "19 ... |
MAXIMUM_WEIGHT_PATH_ENDING_ELEMENT_LAST_ROW_MATRIX | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1387, 452, 0, 260, 48, 21, 2087, 328, 1, 364];
int [] [] [] param0 = [[[1, 3, 17, 22, 24, 29, 36, 38, 41, 42, 44, 44, 47, 48, 49, 51, 52, 54, 64, 69, 70, 77, 79, 82, 86, 86, 87, 88, 97, 99], [5,... |
SPACE_OPTIMIZED_SOLUTION_LCS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 2, 1, 0, 3, 8, 0, 2, 2, 2];
string [] param0 = ["ynpjsv", "736519", "11010000100010", "v ", "8311172", "100011101011", "u", "3943042", "101", "mpbff osizevam"];
string [] param1 = ["qtukj... |
NUMBER_DAYS_TANK_WILL_BECOME_EMPTY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [40, 64, 11, 23, 12, 1, 10, 14, 13, 36];
int [] param0 = [91, 99, 11, 23, 12, 1, 18, 14, 13, 36];
int [] param1 = [29, 55, 56, 56, 97, 64, 5, 37, 55, 99];
int n_success = 0;
for (in... |
NUMBER_SUBSTRINGS_DIVISIBLE_4_STRING_INTEGERS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 16, 10, 11, 1, 1, 6, 11, 0, 21];
string [] param0 = ["qaq", "9400761825850", "0011001111", "laswqrlrq", "5662", "110", " toykf", "6536991235305", "11111", "uzftt idhcyict"];
int n_succes... |
FIND_MAXIMUM_AVERAGE_SUBARRAY_OF_K_LENGTH_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 0, 1, 0, 1, 3, 2, 0, 14, 15];
int [] [] param0 = [[2, 5, 11, 37, 41, 49, 49, 63, 98], [84, -72, 12, 0, 86, -32, -18, 48, 60, 42, 8, -6, -10, -6, -52, -84, -98, 76, -10, -14, -94, -48, 94, -10... |
HOW_TO_AVOID_OVERFLOW_IN_MODULAR_MULTIPLICATION | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [25, 3, 1, 35, 6, 5, 20, 4, 9, 45];
long [] param0 = [99, 11, 51, 49, 9, 90, 19, 17, 54, 5];
long [] param1 = [75, 4, 37, 51, 34, 85, 96, 96, 3, 69];
long [] param2 = [40, 41, 23, 88, 30... |
BELL_NUMBERS_NUMBER_OF_WAYS_TO_PARTITION_A_SET | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975, 678570, 4213597, 27644437, 190899322, 1382958545];
int [] param0 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
int n_success = 0;
... |
MAXIMIZE_SUM_ARRII | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [58965, 28832, 126, 5898, 3418, 155, 78220, 30682, 5, 9269];
int [] [] param0 = [[2, 3, 4, 6, 7, 8, 9, 11, 19, 23, 24, 30, 31, 31, 32, 41, 43, 43, 46, 47, 50, 50, 51, 53, 57, 63, 63, 69, 73, 74, ... |
REMAINDER_7_LARGE_NUMBERS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [6, 3, 6, 5, 1, 1, 0, 3, 3, 3];
string [] param0 = ["k", "850076", "00111", "x", "1", "10010001100", " pgpelz", "53212456821275", "101", "v"];
int n_success = 0;
for (int i = 0; i < par... |
FIND_DIFFERENCE_BETWEEN_SUMS_OF_TWO_DIAGONALS_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [37, 362, 2, 95, 50, 1, 11, 362, 0, 59];
int [] [] [] param0 = [[[1, 2, 4, 8, 12, 15, 17, 17, 19, 19, 21, 26, 27, 28, 32, 33, 40, 41, 41, 46, 46, 47, 48, 56, 59, 62, 68, 68, 69, 76, 80, 81, 82, 8... |
BREAK_NUMBER_THREE_PARTS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [1431, 1176, 2926, 703, 2415, 153, 5050, 780, 3655, 1081];
long [] param0 = [52, 47, 75, 36, 68, 16, 99, 38, 84, 45];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
PAIR_WITH_GIVEN_PRODUCT_SET_1_FIND_IF_ANY_PAIR_EXISTS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, false, true, false, false, false, false, false, false];
int [] [] param0 = [[10, 20, 9, 40], [1, -10, 20, 9, -40], [0, 0, 0, 0, 0, 1, 1, 1, 1], [4, 10, 20, 9, -40], [-90, -86, -76, ... |
PROGRAM_CHECK_INPUT_INTEGER_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, true, true, false, true, true, false, true, true, false];
string [] param0 = ["mgtoyho nt", "033675175", "011001", "xllccg", "8223900094410", "000", "aupp", "90202721499", "110000100011"... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.