id stringlengths 9 106 | d_with_params stringlengths 426 57.5k |
|---|---|
CHECK_LARGE_NUMBER_DIVISIBLE_13_NOT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, false, false, false, true, true, false, false, false, false];
string [] param0 = ["vztuaitpcplnjy", "33855", "0011110101011", "mmq", "439340517954", "000000000", "uugaurrjbjegl", "640655... |
CHECK_WHETHER_ARITHMETIC_PROGRESSION_CAN_FORMED_GIVEN_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, true, true, true, true, false, false, false, false, false];
int [] [] param0 = [[1, 4, 16, 64], [0, 4, 8, 12], [-2, 0, 2, 4, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [46, 56, 66, 76, 86... |
MAXIMUM_NUMBER_SEGMENTS_LENGTHS_B_C | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, -1, 32, -1, -1, -1, 2, 7, -1, -1];
int [] param0 = [23, 62, 32, 82, 94, 44, 4, 53, 9, 23];
int [] param1 = [16, 76, 46, 48, 99, 21, 57, 23, 55, 15];
int [] param2 = [23, 81, 1, 72, 62... |
SMALLEST_OF_THREE_INTEGERS_WITHOUT_COMPARISON_OPERATORS_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [48, 11, 50, 21, 39, 22, 3, 62, 2, 1];
int [] param0 = [48, 11, 50, 21, 94, 22, 3, 67, 59, 50];
int [] param1 = [63, 55, 89, 71, 39, 44, 41, 62, 2, 11];
int [] param2 = [56, 84, 96, 74, 4... |
MINIMUM_SUM_TWO_NUMBERS_FORMED_DIGITS_ARRAY_2 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [372, -1977127, 1, 95, -1149, 122222222, 108, -49, 12, 625];
int [] [] param0 = [[4, 1, 2, 3, 3, 8], [-9, -5, -8, 4, -1, -6, -8, -9, -8, -1, -2, -8], [0, 1], [7, 1, 7, 8], [-7, -4, -4, -2, 8, 3],... |
COUNT_NEGATIVE_NUMBERS_IN_A_COLUMN_WISE_ROW_WISE_SORTED_MATRIX_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [309, 1, 454, 0, 60, 20, 185, 63, 191, 295];
int [] [] [] param0 = [[[-43, -43, -39, -38, -36, -26, -25, -22, -12, -12, -11, -4, -3, 2, 3, 4, 18, 19, 25, 26, 27, 31, 31, 33, 33, 36, 42, 44, 47], ... |
PROGRAM_BINARY_DECIMAL_CONVERSION_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 20, 154, 0, 130, 61, 0, 0, 1, 0];
string [] param0 = ["uemiagf", "753310137", "010011010", "kni", "04562016903312", "000111101", "bk", "9", "1", "xxt nxllk"];
int n_success = 0;
for... |
FIND_WHETHER_GIVEN_INTEGER_POWER_3_NOT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, true, true, true, false, false, false, false, false];
int [] param0 = [1, 3, 27, 9, -9, 11, 57, 21, 60, 44];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
PIZZA_CUT_PROBLEM_CIRCLE_DIVISION_LINES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1082, 2347, 11, 79, 1597, 106, 3322, 436, 352, 821];
int [] param0 = [46, 68, 4, 12, 56, 14, 81, 29, 26, 40];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (re... |
WILDCARD_CHARACTER_MATCHING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, false, false, true, false, true, true, true, false];
string [] param0 = ["g*ks", "ge?ks*", "g*k", "*pqrs", "abc*bcd", "abc*c?d", "*c*d", "*?c*d", "?*1", "a*"];
string [] param1 ... |
FIND_WHETHER_A_GIVEN_NUMBER_IS_A_POWER_OF_4_OR_NOT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0];
int [] param0 = [45, 16, 15, 91, 82, 18, 31, 6, 93, 35];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_filled(p... |
MINIMUM_COST_FOR_ACQUIRING_ALL_COINS_WITH_K_EXTRA_COINS_ALLOWED_WITH_EVERY_COIN | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [6, -98, 0, 1, -98, 0, 5, -160, 0, 23];
int [] [] param0 = [[2, 4, 5, 9, 10, 10, 11, 14, 15, 19, 21, 22, 29, 36, 36, 38, 39, 39, 39, 41, 41, 42, 45, 45, 48, 55, 56, 57, 64, 66, 66, 66, 66, 69, 74... |
POLICEMEN_CATCH_THIEVES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
char [] [] param0 = [['a', 'b', 'b', 'd', 'e', 'e', 'f', 'g', 'g', 'g', 'i', 'j', 'o', 'p', 'q', 'q', 'q', 'q', 'r', 'r', 's', 'u', 'x', 'y', 'y', 'c', 'd', 'h', '... |
COUNT_PALINDROMIC_SUBSEQUENCE_GIVEN_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 10, 2798, 20, 2, 270, 8, 2, 563, 3];
string [] param0 = ["r", "2956350", "11100111110101", "tztdliifad", "98", "1100100001", "okwgeatf", "19", "00010110100", "cyq"];
int n_success = 0;
... |
HOW_CAN_WE_SUM_THE_DIGITS_OF_A_GIVEN_NUMBER_IN_SINGLE_STATEMENT_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [5, 11, 13, 13, 7, 3, 16, 17, 13, 5];
int [] param0 = [50, 92, 49, 94, 7, 30, 88, 98, 94, 23];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fi... |
WRITE_ONE_LINE_C_FUNCTION_TO_FIND_WHETHER_A_NO_IS_POWER_OF_TWO | 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, 2, 8, 1024, 24, 7, 46, 61, 73, 66];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {... |
HOW_TO_TURN_OFF_A_PARTICULAR_BIT_IN_A_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [49, 59, 76, 27, 61, 67, 63, 85, 26, 16];
int [] param0 = [49, 59, 76, 27, 61, 67, 63, 85, 90, 24];
int [] param1 = [31, 28, 25, 22, 19, 16, 13, 10, 7, 4];
int n_success = 0;
for (i... |
CALCULATE_ANGLE_HOUR_HAND_MINUTE_HAND | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [-180831, -15630, -251193, -111919, -208740, -268510, -287700, -138167, -10289, -32987];
double [] param0 = [7322.337365895532, -0.5025472034247969, 8735.336068205026, -5478.862697905712, 8264.12... |
FIND_THE_NUMBER_OCCURRING_ODD_NUMBER_OF_TIMES_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [49, -96, 0, 79, -90, 1, 2, 86, 0, 11];
int [] [] param0 = [[49, 90], [-96, 94, 92, -24, 48, 54, -30, -86, 28, -18, 12, -64, -36, 68, 68, -78, -6, 30, -84, 20, 52, -36, 40, -62, 90, -48, 86, 98, ... |
COUNT_NUMBER_OF_WAYS_TO_FILL_A_N_X_4_GRID_USING_1_X_4_TILES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [188941273, 657, 685792227, 52054840, 59864, 1728, 95, 2385, 5453761, 3];
int [] param0 = [61, 22, 65, 57, 36, 25, 16, 26, 50, 5];
int n_success = 0;
for (int i = 0; i < param0.length; ... |
ELEMENTS_TO_BE_ADDED_SO_THAT_ALL_ELEMENTS_OF_A_RANGE_ARE_PRESENT_IN_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [62, 168, 0, 69, 146, 0, 54, 161, 0, 33];
int [] [] param0 = [[4, 4, 5, 7, 7, 9, 13, 15, 18, 19, 25, 27, 27, 29, 32, 36, 48, 51, 53, 53, 55, 65, 66, 67, 72, 74, 74, 76, 77, 79, 80, 81, 82, 83, 83... |
PERFECT_REVERSIBLE_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, true, false, true, true, true, false, false, false, true];
string [] param0 = ["ab", "303", "11110000", "aba", "404", "10101", "abab", "6366", "001", ""];
int n_success = 0;
fo... |
FIND_THREE_ELEMENT_FROM_DIFFERENT_THREE_ARRAYS_SUCH_THAT_THAT_A_B_C_K | 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, false, false];
int [] [] param0 = [[4, 9, 10, 19, 24, 25, 26, 30, 36, 43, 44, 49, 52, 62, 66, 69, 72, 77, 80, 80, 82, 84, 90, 93, 94, 98], [-... |
COUNT_NUMBERS_THAT_DONT_CONTAIN_3 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [67, 68, 2, 26, 44, 26, 26, 13, 58, 57];
int [] param0 = [85, 86, 3, 35, 59, 38, 33, 15, 75, 74];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f... |
UNIQUE_CELLS_BINARY_MATRIX | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 1, 1, 0, 0, 0, 0, 0, 0];
int [] [] [] param0 = [[[0, 1, 0, 0], [0, 0, 1, 0], [1, 0, 0, 1]], [[0, 1, 0, 0], [0, 0, 1, 1], [1, 0, 1, 1]], [[0, 1, 0, 0], [0, 0, 1, 0], [1, 1, 0, 1]], [[1, 1, 1, ... |
SUM_PAIRWISE_PRODUCTS_2 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1397887, 15675, 11449977, 1155, 420497, 2645897, 3327486, 2493271, 2972060, 15675];
int [] param0 = [57, 18, 97, 9, 42, 67, 71, 66, 69, 18];
int n_success = 0;
for (int i = 0; i < para... |
MAXIMUM_REMOVAL_FROM_ARRAY_WHEN_REMOVAL_TIME_WAITING_TIME | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [3, 5, 5, 3, 6, 11, 5, 6, 13, 5];
int [] [] param0 = [[7, 33, 34, 42, 42, 45, 73], [-98, -90, -80, -66, -64, -62, -48, -30, -20, -10, 4, 6, 12, 14, 32, 42, 44, 44, 52, 64, 86, 92, 94], [0, 0, 0, ... |
PROGRAM_PAGE_REPLACEMENT_ALGORITHMS_SET_2_FIFO | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [34, 30, 2, 13, 9, 2, 16, 25, 2, 15];
int [] [] param0 = [[4, 4, 6, 7, 8, 11, 13, 18, 26, 35, 36, 37, 45, 46, 46, 47, 48, 49, 51, 52, 53, 56, 61, 74, 75, 77, 80, 83, 85, 86, 87, 90, 93, 95, 97, 9... |
SUM_MATRIX_ELEMENT_ELEMENT_INTEGER_DIVISION_ROW_COLUMN_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [630, 4371, 28, 3321, 3240, 1128, 28, 861, 1770, 595];
int [] param0 = [35, 93, 7, 81, 80, 47, 7, 41, 59, 34];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (re... |
ROUND_THE_GIVEN_NUMBER_TO_NEAREST_MULTIPLE_OF_10 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [30, 80, 20, 40, 80, 90, 90, 20, 90, 0];
int [] param0 = [31, 78, 19, 36, 77, 94, 86, 16, 95, 2];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f... |
CHECK_IF_A_NUMBER_IS_POWER_OF_ANOTHER_NUMBER_1 | 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 = [57, 3, 10, 10, 6, 3, 3, 20, 96, 25];
int [] param1 = [1, 9, 101, 10000, 46656, 2048, 40, 79, 98, 5];
... |
FIND_NUMBER_TIMES_STRING_OCCURS_GIVEN_STRING_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 6, 0, 2, 0, 1, 6, 35, 0];
string [] param0 = ["fzokcdz lav", "2", "1000001110", "iaoybzgiwho", "211806", "1", "cvaqtg", "6265187228", "10111101101000", "vei"];
string [] param1 = ["fka... |
CHECK_INTEGER_OVERFLOW_MULTIPLICATION | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, true, true, false, false, false, false, false, false, false];
long [] param0 = [37, 10000000000, 10000000000, 999999999, 39, 92, 14, 19, 14, 88];
long [] param1 = [80, -10000000000, ... |
CHECK_WHETHER_TWO_STRINGS_ARE_ANAGRAM_OF_EACH_OTHER | 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];
char [] [] param0 = [['l', 'i', 's', 't', 'e', 'n'], ['t', 'r', 'i', 'a', 'n', 'g', 'l', 'e'], ['t', 'e', 's', 't'], ['n', 'i... |
FIND_MAXIMUM_AVERAGE_SUBARRAY_OF_K_LENGTH | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [9, -1, 1, 0, 15, 4, -1, 4, 2, -1];
int [] [] param0 = [[2, 4, 6, 19, 21, 23, 32, 34, 47, 51, 56, 57, 57, 65, 68, 68, 69, 70, 71, 73, 74, 74, 77, 77, 79, 82, 82, 86, 87, 87, 88, 89, 90, 91, 92], ... |
MAXIMUM_BINOMIAL_COEFFICIENT_TERM_VALUE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1352078, 10, 252, 352716, 24310, 924, 10400600, 126, 35, 2704156];
int [] param0 = [23, 5, 10, 21, 17, 12, 26, 9, 7, 24];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
FIND_EQUAL_POINT_STRING_BRACKETS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [4, 2, 0, 5, 3, 3, 3, 1, 7, 8];
string [] param0 = ["(())))(", "))", "((", "))(()(()()(", ")((()(()", "))(()", "()))", "()", "1100110", "dhfsnebd"];
int n_success = 0;
for (int i = 0; i... |
FUNCTION_COPY_STRING_ITERATIVE_RECURSIVE_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["v", "86028087054621937", "00000000000000000111111111111111111", "smdawnfhbehmzhcxlareddqvuwokunbkymlhlxhrditay", "00000111222334445555667777788889989999", "11000101100010011000011", "ggjklnqrrsu... |
FIND_INDEX_GIVEN_FIBONACCI_NUMBER_CONSTANT_TIME | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [5, 8, 6, 12, 11, 11, 11, 12, 11, 8];
int [] param0 = [5, 19, 7, 94, 58, 65, 69, 96, 80, 14];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fil... |
SUM_OF_ALL_ELEMENTS_UP_TO_NTH_ROW_IN_A_PASCALS_TRIANGLE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [3, 15, 7, 127, 255, 31, 63, 1023, 4095, 32767];
int [] param0 = [2, 4, 3, 7, 8, 5, 6, 10, 12, 15];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] =... |
COUNT_PAIRS_DIFFERENCE_EQUAL_K | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [3, 0, 0, 3, 0, 0, 2, 0, 0, 3];
int [] [] param0 = [[9, 14, 17, 19, 22, 23, 23, 27, 30, 31, 34, 37, 37, 39, 39, 42, 57, 61, 68, 73, 77, 79, 91, 96, 97], [-78, -42, 28, -88, 18, -52], [0, 0, 0, 0,... |
FIND_A_ROTATION_WITH_MAXIMUM_HAMMING_DISTANCE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [12, 0, 2, 0, 2, 8, 15, 14, 4, 2];
int [] [] param0 = [[1, 4, 18, 22, 28, 34, 35, 39, 44, 45, 67, 73, 75, 79, 81, 83, 89, 93, 96], [52, -28], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0... |
COUNT_NUMBER_WAYS_TILE_FLOOR_SIZE_N_X_M_USING_1_X_M_SIZE_TILES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [41, 131, 1, 1, 90, 1, 89625, 6, 11, 1578];
int [] param0 = [93, 17, 38, 33, 78, 40, 95, 12, 69, 78];
int [] param1 = [54, 4, 39, 64, 35, 61, 16, 8, 60, 21];
int n_success = 0;
for ... |
CALCULATE_VOLUME_DODECAHEDRON | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
double [] results = [1345766.2993890555, 2981083.5487053124, 81596.89069273109, 7663.118960624633, 4541961.260438062, 61304.95168499706, 1016520.3932458181, 5774704.218276865, 7663.118960624633, 4381671.801138677];
... |
DETECT_IF_TWO_INTEGERS_HAVE_OPPOSITE_SIGNS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, false, true, true, true, false, false, true, true, false];
int [] param0 = [59, -20, -100, 54, -16, -23, 93, 24, -8, 29];
int [] param1 = [-99, -21, 79, -49, 16, -68, 37, -61, 69, 10]... |
CHECK_TWO_GIVEN_CIRCLES_TOUCH_INTERSECT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [-1, 0, -1, 0, 0, 0, 0, 0, 0, -1];
int [] param0 = [11, 87, 51, 89, 64, 57, 65, 32, 73, 3];
int [] param1 = [36, 1, 1, 67, 10, 86, 90, 23, 61, 99];
int [] param2 = [62, 62, 47, 9, 79, 99,... |
MAXIMUM_CONSECUTIVE_REPEATING_CHARACTER_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
char [] results = ['e', '3', '1', 'a', '1', '1', 'w', '1', '1', 'a'];
string [] param0 = ["geeekk", "3786868", "110", "aaaabbcbbb", "11", "011101", "wohnyjylc", "3141711779", "10111101101", "aabbabababcc"];
... |
COUNT_NUMBER_BINARY_STRINGS_WITHOUT_CONSECUTIVE_1S | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [5, 13, 144, 1597, 17711, 196418, 2178309, 24157817, 267914296, 433494437, 1134903170];
int [] param0 = [3, 5, 10, 15, 20, 25, 30, 35, 40, 41, 43];
int n_success = 0;
for (int i = 0; i ... |
C_PROGRAM_FACTORIAL_NUMBER_2 | 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... |
TRIANGULAR_NUMBERS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, false, false, false, false, false, false, false, true, false];
int [] param0 = [97, 97, 32, 40, 18, 14, 90, 39, 1, 57];
int n_success = 0;
for (int i = 0; i < param0.length; i+... |
MAXIMUM_NUMBER_CHARACTERS_TWO_CHARACTER_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [-1, 2, -1, -1, -1, -1, -1, 10, 0, -1];
string [] param0 = ["ci", "76478", "1", "tr", "10", "01", "rmhzp", "5784080133917", "1100", "ok"];
int n_success = 0;
for (int i = 0; i < param0.... |
FIND_HARMONIC_MEAN_USING_ARITHMETIC_MEAN_GEOMETRIC_MEAN | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
double [] results = [65.91176470588235, 48.0, 20.43243243243243, 30.72340425531915, 45.555555555555564, 11.375, 40.949999999999996, 19.027027027027028, 88.36363636363636, 23.823529411764707];
int [] param0 = [54,... |
FIND_LAST_DIGIT_FACTORIAL_DIVIDES_FACTORIAL_B | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 1, 0, 0, 0, 1, 0, 1, 1, 1];
long [] param0 = [79, 61, 39, 39, 61, 86, 7, 86, 86, 11];
long [] param1 = [84, 29, 77, 65, 78, 73, 92, 50, 63, 2];
int n_success = 0;
for (int i = 0... |
FINDING_POWER_PRIME_NUMBER_P_N_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 0, 0, 0, 0, 13, 3, 0, 1, 2];
int [] param0 = [76, 77, 9, 59, 8, 97, 78, 41, 72, 71];
int [] param1 = [43, 91, 42, 67, 52, 8, 24, 88, 61, 28];
int n_success = 0;
for (int i = 0; ... |
CHECK_IF_X_CAN_GIVE_CHANGE_TO_EVERY_PERSON_IN_THE_QUEUE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 0, 1, 0, 1, 0, 0, 0, 0, 0];
int [] [] param0 = [[5, 5, 5, 10, 20], [5, 5, 5, 20, 10], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, ... |
GCD_ELEMENTS_GIVEN_RANGE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [57, 22, 17, 74, 1, 1, 1, 1, 1, 1];
int [] param0 = [57, 22, 17, 74, 93, 56, 5, 5, 9, 98];
int [] param1 = [57, 22, 17, 74, 22, 54, 33, 68, 75, 21];
int n_success = 0;
for (int i = ... |
CHECK_WHETHER_GIVEN_NUMBER_EVEN_ODD | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, true, false, true, false, true, true, true, false, false];
int [] param0 = [67, 90, 55, 90, 83, 32, 58, 38, 87, 87];
int n_success = 0;
for (int i = 0; i < param0.length; i++) ... |
MINIMUM_PERIMETER_N_BLOCKS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [28, 36, 30, 28, 38, 34, 24, 18, 34, 34];
int [] param0 = [45, 80, 54, 48, 83, 68, 32, 20, 68, 66];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] =... |
MAXIMUM_CONSECUTIVE_NUMBERS_PRESENT_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 1, 2, 2, 1, 2, 2, 1, 1, 3];
int [] [] param0 = [[3, 5, 9, 24, 28, 31, 49, 54, 67, 85, 86, 94, 97, 97], [-34, 16, -80, -10, 80, 2, 50, -74, -76, 36, -84, -24, 74, -54, -22, 46, 80, 58, -8, 70,... |
LONGEST_SUBARRAY_COUNT_1S_ONE_COUNT_0S | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 1, 1, 1, 3, 7, 1, 3, 3, 1];
int [] [] param0 = [[6, 10, 31, 35], [4, 88, -72, 28, -54, 32, -34], [0, 0, 0, 1, 1, 1, 1, 1, 1], [39, 22, 15, 10, 34, 87, 46, 83, 74, 77, 61, 90, 43, 67, 64, 72, ... |
PROGRAM_CALCULATE_VOLUME_ELLIPSOID | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
float [] results = [522232.74089280004, -283737.6598056, 379381.2427776, -112115.51806000002, 1639671.7048656002, -1938016.9772600005, 306019.63709100004, -238081.08602880003, 192599.16093600003, -1561484.5209600003]... |
CHECK_STRING_CAN_OBTAINED_ROTATING_ANOTHER_STRING_2_PLACES | 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];
string [] param0 = ["amazon", "onamaz", "amazon", "ab", "737009", "000110", "l", "4420318628", "11011111000000", " pvfhanc"];... |
MAXIMUM_TRIPLET_SUM_ARRAY_2 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [265, -100000026, 3, 218, 52, 3, -99999966, 286, 2, 292];
int [] [] param0 = [[4, 7, 12, 21, 22, 25, 27, 28, 28, 31, 32, 32, 41, 45, 47, 51, 53, 60, 61, 61, 63, 71, 74, 82, 83, 85, 88, 92, 96, 96... |
NUMBER_INDEXES_EQUAL_ELEMENTS_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, 4, 0, 0, 0];
int [] [] param0 = [[4, 13, 13, 16, 16, 19, 39, 41, 48, 52, 57, 62, 65, 67, 76, 84, 88, 91, 95, 96, 97, 98], [62, 76, 86, -8, 84, -6, 72, 84, 6, -50, -18, -94, 54,... |
COUNT_OF_OCCURRENCES_OF_A_101_PATTERN_IN_A_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 3, 3, 0, 0, 0, 0, 0, 0, 0];
string [] param0 = ["1001ab010abc01001", "1001010001", "010100010100", "dlcu", "7072430592", "011", "pnjpypyoza", "1037", "111", "hxk"];
int n_success = 0;
... |
NUMBER_NON_NEGATIVE_INTEGRAL_SOLUTIONS_B_C_N | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2016, 1035, 741, 3403, 120, 231, 3003, 2701, 4753, 1431];
int [] param0 = [62, 44, 37, 81, 14, 20, 76, 72, 96, 52];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
DYNAMIC_PROGRAMMING_SET_17_PALINDROME_PARTITIONING_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [10, 6, 0, 2, 6, 1, 8, 4, 2, 4];
string [] param0 = ["yygwgyrovdsh", "56109778", "101", "rxm", "187546405", "0110010", "wvodamgvi", "56719", "10100011001100", "wtpai"];
int n_success = 0;
... |
REMOVE_MINIMUM_NUMBER_ELEMENTS_NO_COMMON_ELEMENT_EXIST_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [3, 1, 9, 0, 1, 2, 1, 0, 24, 1];
int [] [] param0 = [[4, 7, 10, 12, 12, 24, 29, 38, 45, 51, 53, 54, 59, 68, 72, 73, 85, 86, 88, 92, 92, 95], [-6, 48, -70, 14, -86, 56, 80, -64, 64, -88, -14, 78, ... |
MINIMUM_NUMBER_PLATFORMS_REQUIRED_RAILWAYBUS_STATION | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 11, 6, 5, 1, 13, 1, 8, 26, 3];
int [] [] param0 = [[8, 24, 28, 64, 75, 86, 93, 95], [2, -30, -8, -78, 58, -42, -94, 84, -58, 14, 78, 34, 30, 6, -18, -92, 0, 94, -54, 58, 0, -86, 66, 86, 8, -2... |
SQUARE_ROOT_OF_A_PERFECT_SQUARE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
float [] results = [41.99589376968351, -3544.737136289062, 88.84373605423394, -3008.0331952533734, 78.45502015008492, -5799.751467314729, 90.74222584648552, -1829.5367705266551, 76.01465104349802, -7785.473710863676]... |
PROGRAM_CHECK_PLUS_PERFECT_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, false, false, false, false, false, false, false, false];
int [] param0 = [371, 9474, 85, 35, 54, 17, 97, 63, 12, 43];
int n_success = 0;
for (int i = 0; i < param0.length;... |
MIDDLE_OF_THREE_USING_MINIMUM_COMPARISONS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [56, 56, 51, 54, 70, 57, 80, 54, 70, 5];
int [] param0 = [56, 56, 36, 71, 3, 84, 30, 82, 90, 38];
int [] param1 = [5, 60, 56, 54, 70, 57, 80, 54, 70, 4];
int [] param2 = [82, 17, 51, 6, 8... |
FIBONACCI_MODULO_P | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [36, 30, 18, 8, 6, 24, 60, 100, 70, 20];
int [] param0 = [51, 40, 68, 7, 8, 32, 93, 75, 71, 15];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_... |
SUM_OF_ALL_ELEMENTS_UP_TO_NTH_ROW_IN_A_PASCALS_TRIANGLE_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [31, 7, 2047, 15, 255, 8191, 63, 7, 65535, 511];
int [] param0 = [5, 3, 11, 4, 8, 13, 6, 3, 16, 9];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] =... |
CHECK_WHETHER_GIVEN_DEGREES_VERTICES_REPRESENT_GRAPH_TREE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, false, true, true, false, false, false, false, false];
int [] [] param0 = [[2, 3, 1, 1, 1], [2, 2, 1, 1, 2], [2, 2, 1, 1, 1], [0, 0, 0, 3, 3, 4], [-10, 12, 2], [1, 1, 1, 1, 0, 0, 0,... |
MAXIMUM_SUM_PAIRS_SPECIFIC_DIFFERENCE_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1578, -338, 25, 0, 596, 24, 1866, 406, 20, 1153];
int [] [] param0 = [[2, 10, 11, 11, 12, 14, 15, 17, 27, 27, 28, 36, 36, 44, 47, 47, 54, 55, 62, 64, 68, 69, 70, 70, 75, 76, 78, 85, 85, 91, 95, ... |
FIND_THE_FIRST_MISSING_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [19, 19, 26, 20, 8, 24, 0, 32, 28, 0];
int [] [] param0 = [[3, 6, 7, 9, 11, 14, 18, 30, 30, 32, 32, 34, 37, 44, 45, 45, 48, 48, 48, 52, 58, 60, 63, 67, 69, 69, 81, 83, 87, 89, 97, 99], [88, -62, ... |
CHECK_ARRAY_REPRESENTS_INORDER_BINARY_SEARCH_TREE_NOT | 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 = [[2, 3, 4, 10, 11, 13, 17, 19, 23, 26, 28, 29, 30, 34, 35, 37, 38, 38, 43, 49, 49, 50, 52, 53, 55, 55, 57, 58... |
DISTRIBUTING_ITEMS_PERSON_CANNOT_TAKE_TWO_ITEMS_TYPE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, true, true, true, false, true, true, false, true];
int [] [] param0 = [[1, 1, 2, 3, 1], [2, 3, 3, 5, 3, 3], [0, 0, 1, 1, 1], [7, 60, 78, 91, 80, 75, 85, 21, 41, 63, 1, 84, 69, 13, 9... |
K_TH_ELEMENT_TWO_SORTED_ARRAYS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [31, 20, 0, 71, -22, 0, 30, 86, 1, 70];
int [] [] param0 = [[2, 2, 4, 4, 9, 10, 14, 16, 16, 19, 20, 21, 25, 26, 29, 36, 36, 37, 38, 44, 44, 49, 53, 54, 56, 61, 62, 64, 72, 72, 73, 77, 80, 84, 84,... |
DIVISIBILITY_BY_7 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, true, true, true, false, false, false, false, false];
int [] param0 = [0, -21, 7, 63, 84, 73, 81, -10, 47, 23];
int n_success = 0;
for (int i = 0; i < param0.length; i++) ... |
MAXIMUM_SUM_2_X_N_GRID_NO_TWO_ELEMENTS_ADJACENT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [34, 832, 0, 212, 58, 13, 47, 372, 3, 1000];
int [] [] [] param0 = [[[6, 10, 23, 28, 35, 55, 91], [11, 14, 15, 54, 55, 62, 81], [18, 26, 40, 43, 47, 89, 93], [3, 11, 19, 53, 65, 82, 92], [14, 32,... |
SMALLEST_SUM_CONTIGUOUS_SUBARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, -58, 0, 1, -316, 0, 3, -402, 0, 1];
int [] [] param0 = [[2, 9, 13, 14, 15, 18, 19, 19, 25, 26, 29, 29, 29, 30, 31, 36, 37, 37, 38, 39, 39, 40, 40, 42, 42, 46, 50, 53, 58, 60, 62, 64, 65, 67, ... |
BREAKING_NUMBER_FIRST_PART_INTEGRAL_DIVISION_SECOND_POWER_10 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 1, 0, 0, 2, 0, 0, 1, 2];
string [] param0 = ["zcoqhum", "2674377254", "11", "lbuglvrywapbpo", "26382426486138", "111010111010", "huinqjxndbfp", "5191", "1110101101", "2202200"];
int n... |
PROGRAM_TO_CHECK_IF_A_GIVEN_NUMBER_IS_LUCKY_ALL_DIGITS_ARE_DIFFERENT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, false, true, true, false, true, false, true, true, false];
int [] param0 = [474, 9445, 90, 30, 37453, 27, 2400, 98, 46, 722];
int n_success = 0;
for (int i = 0; i < param0.leng... |
MAXIMUM_POSSIBLE_DIFFERENCE_TWO_SUBSETS_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [198, 1100, 0, 217, 468, 1, 671, 710, 0, 703];
int [] [] param0 = [[5, 14, 15, 21, 0, 0, 42, 0, 0, 0, 0, 48, 0, 0, 53, 60, 62, 69, 69, 79, 82, 86, 96], [-54, 0, -22, 94, 58, 0, -12, 84, 0, 0, -34... |
FIND_MAXIMUM_HEIGHT_PYRAMID_FROM_THE_GIVEN_ARRAY_OF_OBJECTS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [7, 2, 3, 8, 1, 3, 9, 1, 2, 7];
int [] [] param0 = [[7, 8, 11, 11, 14, 19, 25, 27, 41, 42, 46, 52, 53, 54, 55, 58, 59, 62, 63, 66, 67, 69, 74, 75, 77, 81, 83, 84, 88, 88, 93, 93, 94], [-96, -92, ... |
FIND_FIRST_NATURAL_NUMBER_WHOSE_FACTORIAL_DIVISIBLE_X | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [4, 11, 5, 6, 4, 7, 3, 5, 4, 3];
int [] param0 = [12, 11, 10, 9, 8, 7, 6, 5, 4, 3];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_filled(param0... |
TILING_WITH_DOMINOES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 0, 41, 0, 3, 0, 11, 153, 571];
int [] param0 = [9, 13, 5, 6, 7, 2, 19, 4, 8, 10];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_filled(p... |
CHECK_STRING_FOLLOWS_ANBN_PATTERN_NOT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, true, false, false, false, false, false, false, false, false];
string [] param0 = ["ba", "aabb", "abab", "aaabb", "aabbb", "abaabbaa", "abaababb", "bbaa", "11001000", "zwxv te"];
in... |
QUERIES_COUNTS_ARRAY_ELEMENTS_VALUES_GIVEN_RANGE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 0, 0, 1, 0, 0, 0, 0, 0];
int [] [] param0 = [[9, 16, 19, 24, 36, 38, 42, 49, 51, 53, 53, 57, 57, 58, 71, 78, 78, 92, 92, 93], [28, -74, -18, 10, 26, 28, -96, -80, 82, 94, 22, 50, 72, -90, ... |
HIGHWAY_BILLBOARD_PROBLEM | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0];
int [] param0 = [16, 39, 5, 10, 14, 32, 2, 22, 15, 8];
int [] [] param1 = [[6, 15, 15, 18, 23, 29, 32, 36, 37, 39, 40, 41, 44, 49, 51, 52, 53, 57, 66, 68, 82, ... |
COUNT_DISTINCT_OCCURRENCES_AS_A_SUBSEQUENCE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [3, 2, 20, 0, 2, 0, 1, 4, 6, 1];
string [] param0 = ["banana", "49597223", "1000010000011", "btlzufk", "3474007", "0010", "dkhhotd", "9123259723", "11001000111110", "iy wjliz"];
string [] par... |
DIVISIBILITY_9_USING_BITWISE_OPERATORS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, false, true, false, false, false, false, true, false, false];
int [] param0 = [96, 85, 54, 14, 47, 11, 49, 99, 28, 82];
int n_success = 0;
for (int i = 0; i < param0.length; i+... |
NUMBER_OF_BINARY_TREES_FOR_GIVEN_PREORDER_SEQUENCE_LENGTH | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [429, 42, 9694845, 58786, 16796, 5, 4862, 1430, 742900, 132];
int [] param0 = [7, 5, 15, 11, 10, 3, 9, 8, 13, 6];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if ... |
SUM_SERIES_555555_N_TERMS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [61719994, 5, 6171995, 6169, 617199994, 617196, 5, 614, 60, 61716];
int [] param0 = [8, 1, 7, 4, 9, 6, 1, 3, 2, 5];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
i... |
PROGRAM_FIND_STRING_START_END_GEEKS | 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, false, false];
string [] param0 = ["geeksmanishgeeks", "shreyadhatwalia", "10000100", "abaa", "30645530", "0000011011001", "dkqed", "486941193... |
MINIMIZE_THE_SUM_OF_DIGITS_OF_A_AND_B_SUCH_THAT_A_B_N | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 12, 4, 9, 8, 13, 13, 5, 4, 9];
int [] param0 = [2, 39, 31, 45, 35, 94, 67, 50, 4, 63];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_filled... |
HOW_CAN_WE_SUM_THE_DIGITS_OF_A_GIVEN_NUMBER_IN_SINGLE_STATEMENT_2 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [10, 10, 9, 16, 4, 12, 14, 9, 13, 8];
int [] param0 = [73, 91, 27, 79, 31, 84, 68, 9, 85, 35];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fi... |
MAXIMUM_SUBSEQUENCE_SUM_SUCH_THAT_NO_THREE_ARE_CONSECUTIVE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [832, 308, 2, 419, -182, 7, 895, 450, 0, 895];
int [] [] param0 = [[5, 6, 8, 9, 10, 10, 16, 17, 17, 20, 21, 22, 23, 28, 29, 32, 36, 37, 40, 41, 42, 43, 47, 47, 48, 48, 49, 49, 52, 52, 53, 59, 61,... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.