id stringlengths 9 106 | d_with_params stringlengths 426 57.5k |
|---|---|
MAXIMUM_EQULIBRIUM_SUM_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [7, 6, 5, 4, 0, 9, 4, 4];
int [] [] param0 = [[-2, 5, 3, 1, 2, 6, -4, 2], [4, 2, 8, -1, 2, -4, -1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 0, 3, 0, 4], [1, 0, ... |
PROGRAM_DECIMAL_BINARY_CONVERSION_2 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [10010, 1011100, 1010111, 110010, 111000, 1011000, 11, 10000, 101101, 111010];
int [] param0 = [18, 92, 87, 50, 56, 88, 3, 16, 45, 58];
int n_success = 0;
for (int i = 0; i < param0.len... |
SCHEDULE_JOBS_SERVER_GETS_EQUAL_LOAD | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [-1, -1, -1, -1, -1, -1, 81, -1, -1, -1];
int [] [] param0 = [[4, 9, 16, 18, 20, 23, 24, 25, 25, 26, 29, 30, 35, 40, 41, 43, 44, 46, 53, 53, 56, 56, 58, 60, 62, 70, 80, 80, 80, 82, 86, 90, 92, 92... |
FIND_LARGEST_D_IN_ARRAY_SUCH_THAT_A_B_C_D | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [98, 92, 1, 67, 90, 1, 97, 96, 1, 99];
int [] [] param0 = [[8, 12, 14, 15, 16, 20, 27, 28, 29, 30, 35, 41, 46, 51, 53, 55, 55, 58, 63, 64, 72, 73, 75, 75, 75, 82, 82, 86, 89, 91, 92, 94, 95, 95, ... |
MAXIMIZE_SUM_CONSECUTIVE_DIFFERENCES_CIRCULAR_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1708, 3788, 6, 306, 3172, 44, 2146, 2704, 40, 688];
int [] [] param0 = [[8, 9, 12, 13, 17, 21, 24, 29, 37, 37, 39, 40, 41, 45, 49, 50, 53, 54, 56, 59, 60, 60, 70, 71, 72, 74, 77, 77, 78, 85, 89,... |
DYNAMIC_PROGRAMMING_SET_14_MAXIMUM_SUM_INCREASING_SUBSEQUENCE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [301, 102, 1, 396, 582, 1, 0, 254, 0, 550];
int [] [] param0 = [[4, 5, 7, 12, 23, 31, 31, 45, 47, 60, 67, 70, 84, 85, 91, 96], [-88, -38, -50, -14, 36, -32, 0, -8, -12, -62, -46, 66, -46, -26, 6,... |
FIND_INDEX_0_REPLACED_1_GET_LONGEST_CONTINUOUS_SEQUENCE_1S_BINARY_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [-1, 3, 28, -1, -1, 2, -1, -1, 8, -1];
int [] [] param0 = [[2, 8, 9, 13, 13, 19, 19, 21, 21, 24, 28, 28, 29, 29, 29, 32, 34, 38, 39, 43, 45, 46, 57, 59, 62, 63, 67, 67, 68, 69, 70, 70, 71, 72, 74... |
MAXIMIZE_VOLUME_CUBOID_GIVEN_SUM_SIDES_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [18, 32768, 32768, 32768, 64, 31744, 13824, 19683, 2744, 80];
int [] param0 = [8, 96, 96, 96, 12, 95, 72, 81, 42, 13];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
C_PROGRAM_CONCATENATE_STRING_GIVEN_NUMBER_TIMES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["lpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailpwsailp... |
MAXIMUM_LENGTH_PREFIX_ONE_STRING_OCCURS_SUBSEQUENCE_ANOTHER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 1, 1, 0, 2, 2, 0, 0, 0, 0];
string [] param0 = ["nobyiojeqz", "84574", "1010001010010", "djztafuudk", "550", "1110", "gywyxwh", "67318370914755", "11011000000101", "g"];
string [] param1 ... |
NUMBER_TRIANGLES_N_MOVES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [53, 17, 485, 39365, 13121, 4373, 1062881, 118097, 354293, 1457];
int [] param0 = [3, 2, 5, 9, 8, 7, 12, 10, 11, 6];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
MARKOV_MATRIX | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, false, false, false, true, true, false, false, false, false];
double [] [] [] param0 = [[[0.0, 0.0, 1.0], [0.5, 0.0, 0.5], [1.0, 0.0, 0.0]], [[0.0, 0.0, 1.0], [0.5, 0.0, 0.51], [1.0, 0.0,... |
LONGEST_COMMON_INCREASING_SUBSEQUENCE_LCS_LIS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 1, 2, 0, 0, 2, 4, 1, 2, 0];
int [] [] param0 = [[1, 7, 9, 35, 43, 51, 51, 66, 88], [-52, 52, -92, -46, -94, 30, -36, 18, -98, 22, -36, 96, -88, -50, 50], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... |
TAIL_RECURSION | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [5040, 2, 24, 720, 40320, 6, 362880, 3628800, 39916800, 1];
int [] param0 = [7, 2, 4, 6, 8, 3, 9, 10, 11, 1];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (res... |
SWAP_BITS_IN_A_GIVEN_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [5, 1, 5, 5, 129, 65, 192, 65, 3, 6];
int [] param0 = [5, 1, 5, 5, 9, 5, 6, 5, 3, 6];
int [] param1 = [8, 2, 5, 5, 1, 6, 6, 1, 3, 6];
int [] param2 = [7, 5, 4, 9, 5, 2, 1, 5, 9, 6];
i... |
SQUARE_ROOT_OF_AN_INTEGER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [9, 3, 3, 9, 8, 7, 7, 4, 9, 8];
int [] param0 = [89, 11, 14, 92, 76, 63, 51, 16, 83, 66];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_filled(... |
FIND_MINIMUM_DIFFERENCE_PAIR_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 0, 0, 0, 0, 0, 15, 2, 0, 2147483647];
int [] [] param0 = [[3, 25, 44, 46, 54, 60, 81], [82, 68, -98, -66, -36, -42, 98, -38, 58, -6, -28, 70, -24, 18, 16, 10, 92, 44, 28, -96, -72, 24, 28, -8... |
PYTHAGOREAN_QUADRUPLE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, false, true, false, false, false, false, false, false, false];
int [] param0 = [1, 3, 0, -1, 82, 14, 6, 13, 96, 70];
int [] param1 = [1, 2, 0, -1, 79, 57, 96, 7, 65, 33];
int [] ... |
MINIMUM_DIFFERENCE_BETWEEN_GROUPS_OF_SIZE_TWO | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [10, 10, 1, 13, 38, 0, 9, 0, 1, 16];
long [] [] param0 = [[11, 12, 14, 15, 20, 21, 28, 28, 30, 33, 39, 39, 42, 43, 44, 45, 48, 53, 53, 58, 59, 67, 68, 70, 70, 72, 74, 76, 76, 81, 87, 91], [-94, ... |
MAXIMUM_NUMBER_OF_SQUARES_THAT_CAN_BE_FIT_IN_A_RIGHT_ANGLE_ISOSCELES_TRIANGLE | 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, 153, 0];
int [] param0 = [40, 38, 47, 52, 21, 50, 8, 56, 93, 21];
int [] param1 = [74, 35, 71, 29, 9, 33, 82, 80, 5, 90];
int n_success = 0;
for (int i = 0;... |
CHECK_ARRAY_CONTAINS_CONTIGUOUS_INTEGERS_DUPLICATES_ALLOWED | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, false, true, false, false, true, false, false, true, false];
int [] [] param0 = [[2, 4, 19, 25, 65, 72, 75, 83, 90, 92], [46, 2, 28, -44, 74, -36, -8, 30, -96, 60, 52, -58, 16, -38, 78, ... |
MAXIMUM_LENGTH_SUBSEQUENCE_DIFFERENCE_ADJACENT_ELEMENTS_EITHER_0_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 2, 29, 2, 1, 3, 3, 1, 38, 1];
int [] [] param0 = [[4, 5, 9, 31, 31, 37, 41, 55, 56, 61, 79, 81, 89, 93], [-76, 96, -68, -16, 22, -24, -24, 6, 98, -82, 54, -80, 46, 0, 0, -50], [0, 0, 0, 0, 0,... |
FIND_SMALLEST_VALUE_REPRESENTED_SUM_SUBSET_GIVEN_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, -95, 4, 1, -93, 2, 1, 1, 12, 1];
int [] [] param0 = [[16, 23, 24, 41, 48, 58, 72, 75], [-14, -82, 12, -14, -38, 12, 40, 12, -74, 42, -36, 64], [0, 0, 1, 1, 1, 1], [17, 89, 44], [-94, -92, -84... |
FIND_REPEATED_CHARACTER_PRESENT_FIRST_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [-1, 0, 0, 0, 0, 0, -1, 0, 0, 1];
string [] param0 = ["orxmflacqfbv", "39977638567848", "011110011011", "fyjfny", "222280492", "11", "ujntbg", "6866190138212", "0000", "fwz pweqgvlrz"];
int ... |
FIND_THE_NUMBER_OCCURRING_ODD_NUMBER_OF_TIMES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, -56, 0, 36, -84, 1, 11, 52, 0, 4];
int [] [] param0 = [[1, 5, 5, 8, 14, 15, 17, 17, 18, 23, 23, 25, 26, 35, 36, 39, 51, 53, 56, 56, 60, 62, 64, 64, 65, 66, 67, 68, 71, 75, 80, 82, 83, 88, 89,... |
COUNT_SUM_OF_DIGITS_IN_NUMBERS_FROM_1_TO_N | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [165, 865, 540, 667, 525, 168, 667, 177, 609, 240];
int [] param0 = [29, 97, 71, 82, 69, 30, 82, 32, 77, 39];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (res... |
CHECK_POSSIBLE_TRANSFORM_ONE_STRING_ANOTHER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, false, false, false, true, false, false, false, true, false];
string [] param0 = ["dabcd", "417514", "010000", "zckyguimrdyn", "argaju", "1110101101", "ysocosaygi", "204", "10011100000010... |
COUNT_SET_BITS_IN_AN_INTEGER_2 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 5, 2, 4, 2, 1, 2, 3, 2, 4];
int [] param0 = [32, 94, 33, 99, 17, 64, 80, 42, 12, 86];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_filled(... |
PRIMALITY_TEST_SET_5USING_LUCAS_LEHMER_SERIES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [false, true, true, false, true, false, false, false, false, false];
int [] param0 = [11, 7, 5, 4, 3, 14, 9, 2, 8, 12];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
CIRCLE_LATTICE_POINTS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [12, 4, 12, 4, 4, 4, 4, 4, 4, 20];
int [] param0 = [34, 56, 90, 47, 36, 63, 21, 76, 18, 75];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fill... |
N_TH_NUMBER_WHOSE_SUM_OF_DIGITS_IS_TEN | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [406, 136, 613, 1054, 1126, 109, 1360, 433, 1054, 46];
int [] param0 = [37, 13, 51, 69, 76, 10, 97, 40, 69, 4];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (r... |
REMOVE_BRACKETS_ALGEBRAIC_STRING_CONTAINING_OPERATORS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["ggbsmvmzcmovd", "384292670", "10000100", "fdhme", "09198832", "0011111011", "snxwrs", "071", "01101", "xwmqxgba"];
string [] param0 = ["ggbsmvmzcmovd", "384292670", "10000100", "fdhme", "091... |
DICE_THROW_PROBLEM | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [50116, 77635844, 0, 0, 0, 0, 0, 1131, 0, 0];
int [] param0 = [94, 7, 20, 90, 50, 32, 46, 43, 43, 6];
int [] param1 = [4, 12, 44, 94, 58, 90, 25, 3, 82, 83];
int [] param2 = [69, 33, 24,... |
PROGRAM_BINARY_DECIMAL_CONVERSION | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [14, 23, 9, 25, 8, 8, 9, 17, 17, 22];
int [] param0 = [70, 95, 41, 97, 8, 16, 41, 57, 81, 78];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fi... |
MAXIMUM_SUM_IARRI_AMONG_ROTATIONS_GIVEN_ARRAY_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2249, 9152, 35, 34887, 586, 58, 11145, 14776, 297, 1359];
int [] [] param0 = [[6, 6, 13, 14, 16, 20, 24, 24, 24, 27, 28, 36, 49, 51, 55, 56, 62, 69, 74, 74, 76, 85, 86, 90, 92, 98], [-42, 96, 68... |
BASIC_AND_EXTENDED_EUCLIDEAN_ALGORITHMS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 2, 4, 2, 1, 1, 1, 3, 2, 1];
int [] param0 = [46, 26, 40, 58, 25, 2, 8, 21, 82, 17];
int [] param1 = [89, 82, 12, 4, 44, 87, 65, 87, 10, 61];
int n_success = 0;
for (int i = 0; i... |
COUNT_SET_BITS_IN_AN_INTEGER_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [4, 5, 2, 4, 3, 2, 1, 3, 4, 2];
int [] param0 = [43, 94, 72, 86, 42, 33, 8, 74, 29, 34];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_filled(p... |
CHECK_WHETHER_NUMBER_DUCK_NUMBER_NOT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 1, 8, 0, 2, 5, 0, 0, 1, 0];
string [] param0 = ["hllqwsphzcic", "080287724", "0000100000", " q", "4247040983", "00001011101", "lbnsnythmlbcf", "24", "110", "ie"];
int n_success = 0;
... |
LCS_FORMED_CONSECUTIVE_SEGMENTS_LEAST_LENGTH_K | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [8, 2, 7, 5, 0, 5, 4, 3, 3, 0];
int [] param0 = [4, 2, 3, 5, 2, 3, 3, 1, 2, 2];
string [] param1 = ["aggayxysdfa", "55571659965107", "01011011100", "aggasdfa", "5710246551", "0100010", "aabca... |
FIND_SUM_UNIQUE_SUB_ARRAY_SUM_GIVEN_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [5631, 52, 0, 207596, -1638, 0, 27034, 1698, 0, 267019];
int [] [] param0 = [[7, 24, 34, 35, 36, 40, 49, 51, 53, 74, 78], [-34, 60, 32], [0], [80, 64, 10, 82, 14, 75, 51, 91, 1, 25, 98, 22, 36, 2... |
COUNT_PAIRS_DIFFERENCE_EQUAL_K_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 14, 1, 3, 4, 1, 0, 0, 0, 0];
int [] [] param0 = [[5, 5, 10, 19, 29, 32, 40, 60, 65, 70, 72, 89, 92], [-98, -90, -88, -82, -80, -78, -74, -74, -72, -62, -58, -58, -56, -52, -48, -46, -38, -38,... |
MINIMUM_STEPS_TO_DELETE_A_STRING_AFTER_REPEATED_DELETION_OF_PALINDROME_SUBSTRINGS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [8, 7, 3, 7, 5, 2, 6, 7, 2, 2];
string [] param0 = ["yctlqthlwr", "47713514383248", "0100101001111", "xfdiyvn", "45499225407", "000100111001", "zouqhqwoap", "18579027952", "00000001111", "jd"];
... |
CHECK_GIVEN_SENTENCE_GIVEN_SET_SIMPLE_GRAMMER_RULES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, true, false, false, false, true, false, false, false];
char [] [] param0 = [['i', ' ', 'l', 'o', 'v', 'e', ' ', 'c', 'i', 'n', 'e', 'm', 'a', '.'], ['t', 'h', 'e', ' ', 'v', 'e', 'r... |
NON_REPEATING_ELEMENT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, -96, -1, 19, -90, -1, 1, -84, -1, 2];
int [] [] param0 = [[1, 2, 3, 4, 6, 6, 7, 9, 10, 13, 16, 23, 30, 32, 36, 42, 42, 43, 44, 47, 48, 48, 49, 52, 52, 53, 55, 56, 58, 59, 60, 60, 63, 67, 68, ... |
HOW_CAN_WE_SUM_THE_DIGITS_OF_A_GIVEN_NUMBER_IN_SINGLE_STATEMENT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [12, 3, 2, 10, 16, 8, 8, 13, 4, 10];
int [] param0 = [57, 21, 11, 64, 88, 62, 17, 49, 22, 19];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fi... |
SUM_MANHATTAN_DISTANCES_PAIRS_POINTS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [35930, 35216, 4, 19322, 42084, 4, 2776, 28932, 188, 0];
int [] [] param0 = [[2, 4, 6, 6, 8, 11, 12, 13, 14, 19, 20, 22, 24, 28, 29, 30, 32, 35, 37, 44, 48, 49, 51, 51, 56, 59, 59, 62, 65, 68, 68... |
BINARY_REPRESENTATION_OF_NEXT_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["1000", "48710000000000", "0010", "10000000000", "8410000000", "10", "10000000000", "100000000", "001110", "1000000000"];
string [] param0 = ["dxh", "48703586411816", "0001", "ywg wvjnks", "8... |
MIDDLE_OF_THREE_USING_MINIMUM_COMPARISONS_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [24, 66, 40, 10, 56, 50, 62, 16, 41, 63];
int [] param0 = [43, 76, 57, 10, 59, 92, 49, 16, 33, 66];
int [] param1 = [24, 54, 5, 13, 47, 14, 62, 95, 41, 63];
int [] param2 = [7, 66, 40, 4,... |
COUNT_PAIRS_WHOSE_PRODUCTS_EXIST_IN_ARRAY_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 36, 0, 2, 861, 9, 0, 66, 0];
int [] [] param0 = [[7, 10, 17, 17, 18, 20, 27, 28, 29, 29, 31, 32, 41, 43, 45, 46, 63, 66, 69, 69, 70, 75, 87, 95], [-60], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1... |
CHECK_IF_ALL_THE_ELEMENTS_CAN_BE_MADE_OF_SAME_PARITY_BY_INVERTING_ADJACENT_ELEMENTS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, false, true, true, true, true, true, true, true];
int [] [] param0 = [[1, 1, 1, 7, 7, 8, 10, 10, 10, 14, 15, 18, 20, 23, 24, 24, 26, 30, 32, 32, 33, 36, 42, 43, 46, 48, 51, 51, 52, ... |
HYPERCUBE_GRAPH | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [536870912, 268435456, 33554432, 4194304, 524288, 65536, 8192, 1024, 128, 16];
int [] param0 = [29, 28, 25, 22, 19, 16, 13, 10, 7, 4];
int n_success = 0;
for (int i = 0; i < param0.leng... |
NUMBER_UNIQUE_RECTANGLES_FORMED_USING_N_UNIT_SQUARES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [66, 104, 83, 28, 151, 76, 128, 144, 135, 127];
int [] param0 = [34, 49, 41, 17, 67, 38, 59, 64, 61, 58];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results... |
K_TH_DISTINCT_OR_NON_REPEATING_ELEMENT_IN_AN_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [89, -32, -1, -1, 44, -1, -1, -1, -1, 65];
int [] [] param0 = [[2, 3, 8, 18, 20, 33, 53, 56, 60, 71, 76, 80, 81, 87, 88, 89, 92, 95], [-78, 6, 32, 52, -12, -32, 22, -40, -82, 24, 30, 10, -40], [0... |
FIND_INDEX_GIVEN_FIBONACCI_NUMBER_CONSTANT_TIME_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [8, 11, 9, 8, 11, 11, 10, 10, 8, 4];
int [] param0 = [20, 95, 39, 21, 94, 79, 56, 62, 23, 3];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fil... |
COUNT_WAYS_DIVIDE_CIRCLE_USING_N_NON_INTERSECTING_CHORDS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [477638700, 129644790, 2674440, 58786, 1430, 42, 2];
int [] param0 = [18, 17, 14, 11, 8, 5, 2];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_f... |
DYNAMIC_PROGRAMMING_SET_28_MINIMUM_INSERTIONS_TO_FORM_A_PALINDROME | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 3, 0, 3, 0, 1, 2, 4, 0, 1];
char [] [] param0 = [['f', 'f', 'j', 'k', 'k', 'l', 'p', 's', 't', 'v', 'w', 'y', 'b', 'd', 'j', 'l', 't', 'u', 'x', 'y'], ['0', '1', '8', '8', '8', '4', '4', '3',... |
N_TH_NUMBER_WHOSE_SUM_OF_DIGITS_IS_TEN_2 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [631, 649, 640, 856, 910, 415, 838, 82, 766, 478];
int [] param0 = [68, 70, 69, 93, 99, 44, 91, 8, 83, 51];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (resul... |
MAXIMUM_AREA_RECTANGLE_PICKING_FOUR_SIDES_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [4845, 0, 1, 1632, 5412, 1, 5525, 1248, 1, 4794];
int [] [] param0 = [[99, 96, 95, 95, 92, 84, 83, 82, 81, 74, 72, 68, 67, 52, 51, 51, 49, 47, 44, 40, 36, 25, 24, 17, 16, 14, 12, 11, 9, 8, 6, 5, ... |
CALCULATE_AREA_TETRAHEDRON | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
double [] results = [22994.17, 20696.54, 5052.87, 114350.83, 258.92, 10739.18, 7542.47, 91769.26, 40.42, 258.92];
int [] param0 = [58, 56, 35, 99, 13, 45, 40, 92, 7, 13];
int n_success = 0;
for (int i =... |
SEARCH_INSERT_AND_DELETE_IN_A_SORTED_ARRAY_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 7, 13, 21, 30, 12, 13, 38, 3, 24];
int [] [] param0 = [[69], [-34, -38, -72, 90, -84, -40, 6, -52, -12, 80, -4, -58], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1], [9... |
MINIMUM_FLIP_REQUIRED_MAKE_BINARY_MATRIX_SYMMETRIC_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [27, 15, 340, 21, 55, 46, 230, 0, 340, 432];
int [] [] [] param0 = [[[16, 16, 47, 49, 50, 64, 70, 83, 88], [11, 12, 24, 32, 36, 39, 48, 58, 62], [29, 31, 35, 49, 71, 78, 82, 92, 96], [6, 21, 46, ... |
FIND_SUBARRAY_WITH_GIVEN_SUM_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 0, 1, 1, 0, 1, 1, 1, 1, 1];
int [] [] param0 = [[7, 7, 8, 8, 23, 24, 28, 32, 48, 53, 56, 62, 69, 77, 81, 82, 84, 87, 88, 90], [-62, -62, -80, -30, -80, 44, -12, -76, 16, -52, -86, 72, 32, -60... |
CHECK_NUMBER_POWER_K_USING_BASE_CHANGING_METHOD | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, true, false, true, false, false, false, false, false];
int [] param0 = [64, 16, 27, 81, 1, 69, 8, 31, 43, 54];
int [] param1 = [4, 2, 3, 72, 9, 17, 20, 79, 81, 89];
int n_s... |
ARRAY_RANGE_QUERIES_ELEMENTS_FREQUENCY_VALUE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [3, 2, 1, 0, 0, 1, 0, 0, 0, 0];
int [] param0 = [0, 1, 3, 10, 2, 0, 14, 29, 31, 21];
int [] param1 = [31, 25, 4, 15, 3, 6, 18, 33, 19, 32];
int [] [] param2 = [[1, 2, 2, 3, 3, 3, 12, 13, ... |
MULTIPLY_TWO_NUMBERS_WITHOUT_USING_MULTIPLY_DIVISION_BITWISE_OPERATORS_AND_NO_LOOPS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1692, 828, 528, 6900, 1075, 1824, 1767, 136, 912, 5180];
int [] param0 = [18, 23, 24, 75, 25, 57, 31, 8, 12, 74];
int [] param1 = [94, 36, 22, 92, 43, 32, 57, 17, 76, 70];
int n_success... |
MINIMUM_INSERTIONS_SORT_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 3, 0, 7, 0, 4, 0, 30, 0, 10];
int [] [] param0 = [[4, 7, 20, 22, 23, 31, 33, 36, 47, 61, 63, 63, 71, 74, 82, 91, 95, 99], [-84, 12, -42, -78, 22, 72, 56, 70, 28, -72], [0, 0, 0, 0, 0, 0, 0, 0... |
FIND_SUM_NON_REPEATING_DISTINCT_ELEMENTS_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [971, 84, 1, 769, -972, 1, 765, 150, 1, 135];
int [] [] param0 = [[5, 6, 8, 10, 21, 22, 27, 32, 35, 36, 43, 44, 46, 48, 49, 55, 60, 61, 69, 69, 71, 72, 73, 78, 88, 94], [80, 94, 16, -74, 32, -64,... |
SUM_SERIES_23_45_67_89_UPTO_N_TERMS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
double [] results = [0.7803986631477524, -0.16507936507936516, -0.21050375120783382, -0.21185466678122022, -0.2120245854859959, 0.7770671416747363, -0.21172836828074082, 0.780190394898247, 0.7821931668684383, 0.78255... |
PROGRAM_FOR_DEADLOCK_FREE_CONDITION_IN_OPERATING_SYSTEM | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1369, 165, 51, 2699, 2605, 5761, 89, 61, 1509, 2443];
int [] param0 = [38, 82, 2, 38, 31, 80, 11, 2, 26, 37];
int [] param1 = [37, 3, 26, 72, 85, 73, 9, 31, 59, 67];
int n_success = 0;
... |
QUICK_WAY_CHECK_CHARACTERS_STRING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, true, true, false, false, false, true, true, true, false];
string [] param0 = ["", "ggg", "11", "koyihns", "232", "10111000011101", "dddd", "11", "11111", "ewjvixqzu"];
int n_success... |
PROGRAM_TO_CHECK_IF_A_MATRIX_IS_SYMMETRIC | 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 = [[[29]], [[1, 3, 5], [3, 2, 4], [5, 4, 1]], [[1, 2, 5], [3, 2, 4], [5, 4, 1]], [[32, 53, 61, 4, 94, 83... |
FIND_ONE_EXTRA_CHARACTER_STRING_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
char [] results = [' ', '3', '0', 's', '6', '2', 'q', '4', '0', 'v'];
string [] param0 = ["obfla mmmyvghh", "2941", "0111111", "owvbfsti", "4937516500", "101110100", "hyzscjqfbe", "58443", "1100", "zudyuibvnaeeb"... |
BREAK_NUMBER_THREE_PARTS_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
long [] results = [2628, 2628, 703, 10, 4851, 2485, 136, 1225, 3081, 28];
long [] param0 = [71, 71, 36, 3, 97, 69, 15, 48, 77, 6];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if ... |
FIND_THE_ELEMENT_BEFORE_WHICH_ALL_THE_ELEMENTS_ARE_SMALLER_THAN_IT_AND_AFTER_WHICH_ALL_ARE_GREATER_THAN_IT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [3, -1, -1, -1, 28, -1, 8, -1, -1, -1];
int [] [] param0 = [[4, 24, 30, 33, 56, 67, 87, 90], [72, -48, 12, 4, 46, 36, 2, 58, 82, -88, -14, 56, 90, 76, 18, -6, -28, 18, 88, 90, 40, -68, -10, -82, ... |
SUM_K_TH_GROUP_ODD_POSITIVE_NUMBERS_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [185193, 884736, 2744, 262144, 13824, 405224, 614125, 19683, 474552, 1];
int [] param0 = [57, 96, 14, 64, 24, 74, 85, 27, 78, 1];
int n_success = 0;
for (int i = 0; i < param0.length; i... |
FIND_THE_MAXIMUM_ELEMENT_IN_AN_ARRAY_WHICH_IS_FIRST_INCREASING_AND_THEN_DECREASING | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [94, 92, 1, 83, 86, 0, 97, 86, 1, 61];
int [] [] param0 = [[11, 15, 16, 19, 24, 25, 26, 28, 34, 34, 43, 61, 63, 66, 67, 72, 77, 79, 81, 83, 87, 94, 99], [8, 92], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,... |
LEXICOGRAPHICALLY_MINIMUM_STRING_ROTATION | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["echlonw", "2", "001", "aghbcz", "05505687982061", "000100101111", "yhznnyulljp", "17599845449992", "01111", "cyejsyjwzqvypg"];
string [] param0 = ["onwechl", "2", "100", "ghbcza", "505687982... |
COUNT_NUMBER_OF_SOLUTIONS_OF_X2_1_MOD_P_IN_GIVEN_RANGE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [11, 1, 6, 4, 1, 11, 3, 17, 1, 9];
int [] param0 = [94, 11, 88, 85, 74, 96, 49, 50, 21, 81];
int [] param1 = [36, 79, 63, 43, 89, 33, 51, 24, 26, 19];
int n_success = 0;
for (int i ... |
MAXIMIZE_VOLUME_CUBOID_GIVEN_SUM_SIDES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [11132, 4096, 7600, 392, 100, 10648, 0, 15625, 7220, 17576];
int [] param0 = [67, 48, 59, 22, 14, 66, 1, 75, 58, 78];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
PROGRAM_PRINT_SUM_GIVEN_NTH_TERM_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1764, 1600, 4489, 5329, 324, 256, 5476, 1089, 8464, 484];
long [] param0 = [42, 40, 67, 73, 18, 16, 74, 33, 92, 22];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
DECIMAL_REPRESENTATION_GIVEN_BINARY_STRING_DIVISIBLE_10_NOT | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, false, false, true, true, false, true, false, false, true];
string [] param0 = ["101000", "39613456759141", "11", "poihjo", "2", "0000101", "t s dzkedx gk", "3944713969", "1000", "ifyugd... |
FIND_N_TH_ELEMENT_FROM_STERNS_DIATOMIC_SERIES | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [11, 2, 5, 3, 5, 11, 11, 4, 1, 7];
int [] param0 = [37, 24, 13, 56, 26, 67, 82, 60, 64, 65];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fill... |
COUNT_SUBARRAYS_TOTAL_DISTINCT_ELEMENTS_ORIGINAL_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 4, 160, 1, 1, 609, 1, 1, 91, 1];
int [] [] param0 = [[13, 39, 49, 52, 53, 69, 72, 79, 83, 96], [-98, -98, 22, -10, -28, 0, 56, 72, 36, 88, 96, 22, 90, 74, -60, -64, 0, 2, -42, 0, 94, -82, -74... |
MINIMUM_SUM_SUBSEQUENCE_LEAST_ONE_EVERY_FOUR_CONSECUTIVE_ELEMENTS_PICKED_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [188, -76, 6, 48, -366, 1, 61, -474, 0, 36];
int [] [] param0 = [[4, 4, 9, 26, 31, 31, 33, 35, 40, 45, 48, 52, 57, 60, 69, 75, 82, 89, 90, 92, 95, 97], [60, -68, 30, -62, -8, 48, -20, 30, 16, -60... |
STEINS_ALGORITHM_FOR_FINDING_GCD | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 1, 1, 1, 1, 3, 1, 1, 1, 2];
int [] param0 = [37, 58, 89, 75, 59, 84, 47, 37, 83, 28];
int [] param1 = [93, 13, 27, 14, 47, 39, 76, 75, 62, 58];
int n_success = 0;
for (int i = 0... |
FIRST_UPPERCASE_LETTER_IN_A_STRING_ITERATIVE_AND_RECURSIVE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
char [] results = ['h', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00'];
string [] param0 = ["ph", "96544000", "000010000", "ujqpx", "20684847994", "111", "rclkv", "45173693434", "11111011... |
SUM_TWO_LARGE_NUMBERS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["575584", "0526110507350", "121110010", "74169", "614", "01110101112", "106743", "898423490593", "01211112110121", "359233"];
string [] param0 = ["12687", "0526110506447", "011010010", "70234... |
PADOVAN_SEQUENCE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 351, 151, 3, 4, 9, 49, 4410, 12, 7];
int [] param0 = [1, 22, 19, 5, 6, 9, 15, 31, 10, 8];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fil... |
CASSINIS_IDENTITY | 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 = [67, 2, 58, 6, 42, 17, 37, 44, 23, 40];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fille... |
COUNT_OPERATIONS_MAKE_STRINGAB_FREE | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 0, 5, 0, 0, 0, 0, 0, 9];
char [] [] param0 = [['l', 'k', 'y'], ['1', '0', '9', '5', '7', '4', '6', '0', '4', '8', '0', '1', '4', '1', '8', '9', '1', '5', '4', '4', '8', '0', '5', '8', '9',... |
LARGEST_SUBARRAY_WITH_EQUAL_NUMBER_OF_0S_AND_1S_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [0, 0, 10, 0, 0, 0, 0, 2, 2, 0];
int [] [] param0 = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 42, 60, 66, 69, 70, 70, 73, 74, 80, 99], [1, -66], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1,... |
CONSTRUCT_LEXICOGRAPHICALLY_SMALLEST_PALINDROME | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
string [] results = ["", "", "", "", "", "", "dnr", "", "", ""];
char [] [] param0 = [['a', 'b', 'c', 'g', 'i', 'l', 'l', 'o', 'o', 'p', 'q', 's', 'w', 'y', 'c', 'd', 'e', 'f', 'f', 'i', 'm', 'm', 'o', 'q', 'v', ... |
COUNT_DERANGEMENTS_PERMUTATION_SUCH_THAT_NO_ELEMENT_APPEARS_IN_ITS_ORIGINAL_POSITION_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [2, 9, 44, 265, 1854, 14833, 133496, 1334961, 14684570, 176214841];
int [] param0 = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
NUMBER_ORDERED_PAIRS_AI_AJ_0 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [54, 6, 506, 172, 266, 100, 238, 116, 14, 108];
int [] [] param0 = [[17, 20, 32, 35, 35, 36, 43, 47, 59, 59, 68, 69, 70, 70, 75, 82, 88, 94, 96, 99], [-78, -40, 58, -36, 34, -12, -38, 48, -66, 16... |
SMALLEST_POWER_OF_2_GREATER_THAN_OR_EQUAL_TO_N | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [16, 32, 1, 32, 128, 128, 64, 64, 128, 64];
int [] param0 = [13, 27, 1, 24, 98, 94, 36, 41, 74, 39];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] =... |
COMPOSITE_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
bool [] results = [true, false, false, true, true, true, true, false, true, true];
int [] param0 = [62, 13, 29, 72, 30, 20, 10, 47, 91, 52];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
... |
SUM_OF_ALL_PROPER_DIVISORS_OF_A_NATURAL_NUMBER | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [1, 23, 28, 1, 22, 1, 33, 1, 40, 1];
int [] param0 = [2, 57, 28, 43, 38, 29, 45, 47, 44, 3];
int n_success = 0;
for (int i = 0; i < param0.length; i++) {
if (results[i] == f_fill... |
K_TH_DISTINCT_OR_NON_REPEATING_ELEMENT_IN_AN_ARRAY_1 | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [73, -1, -1, 6, -1, -1, 79, -1, -1, 45];
int [] [] param0 = [[17, 25, 27, 27, 73, 91], [-86, -74, -88, 28, -32, 20, -34, 32], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,... |
SUM_K_TH_GROUP_ODD_POSITIVE_NUMBERS | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [753571, 140608, 474552, 132651, 274625, 59319, 74088, 1728, 175616, 941192];
int [] param0 = [91, 52, 78, 51, 65, 39, 42, 12, 56, 98];
int n_success = 0;
for (int i = 0; i < param0.len... |
SEARCH_AN_ELEMENT_IN_A_SORTED_AND_PIVOTED_ARRAY | import std.stdio;
import std.math;
import std.conv;
import std.algorithm;
//TOFILL//
void main(){
int [] results = [8, 1, 3, -1, -1, -1, -1, -1, -1, -1];
int [] [] param0 = [[5, 6, 7, 8, 9, 10, 1, 2, 3], [30, 40, 50, 10, 20], [40, 50, 55, 67, 70, 4, 5, 6, 7], [14, 41, 38, 67, 99, 11, 96, 52, 4, 29, 22, 57, 3,... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.