public static void main(String[] args) {
ExampleRunner.eq(1, 3, new Cut().getMaximum(new int[] {13, 20, 13}, 2));
ExampleRunner.eq(2, 0, new Cut().getMaximum(new int[] {5, 5, 5, 5}, 2));
ExampleRunner.eq(3, 5, new Cut().getMaximum(new int[] {34, 10, 48}, 4));
ExampleRunner.eq(4, 16, new Cut().getMaximum(new int[] {30, 50, 30, 50}, 350));
ExampleRunner.eq(5, 0, new Cut().getMaximum(new int[] {1}, 1));
ExampleRunner.eq(6, 1, new Cut().getMaximum(new int[] {10}, 1));
ExampleRunner.eq(7, 2, new Cut().getMaximum(new int[] {20}, 1));
ExampleRunner.eq(8, 3, new Cut().getMaximum(new int[] {25, 15}, 3));
ExampleRunner.eq(9, 3, new Cut().getMaximum(new int[] {25, 15}, 4));
ExampleRunner.eq(10, 3, new Cut().getMaximum(new int[] {25, 15}, 5));
ExampleRunner.eq(
11,
52,
new Cut()
.getMaximum(
new int[] {
10, 10, 10, 10, 10, 50, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10
},
3));
ExampleRunner.eq(
12,
54,
new Cut()
.getMaximum(
new int[] {
10, 10, 10, 10, 10, 50, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10
},
4));
ExampleRunner.eq(
13,
54,
new Cut()
.getMaximum(
new int[] {
10, 10, 10, 10, 10, 50, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10
},
5));
ExampleRunner.eq(
14,
54,
new Cut()
.getMaximum(
new int[] {
10, 10, 10, 10, 10, 50, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10
},
1000));
ExampleRunner.eq(15, 99, new Cut().getMaximum(new int[] {999}, 99));
ExampleRunner.eq(16, 99, new Cut().getMaximum(new int[] {999}, 100));
ExampleRunner.eq(17, 22, new Cut().getMaximum(new int[] {143, 32, 59, 128, 147}, 22));
ExampleRunner.eq(
18,
143,
new Cut()
.getMaximum(
new int[] {121, 117, 133, 169, 52, 71, 83, 112, 97, 53, 191, 173, 41, 124, 72},
143));
ExampleRunner.eq(
19,
229,
new Cut()
.getMaximum(
new int[] {
41, 22, 11, 159, 178, 37, 182, 182, 123, 95, 98, 19, 122, 2, 88, 175, 87, 62, 83,
139, 179, 37, 131, 15, 146
},
229));
ExampleRunner.eq(
20,
372,
new Cut()
.getMaximum(
new int[] {
111, 163, 139, 108, 97, 125, 44, 92, 156, 49, 194, 142, 132, 42, 41, 67, 56, 176,
47, 175, 176, 154, 169, 13, 135, 133, 128, 188, 107, 7, 175, 4, 188, 59, 111
},
385));
ExampleRunner.eq(
21,
471,
new Cut()
.getMaximum(
new int[] {
19, 87, 158, 158, 128, 94, 152, 168, 12, 158, 51, 24, 87, 101, 141, 174, 165, 174,
155, 107, 129, 78, 194, 129, 61, 75, 175, 66, 18, 116, 186, 129, 178, 5, 53, 65,
4, 196, 144, 41, 136, 85, 131, 107, 139
},
497));
ExampleRunner.eq(22, 276, new Cut().getMaximum(new int[] {128, 553, 964, 371, 769}, 276));
ExampleRunner.eq(
23,
816,
new Cut()
.getMaximum(
new int[] {
957, 653, 962, 452, 709, 985, 742, 705, 991, 153, 108, 683, 684, 21, 312
},
816));
ExampleRunner.eq(
24,
902,
new Cut()
.getMaximum(
new int[] {
739, 618, 127, 164, 38, 961, 437, 61, 63, 463, 214, 528, 111, 949, 76, 706, 946,
292, 478, 25, 502, 372, 524, 807, 741
},
902));
ExampleRunner.eq(
25,
1000,
new Cut()
.getMaximum(
new int[] {
537, 355, 775, 222, 801, 146, 938, 808, 206, 526, 281, 82, 411, 206, 934, 476,
405, 697, 939, 63, 483, 521, 208, 675, 647, 414, 509, 998, 889, 203, 831, 948,
605, 619, 597
},
1000));
ExampleRunner.eq(
26,
1000,
new Cut()
.getMaximum(
new int[] {
426, 729, 121, 319, 647, 459, 117, 37, 107, 223, 526, 117, 695, 584, 845, 216,
114, 986, 831, 586, 448, 182, 894, 426, 775, 481, 426, 782, 745, 908, 37, 835,
471, 579, 775, 15, 755, 74, 439, 836, 73, 797, 268, 32, 579
},
1000));
ExampleRunner.eq(27, 53, new Cut().getMaximum(new int[] {120, 100, 130, 190, 140, 40}, 48));
ExampleRunner.eq(
28,
175,
new Cut()
.getMaximum(
new int[] {160, 60, 10, 30, 200, 60, 100, 180, 200, 100, 170, 180, 60, 200, 40},
163));
ExampleRunner.eq(
29,
280,
new Cut()
.getMaximum(
new int[] {
100, 120, 120, 150, 20, 50, 120, 110, 160, 180, 110, 200, 50, 70, 180, 30, 80,
140, 80, 180, 60, 150, 200, 140
},
280));
ExampleRunner.eq(
30,
341,
new Cut()
.getMaximum(
new int[] {
20, 40, 60, 90, 40, 150, 130, 50, 200, 110, 50, 80, 70, 130, 160, 80, 40, 110,
200, 50, 20, 40, 100, 170, 180, 170, 180, 150, 30, 190, 30, 160, 130
},
353));
ExampleRunner.eq(
31,
486,
new Cut()
.getMaximum(
new int[] {
60, 40, 90, 190, 170, 90, 80, 70, 100, 180, 160, 130, 10, 200, 30, 170, 130, 150,
150, 170, 120, 140, 110, 160, 160, 60, 120, 70, 190, 60, 100, 60, 70, 190, 20,
170, 140, 170, 150, 130, 70, 30
},
510));
ExampleRunner.eq(32, 185, new Cut().getMaximum(new int[] {580, 450, 340, 10, 190, 280}, 185));
ExampleRunner.eq(
33,
492,
new Cut()
.getMaximum(
new int[] {230, 90, 600, 510, 180, 240, 220, 10, 530, 760, 600, 10, 420, 380, 800},
478));
ExampleRunner.eq(
34,
873,
new Cut()
.getMaximum(
new int[] {
270, 320, 610, 40, 760, 620, 700, 440, 450, 230, 770, 230, 40, 510, 340, 780, 50,
520, 300, 180, 20, 520, 800, 610
},
851));
ExampleRunner.eq(
35,
1027,
new Cut()
.getMaximum(
new int[] {
290, 490, 130, 740, 700, 300, 210, 800, 350, 320, 520, 50, 260, 610, 730, 560,
140, 670, 180, 170, 530, 690, 720, 640, 10, 240, 680, 780, 710, 570, 120, 420, 110
},
1000));
ExampleRunner.eq(
36,
1031,
new Cut()
.getMaximum(
new int[] {
570, 380, 740, 300, 650, 650, 230, 130, 360, 130, 570, 330, 240, 700, 360, 650,
350, 180, 80, 60, 560, 280, 350, 490, 670, 590, 730, 500, 20, 790, 160, 130, 220,
540, 540, 360, 700, 310, 500, 660, 120, 440
},
1000));
ExampleRunner.eq(37, 155, new Cut().getMaximum(new int[] {220, 120, 353, 470, 393}, 155));
ExampleRunner.eq(
38,
241,
new Cut()
.getMaximum(
new int[] {45, 490, 363, 30, 161, 315, 490, 187, 190, 90, 100, 233, 60, 414}, 234));
ExampleRunner.eq(
39,
599,
new Cut()
.getMaximum(
new int[] {
429, 170, 255, 489, 290, 116, 480, 408, 180, 450, 470, 228, 329, 310, 59, 390,
211, 410, 413, 350, 460, 472, 182
},
588));
ExampleRunner.eq(
40,
542,
new Cut()
.getMaximum(
new int[] {
187, 328, 420, 60, 2, 155, 380, 270, 110, 380, 34, 365, 4, 203, 248, 490, 410,
290, 440, 383, 380, 36, 175, 44, 360, 260, 387, 360, 73, 272, 210, 35
},
527));
ExampleRunner.eq(
41,
687,
new Cut()
.getMaximum(
new int[] {
49, 49, 235, 453, 199, 60, 266, 10, 250, 148, 175, 260, 314, 433, 373, 141, 138,
230, 204, 390, 450, 180, 460, 455, 360, 240, 470, 190, 280, 240, 434, 12, 63, 200,
280, 70, 403, 345, 50, 409, 22
},
668));
ExampleRunner.eq(
42,
687,
new Cut().getMaximum(new int[] {613, 930, 903, 574, 370, 390, 769, 992, 851, 502}, 687));
ExampleRunner.eq(
43,
726,
new Cut()
.getMaximum(
new int[] {
109, 213, 300, 845, 836, 448, 40, 240, 240, 214, 961, 240, 94, 330, 430, 552, 980,
450, 135, 363
},
717));
ExampleRunner.eq(
44,
1015,
new Cut()
.getMaximum(
new int[] {
942, 923, 300, 619, 980, 906, 530, 810, 920, 220, 520, 760, 350, 450, 568, 500,
969, 66, 151, 690, 488, 600, 541, 360, 931, 543, 240, 564, 387, 888
},
1000));
ExampleRunner.eq(
45,
1019,
new Cut()
.getMaximum(
new int[] {
930, 40, 959, 303, 270, 600, 690, 844, 978, 557, 370, 932, 513, 960, 490, 770,
613, 896, 115, 1000, 811, 640, 752, 460, 700, 997, 350, 492, 241, 419, 580, 858,
920, 300, 310, 810, 70, 520, 976, 928
},
1000));
ExampleRunner.eq(
46,
1023,
new Cut()
.getMaximum(
new int[] {
916, 60, 80, 863, 13, 84, 679, 719, 830, 851, 621, 359, 830, 432, 180, 746, 80,
140, 420, 167, 138, 250, 352, 461, 960, 260, 230, 760, 448, 660, 40, 153, 358,
440, 390, 850, 870, 850, 300, 292, 760, 140, 960, 570, 520, 980, 756, 722, 908,
772
},
1000));
ExampleRunner.eq(
47,
1035,
new Cut()
.getMaximum(
new int[] {
430, 440, 300, 60, 20, 70, 540, 460, 160, 680, 430, 720, 280, 210, 530, 290, 960,
30, 200, 110, 320, 830, 470, 10, 240, 150, 810, 800, 150, 80, 20, 460, 660, 460,
10, 430, 750, 620, 190, 610, 660, 720, 400, 310, 910, 800, 720, 740, 790, 270
},
1000));
ExampleRunner.eq(
48,
1000,
new Cut()
.getMaximum(
new int[] {
854, 849, 701, 162, 326, 767, 159, 218, 37, 632, 71, 29, 844, 735, 47, 914, 353,
954, 125, 254, 968, 901, 226, 981, 423, 247, 952, 747, 523, 115, 709, 393, 672,
366, 325, 989, 504, 228, 203, 951, 118, 879, 434, 557, 523, 509, 783, 955, 603,
198
},
1000));
ExampleRunner.eq(
49,
1005,
new Cut()
.getMaximum(
new int[] {
209, 164, 456, 162, 442, 320, 171, 192, 386, 414, 440, 259, 445, 377, 141, 176,
250, 184, 250, 483, 453, 1, 415, 416, 44, 313, 103, 56, 244, 118, 277, 50, 291,
453, 287, 82, 229, 205, 27, 267, 497, 371, 35, 276, 446, 409, 48, 293, 384, 359
},
1000));
ExampleRunner.eq(
50,
1010,
new Cut()
.getMaximum(
new int[] {
129, 171, 120, 15, 151, 153, 126, 507, 109, 202, 141, 258, 193, 91, 207, 18, 392,
32, 203, 438, 241, 18, 125, 338, 420, 121, 150, 372, 218, 187, 138, 40, 228, 50,
382, 122, 364, 80, 387, 30, 118, 400, 475, 220, 385, 404, 408, 389, 480, 497
},
1000));
ExampleRunner.eq(
51,
1015,
new Cut()
.getMaximum(
new int[] {
318, 238, 10, 214, 438, 416, 1, 470, 440, 27, 88, 253, 430, 100, 212, 315, 401,
478, 378, 496, 251, 184, 150, 96, 180, 441, 40, 370, 169, 88, 9, 150, 176, 266,
439, 72, 123, 90, 114, 230, 20, 240, 142, 215, 170, 259, 444, 381, 133, 187
},
1000));
ExampleRunner.eq(
52,
1020,
new Cut()
.getMaximum(
new int[] {
157, 43, 465, 510, 360, 440, 45, 48, 30, 131, 250, 374, 480, 296, 132, 440, 380,
80, 244, 210, 426, 420, 25, 110, 424, 189, 502, 26, 135, 380, 338, 357, 86, 490,
310, 455, 364, 379, 312, 370, 255, 108, 342, 176, 431, 189, 210, 240, 370, 240
},
1000));
ExampleRunner.eq(
53,
1025,
new Cut()
.getMaximum(
new int[] {
242, 265, 527, 433, 270, 197, 90, 350, 363, 320, 426, 396, 460, 334, 40, 130, 500,
15, 322, 400, 70, 400, 270, 504, 54, 170, 500, 80, 340, 360, 68, 71, 270, 540,
350, 511, 500, 301, 176, 460, 20, 415, 330, 2, 134, 494, 178, 355, 310, 377
},
1000));
ExampleRunner.eq(
54,
1000,
new Cut()
.getMaximum(
new int[] {
227, 407, 11, 418, 223, 678, 928, 166, 815, 293, 684, 282, 749, 397, 256, 836,
743, 776, 497, 836, 891, 19, 727, 605, 196, 93, 57, 402, 215, 265, 215, 485, 641,
819, 937, 122, 312, 438, 157, 173, 87, 973, 19, 152, 867, 456, 626, 702, 312, 115
},
1000));
ExampleRunner.eq(
55,
1027,
new Cut()
.getMaximum(
new int[] {
480, 950, 500, 100, 410, 680, 910, 380, 940, 240, 310, 700, 530, 690, 670, 800,
320, 570, 700, 980, 610, 110, 700, 610, 160, 870, 570, 790, 100, 740, 880, 860,
620, 910, 790, 860, 920, 170, 200, 30, 370, 290, 850, 480, 380, 430, 890, 330,
840, 960
},
1000));
ExampleRunner.eq(
56,
100,
new Cut()
.getMaximum(
new int[] {
9, 9, 1000, 9, 9, 9, 9, 9, 9, 9, 1000, 9, 1000, 9, 9, 9, 9, 9, 9, 9, 1000, 9, 9,
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1000, 9, 9, 9, 9
},
99));
ExampleRunner.eq(
57,
101,
new Cut()
.getMaximum(
new int[] {
9, 1000, 9, 9, 9, 9, 1000, 9, 9, 9, 1000, 1000, 9, 1000, 9, 1000, 1000, 9, 9, 9,
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1000, 9, 9, 9, 9, 1000, 9, 9, 9, 1000, 9, 9, 9, 9, 9
},
100));
ExampleRunner.eq(
58,
102,
new Cut()
.getMaximum(
new int[] {
9, 9, 9, 9, 9, 9, 9, 1000, 9, 1000, 9, 9, 9, 9, 9, 9, 9, 1000, 9, 1000, 9, 9, 9,
9, 9, 1000, 1000, 1000, 1000, 9, 9, 9, 9, 9, 1000, 1000, 9, 1000, 1000, 9, 1000,
1000, 9, 9, 1000, 9, 9, 9, 9, 9
},
101));
ExampleRunner.eq(
59,
50,
new Cut()
.getMaximum(
new int[] {
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10
},
1));
ExampleRunner.eq(
60,
1050,
new Cut()
.getMaximum(
new int[] {
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 20, 20, 20, 20, 20,
20, 20, 20, 20, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 20
},
1000));
ExampleRunner.eq(61, 2, new Cut().getMaximum(new int[] {30, 20, 15}, 1));
ExampleRunner.eq(62, 3, new Cut().getMaximum(new int[] {13, 20, 13}, 2));
ExampleRunner.eq(
63,
8,
new Cut()
.getMaximum(
new int[] {
1, 2, 3, 4, 5, 30, 6, 7, 8, 9, 50, 10, 11, 12, 13, 14, 15, 16, 30, 17, 18, 50
},
5));
ExampleRunner.eq(64, 9, new Cut().getMaximum(new int[] {100, 90}, 8));
ExampleRunner.eq(65, 6, new Cut().getMaximum(new int[] {30, 50, 30, 50}, 4));
ExampleRunner.eq(66, 2, new Cut().getMaximum(new int[] {11, 20}, 1));
ExampleRunner.eq(67, 4, new Cut().getMaximum(new int[] {40, 20, 20}, 2));
ExampleRunner.eq(68, 7, new Cut().getMaximum(new int[] {50, 30, 40}, 5));
ExampleRunner.eq(69, 11, new Cut().getMaximum(new int[] {100, 90, 20}, 9));
ExampleRunner.eq(70, 3, new Cut().getMaximum(new int[] {13, 40, 30}, 2));
ExampleRunner.eq(71, 5, new Cut().getMaximum(new int[] {23, 50, 30, 80, 20}, 3));
ExampleRunner.eq(72, 4, new Cut().getMaximum(new int[] {30, 20, 20}, 2));
ExampleRunner.eq(73, 4, new Cut().getMaximum(new int[] {100, 20}, 3));
ExampleRunner.eq(74, 5, new Cut().getMaximum(new int[] {20, 100, 20}, 3));
ExampleRunner.eq(75, 4, new Cut().getMaximum(new int[] {31, 40}, 3));
ExampleRunner.eq(76, 2, new Cut().getMaximum(new int[] {30, 20}, 1));
ExampleRunner.eq(
77, 4, new Cut().getMaximum(new int[] {10, 30, 11, 21, 20, 21, 11, 30, 10}, 1));
ExampleRunner.eq(78, 5, new Cut().getMaximum(new int[] {25, 25, 20, 30}, 3));
ExampleRunner.eq(79, 5, new Cut().getMaximum(new int[] {40, 30, 20}, 3));
ExampleRunner.eq(80, 3, new Cut().getMaximum(new int[] {23, 30}, 2));
ExampleRunner.eq(81, 2, new Cut().getMaximum(new int[] {40, 30, 20}, 1));
ExampleRunner.eq(82, 2, new Cut().getMaximum(new int[] {40, 20}, 1));
ExampleRunner.eq(83, 3, new Cut().getMaximum(new int[] {50, 30}, 2));
ExampleRunner.eq(84, 7, new Cut().getMaximum(new int[] {16, 32, 50, 20}, 5));
ExampleRunner.eq(85, 5, new Cut().getMaximum(new int[] {40, 20, 20}, 3));
ExampleRunner.eq(
86,
13,
new Cut().getMaximum(new int[] {120, 123, 45, 40, 30, 10, 20, 20, 22, 55, 30, 50}, 8));
ExampleRunner.eq(
87, 6, new Cut().getMaximum(new int[] {50, 60, 15, 20, 20, 20, 15, 15, 15}, 3));
ExampleRunner.eq(
88, 9, new Cut().getMaximum(new int[] {20, 20, 20, 30, 30, 30, 40, 40, 40, 40, 40}, 5));
ExampleRunner.eq(89, 2, new Cut().getMaximum(new int[] {13, 20}, 1));
ExampleRunner.eq(90, 3, new Cut().getMaximum(new int[] {40, 30}, 2));
ExampleRunner.eq(91, 6, new Cut().getMaximum(new int[] {15, 15, 20, 20, 20, 25, 25}, 3));
ExampleRunner.eq(92, 9, new Cut().getMaximum(new int[] {80, 40, 40}, 7));
ExampleRunner.eq(
93, 18, new Cut().getMaximum(new int[] {100, 20, 20, 20, 20, 20, 20, 20, 20, 20}, 9));
ExampleRunner.eq(
94,
16,
new Cut()
.getMaximum(new int[] {50, 50, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20}, 8));
ExampleRunner.eq(95, 5, new Cut().getMaximum(new int[] {48, 50}, 4));
ExampleRunner.eq(96, 3, new Cut().getMaximum(new int[] {80, 20}, 2));
ExampleRunner.eq(97, 2, new Cut().getMaximum(new int[] {100, 20}, 1));
ExampleRunner.eq(98, 2, new Cut().getMaximum(new int[] {13, 40, 13}, 2));
ExampleRunner.eq(99, 6, new Cut().getMaximum(new int[] {13, 30, 20, 20, 20}, 3));
ExampleRunner.eq(100, 6, new Cut().getMaximum(new int[] {10, 13, 14, 15, 20, 30, 40, 28}, 3));
ExampleRunner.eq(101, 6, new Cut().getMaximum(new int[] {50, 20, 20, 20}, 3));
ExampleRunner.eq(
102,
541,
new Cut()
.getMaximum(
new int[] {
1000, 1000, 1000, 1000, 1000, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 300, 270, 110
},
531));
ExampleRunner.eq(103, 8, new Cut().getMaximum(new int[] {30, 37, 41, 20, 20, 20, 10, 10}, 3));
ExampleRunner.eq(104, 3, new Cut().getMaximum(new int[] {31, 30}, 2));
ExampleRunner.eq(
105,
901,
new Cut()
.getMaximum(
new int[] {
931, 230, 984, 724, 288, 418, 20, 20, 401, 990, 333, 10, 11, 116, 452, 1000, 727,
217, 368, 165, 863, 370, 673, 997, 829, 294, 314, 480, 542, 713, 449, 897, 850,
209, 983, 883, 307, 738, 314, 88, 631, 441, 20, 420, 15, 10, 592, 490, 6, 999
},
888));
ExampleRunner.eq(106, 3, new Cut().getMaximum(new int[] {20, 10, 13}, 1));
ExampleRunner.eq(107, 2, new Cut().getMaximum(new int[] {23, 20}, 1));
ExampleRunner.eq(108, 2, new Cut().getMaximum(new int[] {13, 20, 23}, 1));
ExampleRunner.eq(
109,
8,
new Cut()
.getMaximum(new int[] {10, 21, 50, 10, 50, 50, 20, 50, 20, 50, 20, 50, 50, 31}, 3));
ExampleRunner.eq(110, 13, new Cut().getMaximum(new int[] {100, 20, 20, 20, 20, 9}, 9));
ExampleRunner.eq(111, 12, new Cut().getMaximum(new int[] {50, 50, 50}, 10));
ExampleRunner.eq(112, 2, new Cut().getMaximum(new int[] {13, 20, 13}, 1));
ExampleRunner.eq(113, 2, new Cut().getMaximum(new int[] {17, 20, 51}, 1));
ExampleRunner.eq(114, 4, new Cut().getMaximum(new int[] {40, 35, 35}, 3));
ExampleRunner.eq(115, 2, new Cut().getMaximum(new int[] {15, 20, 20}, 1));
ExampleRunner.eq(116, 19, new Cut().getMaximum(new int[] {100, 100, 20}, 17));
ExampleRunner.eq(117, 6, new Cut().getMaximum(new int[] {40, 20, 20, 20}, 3));
ExampleRunner.eq(118, 3, new Cut().getMaximum(new int[] {31, 20}, 2));
ExampleRunner.eq(119, 4, new Cut().getMaximum(new int[] {100, 100, 100, 20, 20}, 2));
ExampleRunner.eq(120, 1, new Cut().getMaximum(new int[] {50}, 1));
ExampleRunner.eq(121, 2, new Cut().getMaximum(new int[] {20}, 1));
ExampleRunner.eq(122, 7, new Cut().getMaximum(new int[] {40, 40, 30}, 5));
ExampleRunner.eq(123, 4, new Cut().getMaximum(new int[] {100, 20, 20}, 2));
ExampleRunner.eq(124, 5, new Cut().getMaximum(new int[] {40, 30, 20, 40}, 3));
ExampleRunner.eq(125, 2, new Cut().getMaximum(new int[] {50}, 2));
ExampleRunner.eq(126, 5, new Cut().getMaximum(new int[] {20, 20, 30, 48}, 3));
ExampleRunner.eq(127, 3, new Cut().getMaximum(new int[] {30, 33}, 2));
ExampleRunner.eq(128, 3, new Cut().getMaximum(new int[] {1, 10, 22, 20}, 1));
ExampleRunner.eq(129, 4, new Cut().getMaximum(new int[] {30, 40}, 3));
ExampleRunner.eq(130, 4, new Cut().getMaximum(new int[] {30, 10}, 2));
ExampleRunner.eq(131, 1, new Cut().getMaximum(new int[] {30}, 1));
ExampleRunner.eq(132, 4, new Cut().getMaximum(new int[] {40, 30, 20, 20}, 2));
ExampleRunner.eq(
133,
1010,
new Cut()
.getMaximum(
new int[] {
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000
},
1000));
ExampleRunner.eq(134, 2, new Cut().getMaximum(new int[] {13, 13, 20}, 1));
ExampleRunner.eq(135, 4, new Cut().getMaximum(new int[] {50, 20, 20, 13}, 2));
ExampleRunner.eq(136, 4, new Cut().getMaximum(new int[] {5, 20, 15, 20}, 2));
ExampleRunner.eq(137, 6, new Cut().getMaximum(new int[] {23, 23, 23, 30, 33, 33, 33}, 5));
ExampleRunner.eq(138, 3, new Cut().getMaximum(new int[] {11, 30}, 2));
ExampleRunner.eq(139, 2, new Cut().getMaximum(new int[] {50, 20}, 1));
ExampleRunner.eq(140, 2, new Cut().getMaximum(new int[] {15, 16, 17, 18, 19, 20}, 1));
ExampleRunner.eq(141, 2, new Cut().getMaximum(new int[] {15, 20}, 1));
ExampleRunner.eq(142, 3, new Cut().getMaximum(new int[] {13, 20, 10, 20}, 1));
ExampleRunner.eq(143, 6, new Cut().getMaximum(new int[] {50, 30, 30}, 4));
ExampleRunner.eq(144, 2, new Cut().getMaximum(new int[] {98, 72, 20, 98}, 1));
ExampleRunner.eq(145, 4, new Cut().getMaximum(new int[] {20, 20}, 3));
ExampleRunner.eq(146, 6, new Cut().getMaximum(new int[] {12, 22, 23, 33, 60}, 5));
ExampleRunner.eq(147, 5, new Cut().getMaximum(new int[] {11, 50, 40, 13, 30, 20, 11}, 3));
ExampleRunner.eq(148, 2, new Cut().getMaximum(new int[] {20, 50}, 1));
ExampleRunner.eq(149, 3, new Cut().getMaximum(new int[] {23, 20, 10, 11}, 1));
ExampleRunner.eq(150, 3, new Cut().getMaximum(new int[] {48, 10, 20}, 1));
ExampleRunner.eq(151, 5, new Cut().getMaximum(new int[] {48, 34, 20}, 4));
ExampleRunner.eq(152, 7, new Cut().getMaximum(new int[] {63, 40, 10, 20, 61}, 4));
ExampleRunner.eq(
153,
1,
new Cut()
.getMaximum(
new int[] {
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000
},
1));
ExampleRunner.eq(154, 6, new Cut().getMaximum(new int[] {30, 40, 20, 20, 20}, 3));
ExampleRunner.eq(155, 2, new Cut().getMaximum(new int[] {20, 22}, 1));
ExampleRunner.eq(156, 2, new Cut().getMaximum(new int[] {10, 11, 30}, 1));
ExampleRunner.eq(157, 5, new Cut().getMaximum(new int[] {30, 10, 20, 20}, 2));
ExampleRunner.eq(
158,
1026,
new Cut()
.getMaximum(
new int[] {
41, 320, 150, 460, 930, 700, 258, 952, 990, 820, 350, 899, 290, 400, 699, 440,
750, 860, 642, 10, 675, 291, 650, 126, 220, 520, 630, 17, 715, 500, 304, 160, 280,
30, 240, 419, 875, 340, 992, 360, 610, 60, 730, 960, 910, 928, 602, 530, 100, 907
},
1000));
ExampleRunner.eq(159, 7, new Cut().getMaximum(new int[] {34, 30, 20, 20, 30}, 4));
ExampleRunner.eq(160, 2, new Cut().getMaximum(new int[] {15, 20, 25}, 1));
ExampleRunner.eq(161, 4, new Cut().getMaximum(new int[] {11, 11, 11, 20}, 3));
ExampleRunner.eq(162, 2, new Cut().getMaximum(new int[] {30, 20, 30}, 1));
ExampleRunner.eq(163, 7, new Cut().getMaximum(new int[] {50, 20, 20, 20}, 4));
ExampleRunner.eq(164, 2, new Cut().getMaximum(new int[] {21, 20}, 1));
ExampleRunner.eq(165, 16, new Cut().getMaximum(new int[] {30, 50, 30, 50}, 350));
ExampleRunner.eq(166, 3, new Cut().getMaximum(new int[] {21, 57, 30}, 2));
ExampleRunner.eq(
167,
6,
new Cut()
.getMaximum(
new int[] {
19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21, 21, 21
},
5));
ExampleRunner.eq(168, 2, new Cut().getMaximum(new int[] {50, 40}, 2));
ExampleRunner.eq(169, 10, new Cut().getMaximum(new int[] {30, 80, 70}, 8));
ExampleRunner.eq(170, 4, new Cut().getMaximum(new int[] {44, 40}, 3));
ExampleRunner.eq(171, 3, new Cut().getMaximum(new int[] {30, 22}, 2));
ExampleRunner.eq(172, 10, new Cut().getMaximum(new int[] {15, 20, 50, 20, 30, 30}, 6));
ExampleRunner.eq(173, 3, new Cut().getMaximum(new int[] {20, 70}, 2));
ExampleRunner.eq(174, 2, new Cut().getMaximum(new int[] {20, 23}, 1));
ExampleRunner.eq(175, 10, new Cut().getMaximum(new int[] {50, 20, 20, 20, 20, 20}, 5));
ExampleRunner.eq(176, 4, new Cut().getMaximum(new int[] {48, 20, 20}, 2));
ExampleRunner.eq(177, 3, new Cut().getMaximum(new int[] {30, 45}, 2));
ExampleRunner.eq(178, 2, new Cut().getMaximum(new int[] {20, 30}, 1));
ExampleRunner.eq(179, 3, new Cut().getMaximum(new int[] {30, 30}, 2));
ExampleRunner.eq(180, 3, new Cut().getMaximum(new int[] {50, 20}, 2));
ExampleRunner.eq(181, 3, new Cut().getMaximum(new int[] {23, 30, 13, 55}, 2));
ExampleRunner.eq(182, 3, new Cut().getMaximum(new int[] {13, 13, 20}, 2));
ExampleRunner.eq(183, 3, new Cut().getMaximum(new int[] {20, 30}, 2));
ExampleRunner.eq(184, 6, new Cut().getMaximum(new int[] {20, 20, 41}, 4));
ExampleRunner.eq(185, 9, new Cut().getMaximum(new int[] {90}, 8));
ExampleRunner.eq(186, 3, new Cut().getMaximum(new int[] {30}, 2));
ExampleRunner.eq(187, 10, new Cut().getMaximum(new int[] {85, 60, 30, 20, 20}, 7));
ExampleRunner.eq(188, 8, new Cut().getMaximum(new int[] {53, 53, 53, 60, 63, 63, 63}, 7));
ExampleRunner.eq(189, 103, new Cut().getMaximum(new int[] {1000, 20, 20, 20}, 100));
ExampleRunner.eq(190, 6, new Cut().getMaximum(new int[] {20, 30, 10}, 3));
ExampleRunner.eq(191, 5, new Cut().getMaximum(new int[] {30, 30, 2, 17, 10}, 3));
ExampleRunner.eq(192, 1, new Cut().getMaximum(new int[] {10}, 1));
ExampleRunner.eq(193, 4, new Cut().getMaximum(new int[] {30, 10, 10, 10}, 1));
ExampleRunner.eq(194, 4, new Cut().getMaximum(new int[] {50, 20}, 3));
ExampleRunner.eq(195, 4, new Cut().getMaximum(new int[] {50, 30}, 3));
ExampleRunner.eq(196, 9, new Cut().getMaximum(new int[] {20, 30, 40, 50}, 6));
ExampleRunner.eq(
197,
3,
new Cut()
.getMaximum(
new int[] {
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 30, 1000, 1000,
1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000
},
2));
ExampleRunner.eq(198, 6, new Cut().getMaximum(new int[] {30, 50, 30}, 4));
ExampleRunner.eq(199, 3, new Cut().getMaximum(new int[] {100, 30}, 2));
ExampleRunner.eq(200, 3, new Cut().getMaximum(new int[] {30, 31}, 2));
ExampleRunner.eq(201, 4, new Cut().getMaximum(new int[] {100, 11, 21, 30, 20, 20}, 2));
ExampleRunner.eq(202, 3, new Cut().getMaximum(new int[] {50}, 3));
ExampleRunner.eq(203, 4, new Cut().getMaximum(new int[] {38, 20}, 3));
ExampleRunner.eq(204, 4, new Cut().getMaximum(new int[] {63, 40}, 3));
ExampleRunner.eq(205, 5, new Cut().getMaximum(new int[] {40, 20, 30, 50}, 3));
ExampleRunner.eq(206, 1, new Cut().getMaximum(new int[] {300}, 1));
ExampleRunner.eq(207, 1, new Cut().getMaximum(new int[] {100}, 1));
ExampleRunner.eq(208, 2, new Cut().getMaximum(new int[] {60, 20}, 1));
ExampleRunner.eq(209, 4, new Cut().getMaximum(new int[] {18, 18, 12, 40, 18, 18}, 3));
ExampleRunner.eq(210, 7, new Cut().getMaximum(new int[] {50, 50, 50, 40, 30, 40}, 5));
ExampleRunner.eq(211, 4, new Cut().getMaximum(new int[] {31, 20, 20}, 2));
ExampleRunner.eq(212, 4, new Cut().getMaximum(new int[] {13, 13, 13, 40}, 3));
ExampleRunner.eq(
213, 5, new Cut().getMaximum(new int[] {11, 11, 200, 200, 20, 20, 200, 1000}, 3));
ExampleRunner.eq(214, 3, new Cut().getMaximum(new int[] {20, 10}, 1));
ExampleRunner.eq(215, 2, new Cut().getMaximum(new int[] {60}, 2));
ExampleRunner.eq(216, 4, new Cut().getMaximum(new int[] {20, 20, 30}, 2));
ExampleRunner.eq(
217,
0,
new Cut().getMaximum(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}, 7));
ExampleRunner.eq(218, 15, new Cut().getMaximum(new int[] {143, 140, 15}, 14));
ExampleRunner.eq(219, 3, new Cut().getMaximum(new int[] {23, 23, 20}, 2));
ExampleRunner.eq(220, 6, new Cut().getMaximum(new int[] {40, 30, 20, 20, 20}, 3));
ExampleRunner.eq(221, 6, new Cut().getMaximum(new int[] {13, 23, 40, 20, 20, 10, 33}, 3));
ExampleRunner.eq(
222, 16, new Cut().getMaximum(new int[] {100, 100, 100, 19, 29, 39, 13, 33}, 15));
ExampleRunner.eq(223, 3, new Cut().getMaximum(new int[] {13, 30}, 2));
ExampleRunner.eq(224, 2, new Cut().getMaximum(new int[] {12, 12, 20}, 1));
ExampleRunner.eq(225, 7, new Cut().getMaximum(new int[] {30, 10, 10, 10, 50}, 3));
ExampleRunner.eq(226, 2, new Cut().getMaximum(new int[] {39, 20, 20}, 1));
ExampleRunner.eq(227, 3, new Cut().getMaximum(new int[] {35, 100, 30}, 2));
ExampleRunner.eq(228, 4, new Cut().getMaximum(new int[] {34, 28}, 4));
ExampleRunner.eq(229, 2, new Cut().getMaximum(new int[] {5, 5, 15, 20}, 1));
ExampleRunner.eq(230, 9, new Cut().getMaximum(new int[] {70, 30, 30, 30}, 6));
ExampleRunner.eq(231, 3, new Cut().getMaximum(new int[] {13, 13, 13, 30}, 2));
ExampleRunner.eq(232, 8, new Cut().getMaximum(new int[] {50, 20, 20, 20, 20}, 4));
ExampleRunner.eq(233, 2, new Cut().getMaximum(new int[] {34, 30, 20}, 1));
ExampleRunner.eq(234, 5, new Cut().getMaximum(new int[] {40, 20, 30}, 3));
ExampleRunner.eq(235, 2, new Cut().getMaximum(new int[] {27}, 5));
ExampleRunner.eq(236, 2, new Cut().getMaximum(new int[] {2, 30, 20}, 1));
ExampleRunner.eq(237, 3, new Cut().getMaximum(new int[] {10, 20}, 1));
ExampleRunner.eq(238, 2, new Cut().getMaximum(new int[] {15, 20, 35}, 1));
ExampleRunner.eq(239, 2, new Cut().getMaximum(new int[] {12, 20}, 1));
ExampleRunner.eq(
240,
9,
new Cut().getMaximum(new int[] {19, 20, 23, 25, 72, 51, 40, 30, 20, 16, 10, 12}, 5));
ExampleRunner.eq(241, 4, new Cut().getMaximum(new int[] {19, 40, 63}, 3));
ExampleRunner.eq(242, 4, new Cut().getMaximum(new int[] {20, 20}, 2));
ExampleRunner.eq(243, 2, new Cut().getMaximum(new int[] {13, 20, 13, 23, 36}, 1));
ExampleRunner.eq(
244,
13,
new Cut().getMaximum(new int[] {90, 120, 123, 45, 40, 30, 10, 20, 20, 22, 55, 30, 50}, 8));
ExampleRunner.eq(245, 6, new Cut().getMaximum(new int[] {60, 101}, 5));
ExampleRunner.eq(246, 12, new Cut().getMaximum(new int[] {100, 40, 40, 40}, 9));
ExampleRunner.eq(247, 5, new Cut().getMaximum(new int[] {10, 50, 40, 25}, 3));
ExampleRunner.eq(248, 3, new Cut().getMaximum(new int[] {30, 50, 30, 50}, 2));
ExampleRunner.eq(249, 4, new Cut().getMaximum(new int[] {40}, 3));
ExampleRunner.eq(250, 4, new Cut().getMaximum(new int[] {50, 50, 30}, 3));
ExampleRunner.eq(251, 1, new Cut().getMaximum(new int[] {30, 30}, 1));
ExampleRunner.eq(252, 2, new Cut().getMaximum(new int[] {40, 20, 30}, 1));
ExampleRunner.eq(253, 8, new Cut().getMaximum(new int[] {63, 40, 20, 10, 10}, 4));
ExampleRunner.eq(254, 4, new Cut().getMaximum(new int[] {13, 13, 13, 30, 40}, 3));
ExampleRunner.eq(255, 5, new Cut().getMaximum(new int[] {30, 30, 20}, 3));
ExampleRunner.eq(256, 9, new Cut().getMaximum(new int[] {11, 11, 11, 30, 30, 30}, 6));
ExampleRunner.eq(257, 6, new Cut().getMaximum(new int[] {10, 30, 20, 3}, 3));
ExampleRunner.eq(
258,
17,
new Cut().getMaximum(new int[] {10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 202, 20, 20}, 6));
ExampleRunner.eq(
259, 11, new Cut().getMaximum(new int[] {70, 80, 23, 20, 20, 20, 13, 40, 20, 30}, 6));
ExampleRunner.eq(
260, 9, new Cut().getMaximum(new int[] {10, 10, 10, 30, 30, 21, 21, 41, 45, 49}, 4));
ExampleRunner.eq(
261, 12, new Cut().getMaximum(new int[] {60, 20, 20, 20, 20, 20, 20, 20, 20}, 6));
ExampleRunner.eq(262, 25, new Cut().getMaximum(new int[] {50, 50, 50, 50, 50}, 20));
ExampleRunner.eq(
263, 2, new Cut().getMaximum(new int[] {30, 50, 60, 50, 40, 20, 40, 30, 60, 80}, 1));
ExampleRunner.eq(264, 2, new Cut().getMaximum(new int[] {13, 23, 20}, 1));
ExampleRunner.eq(265, 9, new Cut().getMaximum(new int[] {60, 20, 20, 20, 20}, 5));
ExampleRunner.eq(266, 6, new Cut().getMaximum(new int[] {30, 20, 20, 17, 10}, 3));
ExampleRunner.eq(267, 5, new Cut().getMaximum(new int[] {15, 20, 30}, 3));
ExampleRunner.eq(268, 5, new Cut().getMaximum(new int[] {60, 30, 20}, 3));
ExampleRunner.eq(269, 3, new Cut().getMaximum(new int[] {73, 20}, 2));
ExampleRunner.eq(270, 5, new Cut().getMaximum(new int[] {20, 30, 50}, 3));
ExampleRunner.eq(271, 7, new Cut().getMaximum(new int[] {100, 105}, 7));
ExampleRunner.eq(272, 1, new Cut().getMaximum(new int[] {34}, 1));
ExampleRunner.eq(273, 10, new Cut().getMaximum(new int[] {99, 100, 999}, 9));
ExampleRunner.eq(274, 3, new Cut().getMaximum(new int[] {15, 15, 30}, 2));
ExampleRunner.eq(275, 2, new Cut().getMaximum(new int[] {20, 21}, 1));
ExampleRunner.eq(276, 9, new Cut().getMaximum(new int[] {70, 30, 30, 30, 30}, 6));
ExampleRunner.eq(277, 5, new Cut().getMaximum(new int[] {35, 30, 10, 10}, 2));
ExampleRunner.eq(278, 1, new Cut().getMaximum(new int[] {40}, 1));
ExampleRunner.eq(279, 7, new Cut().getMaximum(new int[] {30, 50, 40, 50}, 5));
ExampleRunner.eq(280, 7, new Cut().getMaximum(new int[] {20, 20, 30, 30}, 4));
ExampleRunner.eq(
281,
9,
new Cut()
.getMaximum(new int[] {19, 20, 23, 25, 72, 51, 40, 30, 20, 16, 10, 12, 13, 14}, 5));
ExampleRunner.eq(282, 2, new Cut().getMaximum(new int[] {13, 20, 33}, 1));
ExampleRunner.eq(283, 3, new Cut().getMaximum(new int[] {100}, 3));
ExampleRunner.eq(284, 11, new Cut().getMaximum(new int[] {70, 80, 20, 20, 20, 40, 20, 30}, 6));
ExampleRunner.eq(285, 7, new Cut().getMaximum(new int[] {13, 13, 13, 30, 40}, 5));
ExampleRunner.eq(286, 6, new Cut().getMaximum(new int[] {1000, 10}, 5));
ExampleRunner.eq(287, 7, new Cut().getMaximum(new int[] {55, 50, 50, 50, 40, 30, 40}, 5));
ExampleRunner.eq(288, 10, new Cut().getMaximum(new int[] {11, 21, 31, 41, 51, 100}, 9));
ExampleRunner.eq(
289,
50,
new Cut()
.getMaximum(
new int[] {
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10
},
1000));
ExampleRunner.eq(290, 3, new Cut().getMaximum(new int[] {7, 74, 20}, 2));
ExampleRunner.eq(291, 6, new Cut().getMaximum(new int[] {40, 20, 20, 20, 20}, 3));
}
public static void main(String[] args) {
ExampleRunner.eq(
1, "1000", new MultiplesWithLimit().minMultiples(8, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
2,
"222...222(9 digits)",
new MultiplesWithLimit().minMultiples(9, new int[] {1, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(3, "3668", new MultiplesWithLimit().minMultiples(524, new int[] {5, 2, 4}));
ExampleRunner.eq(4, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(10000, new int[] {0}));
ExampleRunner.eq(
5,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(1, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
6,
"777...777(666 digits)",
new MultiplesWithLimit().minMultiples(2007, new int[] {1, 2, 3, 4, 5, 6, 8, 9, 0}));
ExampleRunner.eq(7, "400", new MultiplesWithLimit().minMultiples(100, new int[] {1, 2, 3}));
ExampleRunner.eq(8, "200", new MultiplesWithLimit().minMultiples(200, new int[] {3, 4, 5}));
ExampleRunner.eq(
9, "99992", new MultiplesWithLimit().minMultiples(862, new int[] {1, 4, 6, 7, 8}));
ExampleRunner.eq(
10, "2332888", new MultiplesWithLimit().minMultiples(7048, new int[] {1, 4, 5, 6, 7, 9}));
ExampleRunner.eq(
11,
"9199499",
new MultiplesWithLimit().minMultiples(4261, new int[] {0, 2, 3, 5, 6, 7, 8}));
ExampleRunner.eq(
12, "96138", new MultiplesWithLimit().minMultiples(6867, new int[] {0, 4, 5, 7}));
ExampleRunner.eq(
13, "6479697", new MultiplesWithLimit().minMultiples(9543, new int[] {0, 1, 2, 3, 5, 8}));
ExampleRunner.eq(
14, "44046", new MultiplesWithLimit().minMultiples(7341, new int[] {1, 2, 3, 5, 7, 9}));
ExampleRunner.eq(
15, "21024", new MultiplesWithLimit().minMultiples(7008, new int[] {3, 5, 6, 7, 8}));
ExampleRunner.eq(
16, "337312", new MultiplesWithLimit().minMultiples(4064, new int[] {0, 4, 5, 6, 8, 9}));
ExampleRunner.eq(17, "10388", new MultiplesWithLimit().minMultiples(5194, new int[] {4, 5, 7}));
ExampleRunner.eq(
18, "387030", new MultiplesWithLimit().minMultiples(4074, new int[] {1, 2, 4, 5, 6}));
ExampleRunner.eq(
19,
"444...404(14 digits)",
new MultiplesWithLimit().minMultiples(8794, new int[] {1, 2, 3, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
20, "466704", new MultiplesWithLimit().minMultiples(9723, new int[] {1, 2, 3, 8, 9}));
ExampleRunner.eq(
21, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(1940, new int[] {0, 3, 4, 8, 9}));
ExampleRunner.eq(
22, "20600", new MultiplesWithLimit().minMultiples(824, new int[] {1, 3, 4, 8, 9}));
ExampleRunner.eq(23, "19598", new MultiplesWithLimit().minMultiples(9799, new int[] {4, 7}));
ExampleRunner.eq(
24, "700050", new MultiplesWithLimit().minMultiples(9334, new int[] {1, 2, 3, 6, 8}));
ExampleRunner.eq(
25, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(5310, new int[] {0, 1, 4, 6, 9}));
ExampleRunner.eq(
26, "11556", new MultiplesWithLimit().minMultiples(1926, new int[] {2, 4, 8, 9}));
ExampleRunner.eq(
27, "2421", new MultiplesWithLimit().minMultiples(2421, new int[] {0, 6, 8, 9}));
ExampleRunner.eq(
28, "6876", new MultiplesWithLimit().minMultiples(1719, new int[] {0, 1, 2, 4}));
ExampleRunner.eq(29, "7556", new MultiplesWithLimit().minMultiples(3778, new int[] {2, 3, 8}));
ExampleRunner.eq(
30, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(4990, new int[] {0, 3, 8, 9}));
ExampleRunner.eq(
31,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(5570, new int[] {0, 3, 4, 7, 8, 9}));
ExampleRunner.eq(
32,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(5334, new int[] {0, 1, 2, 4, 6, 7, 8, 9}));
ExampleRunner.eq(
33, "78272", new MultiplesWithLimit().minMultiples(4892, new int[] {0, 3, 4, 9}));
ExampleRunner.eq(34, "17424", new MultiplesWithLimit().minMultiples(8712, new int[] {0, 8, 9}));
ExampleRunner.eq(
35, "115560", new MultiplesWithLimit().minMultiples(2568, new int[] {2, 3, 4, 8, 9}));
ExampleRunner.eq(
36, "24024", new MultiplesWithLimit().minMultiples(3432, new int[] {1, 3, 5, 8}));
ExampleRunner.eq(
37,
"777...777(9 digits)",
new MultiplesWithLimit().minMultiples(2821, new int[] {1, 2, 3, 4, 5, 6, 8, 9}));
ExampleRunner.eq(38, "67779", new MultiplesWithLimit().minMultiples(7531, new int[] {0, 3, 5}));
ExampleRunner.eq(
39, "11410", new MultiplesWithLimit().minMultiples(1630, new int[] {2, 5, 6, 7, 9}));
ExampleRunner.eq(
40, "4433", new MultiplesWithLimit().minMultiples(4433, new int[] {1, 2, 5, 7, 8, 9}));
ExampleRunner.eq(
41, "7272", new MultiplesWithLimit().minMultiples(1818, new int[] {0, 4, 6, 8}));
ExampleRunner.eq(
42, "80873", new MultiplesWithLimit().minMultiples(6221, new int[] {1, 4, 5, 6}));
ExampleRunner.eq(43, "7032", new MultiplesWithLimit().minMultiples(3516, new int[] {1, 9}));
ExampleRunner.eq(
44, "101080", new MultiplesWithLimit().minMultiples(7220, new int[] {2, 3, 4, 5, 9}));
ExampleRunner.eq(
45, "22767207", new MultiplesWithLimit().minMultiples(9327, new int[] {1, 3, 4, 5, 8, 9}));
ExampleRunner.eq(
46, "18429", new MultiplesWithLimit().minMultiples(6143, new int[] {0, 3, 5, 6, 7}));
ExampleRunner.eq(
47, "304", new MultiplesWithLimit().minMultiples(76, new int[] {1, 6, 7, 8, 9}));
ExampleRunner.eq(
48, "20208", new MultiplesWithLimit().minMultiples(5052, new int[] {1, 3, 5, 6}));
ExampleRunner.eq(
49,
"22977972",
new MultiplesWithLimit().minMultiples(2818, new int[] {0, 1, 3, 4, 5, 6, 8}));
ExampleRunner.eq(
50,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(4910, new int[] {0, 3, 4, 5, 7, 8, 9}));
ExampleRunner.eq(
51, "3336", new MultiplesWithLimit().minMultiples(3336, new int[] {0, 1, 7, 8, 9}));
ExampleRunner.eq(
52, "2494", new MultiplesWithLimit().minMultiples(1247, new int[] {3, 5, 7, 8}));
ExampleRunner.eq(
53, "79948", new MultiplesWithLimit().minMultiples(7268, new int[] {0, 2, 3, 5}));
ExampleRunner.eq(
54, "5166716", new MultiplesWithLimit().minMultiples(2102, new int[] {0, 2, 3, 4, 8, 9}));
ExampleRunner.eq(55, "7664", new MultiplesWithLimit().minMultiples(7664, new int[] {0, 1, 9}));
ExampleRunner.eq(
56, "404888", new MultiplesWithLimit().minMultiples(9416, new int[] {2, 6, 7}));
ExampleRunner.eq(
57, "26442", new MultiplesWithLimit().minMultiples(2034, new int[] {0, 1, 3, 5, 7, 8}));
ExampleRunner.eq(
58,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(8490, new int[] {0, 2, 3, 7, 8, 9}));
ExampleRunner.eq(
59, "23388", new MultiplesWithLimit().minMultiples(1949, new int[] {0, 1, 5, 6, 7, 9}));
ExampleRunner.eq(
60,
"500...005(12 digits)",
new MultiplesWithLimit().minMultiples(3845, new int[] {1, 2, 3, 4, 6, 7, 8, 9}));
ExampleRunner.eq(61, "7262", new MultiplesWithLimit().minMultiples(7262, new int[] {5}));
ExampleRunner.eq(
62, "342545", new MultiplesWithLimit().minMultiples(9787, new int[] {1, 6, 7, 8}));
ExampleRunner.eq(
63, "2524", new MultiplesWithLimit().minMultiples(631, new int[] {0, 1, 3, 6, 8, 9}));
ExampleRunner.eq(
64, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(2660, new int[] {0, 5, 7, 8}));
ExampleRunner.eq(
65, "19694", new MultiplesWithLimit().minMultiples(9847, new int[] {0, 2, 7, 8}));
ExampleRunner.eq(
66, "5122", new MultiplesWithLimit().minMultiples(2561, new int[] {4, 6, 7, 9}));
ExampleRunner.eq(
67,
"33393393",
new MultiplesWithLimit().minMultiples(7011, new int[] {0, 1, 2, 4, 5, 6, 7}));
ExampleRunner.eq(
68, "494445", new MultiplesWithLimit().minMultiples(4155, new int[] {0, 1, 2, 6, 7, 8}));
ExampleRunner.eq(
69, "112822", new MultiplesWithLimit().minMultiples(2969, new int[] {3, 4, 5, 6, 9}));
ExampleRunner.eq(
70, "354855", new MultiplesWithLimit().minMultiples(8655, new int[] {0, 2, 6, 7, 9}));
ExampleRunner.eq(
71, "101166", new MultiplesWithLimit().minMultiples(7782, new int[] {3, 4, 5, 8, 9}));
ExampleRunner.eq(
72, "589944", new MultiplesWithLimit().minMultiples(1569, new int[] {0, 1, 2, 3, 6, 7}));
ExampleRunner.eq(
73, "9112", new MultiplesWithLimit().minMultiples(268, new int[] {3, 4, 5, 6, 7, 8}));
ExampleRunner.eq(
74, "6669160", new MultiplesWithLimit().minMultiples(9736, new int[] {2, 3, 4, 5, 7, 8}));
ExampleRunner.eq(
75, "686", new MultiplesWithLimit().minMultiples(686, new int[] {1, 2, 3, 4, 5, 7}));
ExampleRunner.eq(76, "788", new MultiplesWithLimit().minMultiples(197, new int[] {1, 2, 3}));
ExampleRunner.eq(
77, "680068", new MultiplesWithLimit().minMultiples(9316, new int[] {2, 3, 4, 7, 9}));
ExampleRunner.eq(
78, "67522", new MultiplesWithLimit().minMultiples(9646, new int[] {1, 4, 8, 9}));
ExampleRunner.eq(
79,
"3133188",
new MultiplesWithLimit().minMultiples(1809, new int[] {0, 2, 4, 5, 6, 7, 9}));
ExampleRunner.eq(80, "3504", new MultiplesWithLimit().minMultiples(1752, new int[] {1, 7, 8}));
ExampleRunner.eq(
81, "1371766", new MultiplesWithLimit().minMultiples(5422, new int[] {0, 2, 4, 5, 8, 9}));
ExampleRunner.eq(
82, "670677", new MultiplesWithLimit().minMultiples(2289, new int[] {1, 2, 4, 5, 8, 9}));
ExampleRunner.eq(
83, "5652", new MultiplesWithLimit().minMultiples(471, new int[] {0, 3, 4, 7, 8}));
ExampleRunner.eq(84, "2166", new MultiplesWithLimit().minMultiples(1083, new int[] {4, 7, 8}));
ExampleRunner.eq(
85, "180208", new MultiplesWithLimit().minMultiples(6436, new int[] {3, 4, 5, 6, 7}));
ExampleRunner.eq(
86,
"4555554",
new MultiplesWithLimit().minMultiples(5073, new int[] {0, 1, 2, 3, 6, 7, 9}));
ExampleRunner.eq(
87, "4997", new MultiplesWithLimit().minMultiples(263, new int[] {0, 1, 2, 3, 6, 8}));
ExampleRunner.eq(
88, "185080", new MultiplesWithLimit().minMultiples(5288, new int[] {2, 3, 4, 6, 7, 9}));
ExampleRunner.eq(89, "4677", new MultiplesWithLimit().minMultiples(4677, new int[] {0, 1, 5}));
ExampleRunner.eq(
90, "3229332", new MultiplesWithLimit().minMultiples(8681, new int[] {0, 1, 4, 6, 7, 8}));
ExampleRunner.eq(
91, "30163", new MultiplesWithLimit().minMultiples(4309, new int[] {4, 5, 7, 8, 9}));
ExampleRunner.eq(
92,
"9112929",
new MultiplesWithLimit().minMultiples(1227, new int[] {0, 3, 4, 5, 6, 7, 8}));
ExampleRunner.eq(
93, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(8610, new int[] {0, 1, 3, 4, 9}));
ExampleRunner.eq(
94, "703970", new MultiplesWithLimit().minMultiples(3434, new int[] {1, 2, 4, 5, 6, 8}));
ExampleRunner.eq(
95, "9974", new MultiplesWithLimit().minMultiples(9974, new int[] {0, 1, 3, 5, 8}));
ExampleRunner.eq(96, "19130", new MultiplesWithLimit().minMultiples(9565, new int[] {2, 4, 5}));
ExampleRunner.eq(97, "3904", new MultiplesWithLimit().minMultiples(3904, new int[] {6, 8}));
ExampleRunner.eq(
98, "698688", new MultiplesWithLimit().minMultiples(9704, new int[] {1, 2, 4, 5, 7}));
ExampleRunner.eq(
99, "368368", new MultiplesWithLimit().minMultiples(4784, new int[] {0, 1, 2, 4, 9}));
ExampleRunner.eq(100, "4485", new MultiplesWithLimit().minMultiples(4485, new int[] {6, 9}));
ExampleRunner.eq(
101, "4774", new MultiplesWithLimit().minMultiples(4774, new int[] {3, 5, 6, 8}));
ExampleRunner.eq(
102,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(2060, new int[] {0, 1, 5, 6, 8, 9}));
ExampleRunner.eq(
103, "5520", new MultiplesWithLimit().minMultiples(1380, new int[] {1, 3, 4, 7, 8, 9}));
ExampleRunner.eq(
104, "17908", new MultiplesWithLimit().minMultiples(4477, new int[] {4, 5, 6}));
ExampleRunner.eq(
105,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(2115, new int[] {0, 1, 2, 3, 4, 5, 8, 9}));
ExampleRunner.eq(
106, "499149", new MultiplesWithLimit().minMultiples(8757, new int[] {2, 3, 6, 7, 8}));
ExampleRunner.eq(107, "4480", new MultiplesWithLimit().minMultiples(560, new int[] {2, 6, 9}));
ExampleRunner.eq(
108, "4454", new MultiplesWithLimit().minMultiples(262, new int[] {0, 1, 2, 3, 7, 8, 9}));
ExampleRunner.eq(
109,
"111...111(9972 digits)",
new MultiplesWithLimit().minMultiples(9981, new int[] {0, 2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
110,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(1, new int[] {9, 8, 7, 6, 5, 4, 3, 2, 1}));
ExampleRunner.eq(
111, "9", new MultiplesWithLimit().minMultiples(1, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}));
ExampleRunner.eq(112, "1", new MultiplesWithLimit().minMultiples(1, new int[] {}));
ExampleRunner.eq(113, "10", new MultiplesWithLimit().minMultiples(5, new int[] {5}));
ExampleRunner.eq(114, "12", new MultiplesWithLimit().minMultiples(4, new int[] {4, 8}));
ExampleRunner.eq(115, "12", new MultiplesWithLimit().minMultiples(3, new int[] {3, 6, 9}));
ExampleRunner.eq(116, "1000", new MultiplesWithLimit().minMultiples(8, new int[] {2, 4, 6, 8}));
ExampleRunner.eq(
117, "77778", new MultiplesWithLimit().minMultiples(9, new int[] {1, 2, 3, 4, 5, 6, 9}));
ExampleRunner.eq(
118,
"888...888(9 digits)",
new MultiplesWithLimit().minMultiples(9, new int[] {1, 2, 3, 4, 5, 6, 7, 9}));
ExampleRunner.eq(
119,
"888...888(9 digits)",
new MultiplesWithLimit().minMultiples(9, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 9}));
ExampleRunner.eq(120, "10000", new MultiplesWithLimit().minMultiples(10000, new int[] {}));
ExampleRunner.eq(121, "10000", new MultiplesWithLimit().minMultiples(625, new int[] {5}));
ExampleRunner.eq(122, "111888", new MultiplesWithLimit().minMultiples(999, new int[] {9}));
ExampleRunner.eq(123, "1007874", new MultiplesWithLimit().minMultiples(7999, new int[] {9}));
ExampleRunner.eq(124, "11118888", new MultiplesWithLimit().minMultiples(9999, new int[] {9}));
ExampleRunner.eq(125, "10374", new MultiplesWithLimit().minMultiples(399, new int[] {8, 9}));
ExampleRunner.eq(126, "111776", new MultiplesWithLimit().minMultiples(998, new int[] {8, 9}));
ExampleRunner.eq(127, "1011747", new MultiplesWithLimit().minMultiples(3999, new int[] {8, 9}));
ExampleRunner.eq(
128, "11117776", new MultiplesWithLimit().minMultiples(9998, new int[] {8, 9}));
ExampleRunner.eq(129, "11008", new MultiplesWithLimit().minMultiples(172, new int[] {2, 4, 6}));
ExampleRunner.eq(
130, "301788", new MultiplesWithLimit().minMultiples(996, new int[] {2, 4, 6}));
ExampleRunner.eq(
131, "1770888", new MultiplesWithLimit().minMultiples(1992, new int[] {2, 4, 6}));
ExampleRunner.eq(
132, "30017988", new MultiplesWithLimit().minMultiples(9996, new int[] {2, 4, 6}));
ExampleRunner.eq(
133,
"100...000(14 digits)",
new MultiplesWithLimit().minMultiples(8192, new int[] {2, 4, 6, 8}));
ExampleRunner.eq(
134,
"300...000(14 digits)",
new MultiplesWithLimit().minMultiples(8192, new int[] {1, 2, 4, 6, 8}));
ExampleRunner.eq(
135,
"500...000(14 digits)",
new MultiplesWithLimit().minMultiples(8192, new int[] {1, 2, 3, 4, 6, 8}));
ExampleRunner.eq(
136,
"111...000(18 digits)",
new MultiplesWithLimit().minMultiples(7992, new int[] {2, 3, 4, 6, 7, 8, 9}));
ExampleRunner.eq(
137,
"444...888(20 digits)",
new MultiplesWithLimit().minMultiples(9999, new int[] {1, 2, 3, 5, 6, 7, 9}));
ExampleRunner.eq(
138,
"777...000(30 digits)",
new MultiplesWithLimit().minMultiples(7992, new int[] {1, 2, 3, 4, 5, 6, 8, 9}));
ExampleRunner.eq(
139,
"888...888(36 digits)",
new MultiplesWithLimit().minMultiples(9999, new int[] {1, 2, 3, 4, 5, 6, 7, 9}));
ExampleRunner.eq(
140,
"888...888(9918 digits)",
new MultiplesWithLimit().minMultiples(9927, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 9}));
ExampleRunner.eq(
141,
"999...999(9930 digits)",
new MultiplesWithLimit().minMultiples(9931, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}));
ExampleRunner.eq(
142,
"999...999(9948 digits)",
new MultiplesWithLimit().minMultiples(9949, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}));
ExampleRunner.eq(
143,
"999...999(9966 digits)",
new MultiplesWithLimit().minMultiples(9967, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}));
ExampleRunner.eq(
144, "1000", new MultiplesWithLimit().minMultiples(8, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(145, "3668", new MultiplesWithLimit().minMultiples(524, new int[] {5, 2, 4}));
ExampleRunner.eq(146, "8", new MultiplesWithLimit().minMultiples(8, new int[] {}));
ExampleRunner.eq(
147,
"222...222(9 digits)",
new MultiplesWithLimit().minMultiples(9, new int[] {1, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
148, "70288", new MultiplesWithLimit().minMultiples(8786, new int[] {1, 3, 5, 6, 9}));
ExampleRunner.eq(
149,
"100...000(14 digits)",
new MultiplesWithLimit().minMultiples(8192, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(150, "1", new MultiplesWithLimit().minMultiples(1, new int[] {}));
ExampleRunner.eq(
151,
"777...777(10 digits)",
new MultiplesWithLimit().minMultiples(4433, new int[] {0, 2, 4, 6, 8, 9, 3, 5}));
ExampleRunner.eq(
152,
"111...111(36 digits)",
new MultiplesWithLimit().minMultiples(9999, new int[] {0, 2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
153,
"222...222(81 digits)",
new MultiplesWithLimit().minMultiples(81, new int[] {0, 1, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
154,
"200...202(13 digits)",
new MultiplesWithLimit().minMultiples(6561, new int[] {1, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
155,
"111...101(10 digits)",
new MultiplesWithLimit().minMultiples(81, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
156,
"111...111(192 digits)",
new MultiplesWithLimit().minMultiples(9997, new int[] {0, 2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
157,
"999...999(12 digits)",
new MultiplesWithLimit().minMultiples(2121, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}));
ExampleRunner.eq(
158,
"111...111(36 digits)",
new MultiplesWithLimit().minMultiples(9999, new int[] {2, 3, 4, 5, 6, 7, 8, 9, 0}));
ExampleRunner.eq(
159,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(1, new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
160,
"220...222(10 digits)",
new MultiplesWithLimit().minMultiples(27, new int[] {1, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
161,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(2, new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
162,
"IMPOSSIBLE",
new MultiplesWithLimit().minMultiples(2, new int[] {0, 2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(163, "9", new MultiplesWithLimit().minMultiples(9, new int[] {0}));
ExampleRunner.eq(164, "11118888", new MultiplesWithLimit().minMultiples(9999, new int[] {9}));
ExampleRunner.eq(
165,
"888...888(9 digits)",
new MultiplesWithLimit().minMultiples(9, new int[] {1, 2, 3, 4, 5, 6, 7, 9, 0}));
ExampleRunner.eq(166, "6561", new MultiplesWithLimit().minMultiples(6561, new int[] {7}));
ExampleRunner.eq(
167,
"444...444(36 digits)",
new MultiplesWithLimit().minMultiples(9999, new int[] {1, 2, 3, 5, 6, 7, 8, 9}));
ExampleRunner.eq(168, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(5, new int[] {0, 5}));
ExampleRunner.eq(
169, "999", new MultiplesWithLimit().minMultiples(999, new int[] {1, 2, 3, 4, 5, 6}));
ExampleRunner.eq(
170, "8", new MultiplesWithLimit().minMultiples(1, new int[] {0, 1, 2, 3, 4, 5, 6, 7}));
ExampleRunner.eq(
171, "IMPOSSIBLE", new MultiplesWithLimit().minMultiples(10000, new int[] {0}));
ExampleRunner.eq(
172,
"222...222(9 digits)",
new MultiplesWithLimit().minMultiples(9, new int[] {0, 1, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
173,
"222...222(18 digits)",
new MultiplesWithLimit().minMultiples(99, new int[] {0, 1, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
174,
"222...222(10 digits)",
new MultiplesWithLimit().minMultiples(9091, new int[] {1, 4, 5, 6, 7, 8, 9, 0}));
ExampleRunner.eq(
175,
"100...100(15 digits)",
new MultiplesWithLimit().minMultiples(9116, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
ExampleRunner.eq(
176,
"111...111(27 digits)",
new MultiplesWithLimit().minMultiples(999, new int[] {2, 3, 4, 5, 6, 7, 8, 9}));
}
public static void main(String[] args) {
ExampleRunner.eq(1, 2, new Mosquitoes().getMaximum(new int[] {1, -1}, new int[] {1, -1}, 10));
ExampleRunner.eq(
2, 1, new Mosquitoes().getMaximum(new int[] {100, -100}, new int[] {1, -1}, 10));
ExampleRunner.eq(
3,
4,
new Mosquitoes()
.getMaximum(new int[] {0, -1, 10, -11, 99, -99}, new int[] {1, -1, -3, 3, 47, -47}, 3));
ExampleRunner.eq(4, 1, new Mosquitoes().getMaximum(new int[] {5}, new int[] {2}, 8));
ExampleRunner.eq(
5,
3,
new Mosquitoes()
.getMaximum(new int[] {12, 34, 56, 78, 90}, new int[] {-1, 2, -3, 4, -5}, 6));
ExampleRunner.eq(6, 1, new Mosquitoes().getMaximum(new int[] {99}, new int[] {-88}, 1));
ExampleRunner.eq(7, 1, new Mosquitoes().getMaximum(new int[] {-100}, new int[] {100}, 100));
ExampleRunner.eq(
8, 2, new Mosquitoes().getMaximum(new int[] {100, -100}, new int[] {100, -100}, 100));
ExampleRunner.eq(
9, 1, new Mosquitoes().getMaximum(new int[] {100, 97}, new int[] {99, -100}, 1));
ExampleRunner.eq(
10, 1, new Mosquitoes().getMaximum(new int[] {-99, -96}, new int[] {-100, 100}, 1));
ExampleRunner.eq(
11, 2, new Mosquitoes().getMaximum(new int[] {2, -2}, new int[] {-100, 100}, 1));
ExampleRunner.eq(
12,
50,
new Mosquitoes()
.getMaximum(
new int[] {
-68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
-68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
-68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
-68, -68
},
new int[] {
-49, -47, -45, -43, -41, -39, -37, -35, -33, -31, -29, -27, -25, -23, -21, -19,
-17, -15, -13, -11, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23,
25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49
},
1));
ExampleRunner.eq(
13,
50,
new Mosquitoes()
.getMaximum(
new int[] {
100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100, 100, 100, 100, 100, 100, 100, 100, -100, -100, -100, -100, -100, -100,
-100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100,
-100, -100, -100, -100, -100, -100
},
new int[] {
1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81,
85, 89, 93, 97, -1, -5, -9, -13, -17, -21, -25, -29, -33, -37, -41, -45, -49, -53,
-57, -61, -65, -69, -73, -77, -81, -85, -89, -93, -97
},
100));
ExampleRunner.eq(
14,
25,
new Mosquitoes()
.getMaximum(
new int[] {
100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100, 100, 100, 100, 100, 100, 100, 100, -100, -100, -100, -100, -100, -100,
-100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100,
-100, -100, -100, -100, -100, -100
},
new int[] {
1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81,
85, 89, 93, 97, -1, -5, -9, -13, -17, -21, -25, -29, -33, -37, -41, -45, -49, -53,
-57, -61, -65, -69, -73, -77, -81, -85, -89, -93, -97
},
99));
ExampleRunner.eq(
15,
4,
new Mosquitoes()
.getMaximum(
new int[] {-34, -91, 29, -26, 92, -32, 56},
new int[] {2, 5, -90, -39, -4, 36, -2},
3));
ExampleRunner.eq(
16,
5,
new Mosquitoes()
.getMaximum(
new int[] {40, -46, -41, 83, 60, 16, 58, 49},
new int[] {44, 3, 2, -13, -3, -1, -15, -2},
7));
ExampleRunner.eq(
17,
6,
new Mosquitoes()
.getMaximum(
new int[] {6, -62, 56, -68, 88, -10, -54, 68, -29},
new int[] {34, -35, -3, 3, -6, 0, -78, -5, 2},
11));
ExampleRunner.eq(18, 1, new Mosquitoes().getMaximum(new int[] {-33}, new int[] {45}, 4));
ExampleRunner.eq(
19, 2, new Mosquitoes().getMaximum(new int[] {-29, -27}, new int[] {25, 61}, 7));
ExampleRunner.eq(
20, 3, new Mosquitoes().getMaximum(new int[] {50, -90, -24}, new int[] {-57, 68, 8}, 5));
ExampleRunner.eq(
21,
2,
new Mosquitoes().getMaximum(new int[] {87, 31, 54, -71}, new int[] {57, -41, 66, 75}, 4));
ExampleRunner.eq(
22,
2,
new Mosquitoes()
.getMaximum(new int[] {-97, -41, 21, 97, -2}, new int[] {24, -40, 72, -95, 42}, 8));
ExampleRunner.eq(
23,
3,
new Mosquitoes()
.getMaximum(
new int[] {78, 79, -25, 42, -20, -70, -79, 52, -98, 19},
new int[] {85, -3, -36, -54, -96, 66, 27, 72, -11, -40},
10));
ExampleRunner.eq(
24,
4,
new Mosquitoes()
.getMaximum(
new int[] {
-22, 47, 78, 79, 10, 50, -74, 92, -16, 6, -7, -9, 91, -31, 74, -34, 56, -23, -47,
-59
},
new int[] {
15, -76, -33, 69, 61, -86, -27, 85, -85, -50, 59, -18, 5, 23, 44, -63, -59, 45,
-11, -25
},
5));
ExampleRunner.eq(
25,
6,
new Mosquitoes()
.getMaximum(
new int[] {
-52, -48, -21, 36, -28, -75, 79, 39, 100, -42, 26, 42, 62, 100, 37, -40, -19, 77,
99, -32, -55, 99, 17, 50, 32, 12, 7, 40, 11, 23
},
new int[] {
23, 18, -20, 3, -17, -67, 41, -65, 86, -24, 81, 66, -94, -89, 10, 46, -55, -46,
-16, 31, 43, -19, -76, 37, -38, -60, -75, 62, 54, 78
},
4));
ExampleRunner.eq(
26,
9,
new Mosquitoes()
.getMaximum(
new int[] {
-85, -33, 17, -45, 73, -9, -75, -55, 97, -15, 29, -32, -70, -20, -38, -87, -70,
-69, 74, -9, -48, 29, 40, -93, 9, -59, 32, 73, -30, 97, -65, -7, 32, 45, -65, -58,
84, 46, 48, 62
},
new int[] {
26, -81, -62, 47, 65, 25, 73, 82, 71, 57, 19, 96, -6, -58, 34, -10, -96, -13, -35,
-25, 95, -23, 32, 76, 59, 70, -70, 30, -100, 66, 37, 11, -84, -9, -4, 75, -36, 14,
-68, 45
},
9));
ExampleRunner.eq(
27,
11,
new Mosquitoes()
.getMaximum(
new int[] {
29, -20, 77, -30, -16, -27, 10, -18, -61, 20, 75, 98, 60, 22, -38, 32, 44, 83,
-29, 79, 66, 91, 74, 55, -44, -73, -65, 66, -73, 73, -64, 21, 56, 68, 21, 93, 68,
70, 73, -3, -77, 58, -13, -64, 50, 61, 63, -55, 90, 96
},
new int[] {
85, -53, -37, -78, -84, 55, -95, 23, 71, -91, -24, 0, -23, 99, 24, 33, -100, 69,
31, -85, 28, -98, 27, 8, -19, 34, -58, -75, -74, -11, 43, 88, -31, 58, -59, -66,
50, -13, 4, -71, -36, -29, 26, -62, -38, -80, -49, 46, 44, 12
},
7));
ExampleRunner.eq(
28,
6,
new Mosquitoes()
.getMaximum(
new int[] {
-80, -63, 35, -15, -99, -40, 39, -51, -8, -84, 16, 28, -26, -18, -2, 48, 12, -62,
68, -73
},
new int[] {
-94, 88, 31, -13, -69, 82, 67, -81, 21, 47, 8, -31, -99, -22, -4, 33, 50, -70, 98,
-41
},
18));
ExampleRunner.eq(
29,
15,
new Mosquitoes()
.getMaximum(
new int[] {
32, -36, -66, -16, 6, 90, 62, 20, -75, 80, -73, 9, 40, -63, -29, -78, 25, -69, 5,
-98, 97, -29, 30
},
new int[] {
17, 68, -19, -31, -67, -88, -17, -41, 98, 20, 12, 52, -75, 5, -18, -4, 26, -1, 66,
21, -33, 79, -80
},
50));
ExampleRunner.eq(
30,
15,
new Mosquitoes()
.getMaximum(
new int[] {
-66, -53, -50, -63, -81, 14, 65, 78, -72, -33, -74, -45, 19, -92, 84, -48, -81,
-23, 88, -42, 3, -3, 93, -59, 15, 67
},
new int[] {
14, 78, 43, 95, 2, -16, -58, 18, 41, 59, -69, 27, -28, 91, -64, -94, 52, -9, -67,
98, -59, 94, 67, 20, 93, -19
},
34));
ExampleRunner.eq(
31,
15,
new Mosquitoes()
.getMaximum(
new int[] {
34, 93, 43, 69, 93, 15, 54, -73, 43, 33, -56, 31, 43, 58, 35, 96, 94, -31, -16,
98, 64, 87, 74, -11, -21, 83, -11, 100, -47
},
new int[] {
99, -16, 82, 89, 60, -99, 65, 57, -68, -80, -42, -94, 27, -75, -38, 86, 23, 67,
20, 13, 10, -8, -93, -91, 63, -22, 70, -61, -57
},
28));
ExampleRunner.eq(
32,
18,
new Mosquitoes()
.getMaximum(
new int[] {
-67, -17, -86, 36, -17, -49, 7, -46, -93, 63, -79, -54, -33, 26, 61, 84, -56, 52,
87, 82, 93, -41, 99, -28, -19, 69, 16, 79, 66, 23, 58, 1
},
new int[] {
62, 70, 87, 73, -3, 44, 1, 92, -81, 32, -93, 25, 82, 6, 72, 37, 0, -55, -35, -27,
-21, 99, -83, 100, -62, 11, 95, 24, -24, 71, -77, 53
},
35));
ExampleRunner.eq(
33,
19,
new Mosquitoes()
.getMaximum(
new int[] {
34, -13, -52, -83, -21, 97, -68, 26, -59, 96, 67, -5, 56, 40, 52, 66, 99, 99, -95,
57, 33, -73, -1, 77, -80, -67, 73, -91, 45, 46, 96, 54, -93, -57, 18
},
new int[] {
19, -65, -52, 63, 67, 72, -72, 77, -45, -18, -46, -29, 31, -33, 12, 99, 16, -62,
18, 39, -11, -54, -32, 54, -87, 71, 37, -8, -88, 0, -17, 20, -82, -28, 36
},
38));
ExampleRunner.eq(
34,
17,
new Mosquitoes()
.getMaximum(
new int[] {
-46, 76, 57, -28, -68, -43, -37, 44, -21, -95, -18, -5, -99, 99, 79, -96, 90, -29,
0, -92, 18, 63, -86, 98, -100, 1, -47, 55, 38, -97, -35, 48, 51, 74, 45, 10, 15,
76
},
new int[] {
63, -68, 58, 77, 20, 11, -69, -94, -53, 35, 7, 60, -24, 8, -61, 21, 95, 59, 74,
100, -78, 53, 14, -75, -30, -80, 80, -74, 67, -25, 19, 76, 28, -1, 90, 51, 31, 25
},
38));
ExampleRunner.eq(
35,
11,
new Mosquitoes()
.getMaximum(
new int[] {
32, -55, 19, 39, 71, -57, -32, -46, -30, 32, -18, 11, -91, -56, 71, 55, -99, -67,
64, -40, -99, -28, 16, -80, -96, -44, 96, -89, -51, -5, 71, 36, -66, 33, 82, -57,
66, 93, 72, -67, -90
},
new int[] {
26, -17, 82, 90, 27, 62, -32, -92, 67, -5, -73, 92, 13, 11, 64, -33, -97, 94, 6,
-43, 96, 57, -83, -59, 17, 76, -60, 71, -48, -61, 60, 78, 55, -45, 7, -12, -69,
16, 65, -38, 12
},
15));
ExampleRunner.eq(
36,
25,
new Mosquitoes()
.getMaximum(
new int[] {
85, -3, 96, -60, 84, 82, 17, 92, 33, 41, 57, -85, 79, -34, -81, 26, -17, -39, 54,
-58, -59, -48, -13, 12, -6, 49, 46, 26, -44, -40, 73, -58, -36, 1, -98, -42, 100,
-39, -100, -38, -17, -73, -76, 10
},
new int[] {
-32, 64, 37, -79, -80, -49, 9, 94, 46, 8, 35, 95, 90, -50, 71, 19, -55, -20, -96,
84, -71, -24, -30, 2, 10, 38, -41, 31, -66, 82, 25, 50, 79, 52, -18, 65, -23, 45,
87, 67, -39, 5, -92, -54
},
46));
ExampleRunner.eq(
37,
28,
new Mosquitoes()
.getMaximum(
new int[] {
-5, 44, -50, 6, -23, 59, -75, -82, -77, 34, 7, -4, -97, 40, 15, -30, -86, -45, 85,
-87, -60, 56, -72, -9, -81, 98, -58, -94, 99, -89, -43, 36, 61, 30, 99, 46, 59,
-61, -85, 9, -94, -66, -82, 36, -17, -72, 62
},
new int[] {
53, 95, 65, -27, -10, -19, 78, 76, 2, -48, 5, -29, -95, 41, 64, -49, -11, -59, 55,
-38, -37, 35, 40, 30, 11, 98, -34, 71, 39, 50, 29, -1, -20, -3, 10, 17, 31, 59,
-50, -81, 21, -23, -14, -16, 4, -88, -61
},
49));
ExampleRunner.eq(
38,
29,
new Mosquitoes()
.getMaximum(
new int[] {
-74, 68, 75, -99, -32, 33, 45, 37, -90, -9, 98, -7, 58, -67, -25, 95, -10, -29,
64, -18, -14, -22, 91, -88, -93, -70, 75, -87, 58, -56, -63, -92, 32, -84, 17,
-38, -5, -96, -86, 31, -42, -79, -8, 100, 50, 31, -25, -18, 81, -70
},
new int[] {
-79, 25, 89, 46, -58, 51, 73, -17, 90, 86, 13, -43, -71, -87, 79, -83, -37, 35,
58, 21, 24, 67, 62, -70, -7, 71, 77, 99, 54, 22, -48, 88, -88, -21, -15, -61, 68,
17, -9, -76, 31, 6, -38, 94, 78, 74, -52, -5, -74, -55
},
42));
ExampleRunner.eq(
39,
5,
new Mosquitoes()
.getMaximum(
new int[] {
-88, 47, 100, 57, 36, 61, -72, -38, 29, 96, 84, -34, 17, -79, 68, 83, -92, -39,
55, -18, 87, -94, 31, -5, -59, 95, -1, -99, 97, 15, -86, 13, -53, -54, 90, -51,
-58, -35, -92, 6, -57, 97, 41, 15, 99, 86, -5, -73, -59, -59
},
new int[] {
94, -95, 60, -14, -29, 48, -100, 64, -6, -71, 33, -13, 83, 27, 87, 49, -85, 91,
90, 65, -55, -64, -25, -26, -68, 2, -97, 26, -41, -51, -42, -21, 85, 43, 76, 77,
12, -79, 71, -83, -67, 73, 84, 51, 22, -2, 79, -86, 66, 47
},
1));
ExampleRunner.eq(
40,
9,
new Mosquitoes()
.getMaximum(
new int[] {
-5, -62, -15, -60, 94, 68, -8, -69, -83, -20, -47, -94, 17, -75, -18, 85, 51, 50,
-36, -100, -54, -13, 100, 61, -60, -3, -58, 0, 14, -80, 43, -82, 52, -27, -76, 78,
-81, 85, 46, -3, 22, -6, 93, -98, 15, -55, -90, 50, -30, 61
},
new int[] {
-56, -84, -35, -90, 68, -43, 29, 70, -23, -70, 67, -39, -11, 8, -55, 30, 83, -64,
-59, -44, 42, 47, 20, -33, -69, 46, -51, 86, 63, 23, -2, -8, 28, -10, -42, -46,
40, -4, -22, 19, -14, 80, 44, 79, 93, -91, 96, 22, 76, -88
},
5));
ExampleRunner.eq(
41,
10,
new Mosquitoes()
.getMaximum(
new int[] {
-88, -34, 100, -46, -25, -47, 92, 38, 60, 62, 6, -77, 68, 60, -51, 46, 91, -5, 11,
-7, -84, -89, 66, -31, 57, -77, 40, 38, 60, 34, -13, -88, -99, -85, 29, -73, -54,
70, -99, -87, 15, 15, 44, -35, -51, 32, 21, 4, 93, 45
},
new int[] {
-75, -66, -73, -56, 17, 71, -43, -84, -69, -80, -6, 6, 30, 29, 70, 51, -60, 87,
79, -85, 58, 4, -65, -34, 9, 55, 35, 61, -54, -86, 18, 81, -36, -90, 8, -13, 74,
97, -18, -4, 75, 43, -32, -3, -27, -82, 3, 21, -33, -63
},
9));
ExampleRunner.eq(
42,
14,
new Mosquitoes()
.getMaximum(
new int[] {
-88, -56, -63, 21, 19, 96, -63, 14, 83, 94, -31, 13, -82, 100, -98, -62, 21, 72,
-23, 31, 50, 37, -50, -28, 39, -38, -17, 66, 63, 31, -51, 33, -67, 93, -70, -50,
62, 97, 14, -48, -79, 56, 90, 31, 7, -94, -60, -95, -50, -12
},
new int[] {
50, -96, 37, 89, -1, 41, 33, -5, 71, -94, -36, -75, -56, 32, 29, 40, 36, -18, 74,
5, 22, 30, -66, 24, -17, -7, -27, -42, 2, -26, 20, 14, 88, -93, -40, -53, -61,
-98, 98, 11, 39, -58, -47, -15, -28, -25, -72, 62, 92, 97
},
13));
ExampleRunner.eq(
43,
16,
new Mosquitoes()
.getMaximum(
new int[] {
-27, 48, 62, -49, -91, -87, 48, -2, -57, 97, -20, 75, -32, -83, 19, 71, 37, 27,
-29, -54, -55, -72, 4, -75, 41, 74, -15, 35, -45, 50, -11, 36, 66, -79, 14, -69,
-54, 27, 28, 46, 11, 100, 99, -32, 52, -17, 62, -2, 0, 62
},
new int[] {
34, -89, -15, -70, 16, 64, -22, 0, -18, -14, 28, 61, 29, -39, 92, 43, -91, -13,
49, -32, 39, 40, -24, -55, 36, 44, 53, -56, 15, 6, -25, -80, 47, 38, -46, -31, 69,
65, 81, 88, -97, -19, -57, 68, 27, 91, -90, -17, 51, 42
},
17));
ExampleRunner.eq(
44,
17,
new Mosquitoes()
.getMaximum(
new int[] {
48, -22, -5, 62, 80, 5, -14, 52, -84, 37, -64, 74, -26, -96, 89, 54, -36, -7, 100,
85, -59, 62, 88, 100, 33, 91, -37, -92, -10, 31, -84, 57, -21, 1, 43, -76, -28,
43, 48, -34, 87, 62, 37, -87, 3, -35, -67, 16, -98, -35
},
new int[] {
76, -20, -44, -46, 85, -90, 99, 68, -100, -16, -48, -99, -41, -52, 82, -65, -43,
-50, 97, 60, -72, -79, 37, 89, -35, -82, -73, -97, 9, -11, 34, 19, -7, 30, -83,
27, 62, -69, -27, 11, 48, -95, -1, 33, -31, 75, 22, 96, 51, 21
},
21));
ExampleRunner.eq(
45,
18,
new Mosquitoes()
.getMaximum(
new int[] {
54, 88, 20, -42, -34, -49, -74, 84, -17, 35, -4, 87, -80, 9, 20, -12, -79, -40,
-8, -41, 76, 79, 38, 98, 14, 2, -26, 20, 85, 42, 87, -30, -52, -62, -23, -93, 65,
22, -36, 68, -39, 88, 40, -15, 17, -16, 65, -49, 3, 45
},
new int[] {
76, 82, -22, -58, 36, -27, 27, -91, -67, -45, -19, 5, 81, -50, 63, -99, -23, 44,
-47, -69, -97, 85, 72, -37, -24, -2, 58, -84, -7, 16, 83, -49, -75, -76, -74, 49,
67, 95, -8, -88, -66, 80, 92, -44, 68, 59, 28, -43, 57, -87
},
25));
ExampleRunner.eq(
46,
20,
new Mosquitoes()
.getMaximum(
new int[] {
100, -37, 92, -98, -58, 33, -72, -24, 88, 72, -14, -49, -56, 90, 77, -76, -94, 6,
53, -70, -86, 90, -81, 91, -50, -32, 60, 76, 52, 11, -13, 69, -29, -74, 8, -39,
-65, -63, 48, 63, -14, 73, -46, 35, -93, -52, -81, 32, -34, 77
},
new int[] {
99, 100, 18, 51, -11, -71, -66, -61, 59, 15, 36, -22, 54, -28, 80, -78, 70, 65,
84, -41, -95, 67, -5, 58, 83, 19, 21, 76, -10, -15, -18, 9, -68, 81, -44, 69, -98,
2, 38, 4, 52, -27, -9, -52, -20, 39, 97, 85, 35, 79
},
29));
ExampleRunner.eq(
47,
23,
new Mosquitoes()
.getMaximum(
new int[] {
71, 81, 39, 0, 46, -54, -58, 11, -46, 12, 24, 15, -11, 20, -78, -72, -32, 54, 44,
-46, -90, -89, -53, 85, 86, -90, 10, 20, 92, 80, -68, -32, 57, -37, -35, -9, -71,
-86, -69, 57, 73, -24, 22, -94, 77, 17, -18, -3, 30, -95
},
new int[] {
44, -24, -32, 92, -61, 99, -8, 27, 47, 38, 54, -4, -38, 32, -28, 79, 24, -45, -78,
-99, 17, -51, -100, -70, 52, -25, -59, 87, -73, -56, -87, 90, 78, 14, 49, -55, 39,
-14, -83, -57, 70, -42, -1, 33, -7, -84, 60, -29, -27, -35
},
33));
ExampleRunner.eq(
48,
28,
new Mosquitoes()
.getMaximum(
new int[] {
83, 99, -33, -35, -68, -51, 72, 30, 60, -97, 48, 3, 46, 100, -18, -80, -24, -1,
-44, -75, -15, 75, 16, -25, -87, -81, -25, -78, -68, -79, -43, 64, -92, -93, -43,
-62, 37, -84, 41, 56, 92, -79, -13, 34, 93, 35, -90, -34, -89, -3
},
new int[] {
13, -27, 84, 17, 57, 98, -48, -71, -53, 63, 51, -40, 85, 11, -57, -87, 45, -82,
-2, -8, -63, -33, 5, 2, -42, -21, 27, 74, -59, -49, 4, 71, -12, 29, 75, 59, -36,
-13, -92, 76, 28, 65, -46, -100, -14, 100, 25, 50, 9, -9
},
37));
ExampleRunner.eq(
49,
39,
new Mosquitoes()
.getMaximum(
new int[] {
-4, 39, 78, 23, 98, 51, 60, 89, -72, -77, -48, -86, -44, -88, 38, 69, 16, -2, -97,
45, -43, 45, -63, -92, -82, 48, -32, -1, -96, 41, 74, 37, -50, -37, -85, -39, 9,
-89, 3, 89, -76, -23, -20, 43, -84, -12, 28, -67, -57, 83
},
new int[] {
29, -20, 89, -23, -43, 83, -42, -60, -93, 27, 4, -99, -66, 41, -7, -58, 100, -44,
69, 96, 2, 80, 77, 22, 45, 68, 85, 91, -8, 36, -4, -3, -2, -16, -79, 33, 11, -25,
-52, 28, 60, 42, -50, -51, -41, 18, -71, 14, -9, 59
},
70));
ExampleRunner.eq(
50,
46,
new Mosquitoes()
.getMaximum(
new int[] {
-93, -57, 42, 11, -39, 66, 10, -88, -57, 21, -9, -80, -98, 52, -54, -88, -41, 59,
-34, -69, 32, -11, -53, -39, -41, 9, 68, 94, 8, 72, -70, -20, 71, 86, -23, 36,
-11, 23, 2, 59, 45, 21, -35, -13, -22, 15, -42, 17, 8, -40
},
new int[] {
-12, 78, 42, -57, 73, -72, 6, 31, 75, 21, -70, -80, 51, 0, 18, 96, 50, 59, 36, 27,
58, 52, 32, 67, -21, -65, 47, -63, -76, 72, -44, 48, -8, 93, 41, -59, -24, -86,
-23, 64, 99, 40, 76, -5, -38, -16, -55, -31, -53, 34
},
80));
ExampleRunner.eq(
51,
46,
new Mosquitoes()
.getMaximum(
new int[] {
-3, 39, -34, -83, 67, 41, -97, 56, 67, -94, -90, -10, 100, 2, 3, -95, 61, -95, 65,
66, 21, -28, -62, 99, -10, -35, 98, -86, 46, -11, 62, 28, 57, 99, 25, 0, -24, -79,
70, -89, -36, -71, -86, 7, 67, -52, 80, -69, -4, -58
},
new int[] {
-36, 54, 69, -78, 27, 83, 43, 63, -77, -65, 92, -73, 49, 23, -47, 85, -35, 94,
-71, 56, 34, 41, -23, -66, -22, -44, 21, -26, 2, -99, 100, -79, -46, -20, -19, 70,
22, 53, -16, -96, -30, 40, -89, -6, 58, 36, -7, -32, 87, -11
},
90));
ExampleRunner.eq(
52,
50,
new Mosquitoes()
.getMaximum(
new int[] {
76, -85, 23, -81, 89, 35, 40, 38, 94, -31, -60, 59, -21, 86, 26, -73, -93, -65,
-60, 60, -1, -92, 14, 68, 55, -46, 36, -83, -75, 2, -20, -53, 79, -25, -38, -10,
37, 73, 90, 29, 29, 13, 59, 52, 11, 55, 92, 27, 94, 52
},
new int[] {
14, -65, -1, 56, 12, 30, 43, 21, 16, 79, -85, -86, -50, -90, 81, -16, 69, -23,
-38, -61, -14, 36, 52, 58, 74, -36, -32, 25, -96, -77, 63, 40, -25, -95, -97, -64,
-69, -46, 89, -9, 29, 95, 61, 51, 39, -83, 15, -15, 45, 5
},
100));
ExampleRunner.eq(
53,
4,
new Mosquitoes().getMaximum(new int[] {-70, 79, 0, -12}, new int[] {90, -99, 0, 18}, 1));
ExampleRunner.eq(
54,
6,
new Mosquitoes()
.getMaximum(
new int[] {0, 43, -47, -13, 59, -6}, new int[] {1, -45, 55, 15, -65, 9}, 1));
ExampleRunner.eq(
55,
8,
new Mosquitoes()
.getMaximum(
new int[] {18, -1, -9, 15, 10, -55, 27, -5},
new int[] {-31, -7, 0, -28, -20, 56, -42, -4},
1));
ExampleRunner.eq(
56,
4,
new Mosquitoes().getMaximum(new int[] {-16, -24, -9, -13}, new int[] {0, 40, -60, -20}, 1));
ExampleRunner.eq(
57,
24,
new Mosquitoes()
.getMaximum(
new int[] {
-2, 9, 7, 5, -2, 1, -12, -18, -3, 14, -4, 1, -15, 13, -6, 14, 12, -2, 5, 15, -5,
16, -13, 1
},
new int[] {
7, -51, -30, -54, -12, -22, 48, 94, 30, -96, 25, -9, 85, -68, 43, -77, -81, 15,
-38, -92, 18, -84, 75, 3
},
3));
ExampleRunner.eq(
58,
44,
new Mosquitoes()
.getMaximum(
new int[] {
-22, 63, 15, -49, -2, -66, 36, -12, -14, -14, 5, -53, 40, 60, 13, -53, -22, -76,
27, 40, 8, -32, -52, 68, -46, -78, -42, 12, -61, 24, 59, -64, 5, -21, -76, -31,
-76, 26, -9, -67, -13, -34, 60, 9
},
new int[] {
27, -88, -19, 66, 1, 82, -41, 8, 20, 23, -14, 69, -59, -75, -18, 68, 25, 94, -31,
-47, -11, 46, 70, -84, 56, 96, 57, -17, 71, -26, -83, 87, -10, 24, 93, 45, 95,
-33, 4, 80, 13, 49, -72, -16
},
5));
ExampleRunner.eq(
59,
5,
new Mosquitoes()
.getMaximum(new int[] {-8, -32, 46, -53, 58}, new int[] {22, 55, -88, 98, -99}, 3));
ExampleRunner.eq(
60,
15,
new Mosquitoes()
.getMaximum(
new int[] {-58, -69, -48, -12, -79, -98, -39, 53, -2, 88, 96, 30, 59, 84, -100},
new int[] {30, 39, 34, 6, 45, 58, 22, -36, -3, -46, -52, -22, -38, -53, 54},
9));
ExampleRunner.eq(
61,
25,
new Mosquitoes()
.getMaximum(
new int[] {
1, 23, 33, 7, -28, -3, -65, 87, 46, 65, 59, 10, -30, -21, -48, -33, 41, -78, -52,
-72, -38, -6, -24, 18, 85
},
new int[] {
11, -29, -42, -4, 27, -12, 63, -76, -54, -62, -49, 4, 20, 38, 36, 52, -36, 100,
62, 89, 45, 21, 16, -7, -95
},
15));
ExampleRunner.eq(
62,
5,
new Mosquitoes()
.getMaximum(new int[] {-4, -64, 46, -41, -92}, new int[] {0, 51, -34, 29, 68}, 3));
ExampleRunner.eq(
63,
15,
new Mosquitoes()
.getMaximum(
new int[] {-35, 5, -39, 90, 58, -76, -26, 67, 35, -44, 11, 21, 31, -55, 0},
new int[] {21, -4, 17, -48, -25, 35, 13, -30, -20, 24, -10, -13, -19, 26, 5},
9));
ExampleRunner.eq(
64,
25,
new Mosquitoes()
.getMaximum(
new int[] {
-3, -13, -27, 23, -17, -26, 98, -55, -93, -100, 6, -71, 83, 23, -74, 51, -65, 20,
-77, 98, 55, 17, 91, -30, 11
},
new int[] {
9, 14, 19, -16, 5, 7, -41, 22, 40, 53, -8, 35, -30, -4, 39, -17, 24, -1, 32, -40,
-28, -5, -44, 11, 3
},
15));
ExampleRunner.eq(
65,
5,
new Mosquitoes()
.getMaximum(new int[] {-20, 49, -10, -94, 81}, new int[] {4, -7, 3, 15, -11}, 3));
ExampleRunner.eq(
66,
9,
new Mosquitoes()
.getMaximum(
new int[] {63, -91, 77, -32, -89, 23, 84, 71, 54},
new int[] {-9, 19, -11, 5, 14, -6, -15, -12, -7},
13));
ExampleRunner.eq(
67,
13,
new Mosquitoes()
.getMaximum(
new int[] {73, -30, -13, 57, -87, 76, -72, 74, -1, -100, 7, -98, 28},
new int[] {-10, 0, -2, -14, 10, -12, 14, -11, -5, 15, -3, 20, -6},
23));
ExampleRunner.eq(
68,
4,
new Mosquitoes()
.getMaximum(
new int[] {-19, 83, 26, 96, -46, -76}, new int[] {1, -1, 0, -76, -31, 2}, 3));
ExampleRunner.eq(
69,
4,
new Mosquitoes().getMaximum(new int[] {-47, 61, -75, 21}, new int[] {1, -2, 2, -1}, 3));
ExampleRunner.eq(
70,
4,
new Mosquitoes()
.getMaximum(
new int[] {-32, 38, -17, 24, -66, 74, 48, 11},
new int[] {-20, -56, 19, 33, 94, -26, -31, -11},
3));
ExampleRunner.eq(
71,
8,
new Mosquitoes()
.getMaximum(
new int[] {52, 90, -10, 26, -2, 85, -50, -26, -35, 49, -60, -98, -40, -77, 100},
new int[] {-56, -81, 10, -23, 73, -73, 39, 24, 33, -39, 68, 20, 62, -11, -48},
4));
ExampleRunner.eq(
72,
12,
new Mosquitoes()
.getMaximum(
new int[] {
17, 91, 13, 3, 86, 20, 0, -1, 21, 15, 52, 90, -18, 6, -12, 98, -41, 10, 14, 16,
-18, -26
},
new int[] {
-45, -20, 20, 46, -86, -15, 81, 92, -57, 11, 27, 36, 49, 15, 82, 5, -99, 45, 30,
-60, 85, 56
},
5));
ExampleRunner.eq(
73,
16,
new Mosquitoes()
.getMaximum(
new int[] {
-38, -5, 46, -92, -91, -52, -30, -38, -28, 32, 17, -40, 30, 0, 31, -15, -41, -56,
-95, -16, -18, -1, 37, 99, 16, 5, -12, 18, 25
},
new int[] {
22, 0, -2, 24, -27, -44, 90, 87, 3, -64, -46, 96, -77, -3, 2, 38, 82, 7, -41, -47,
55, 13, -66, 89, -28, -12, 37, -32, 9
},
6));
ExampleRunner.eq(
74,
4,
new Mosquitoes()
.getMaximum(
new int[] {-16, -7, -43, -99, -40, -62, 66},
new int[] {62, 0, -76, 6, -88, 3, -3},
9));
ExampleRunner.eq(
75,
4,
new Mosquitoes()
.getMaximum(
new int[] {3, 34, 80, 91, -89, 79, -59, -3},
new int[] {12, -91, 68, 34, 5, -4, 2, -1},
13));
ExampleRunner.eq(
76,
4,
new Mosquitoes()
.getMaximum(
new int[] {43, 54, -67, -11, 79, -89, -50, -4, -89},
new int[] {32, -98, 3, 0, -3, 6, 82, -75, -78},
17));
ExampleRunner.eq(
77,
5,
new Mosquitoes()
.getMaximum(
new int[] {47, 15, -30, -55, 66, 6, 94, -92, -15, 51},
new int[] {23, -1, 0, -38, -2, 61, 85, -74, 1, -3},
21));
ExampleRunner.eq(
78,
10,
new Mosquitoes()
.getMaximum(
new int[] {58, -60, 77, 3, 73, 37, -83, -23, -54, 95, -49, 98, 85},
new int[] {-70, 10, -13, -3, -12, -52, 15, 4, 9, -18, 6, -17, -49},
9));
ExampleRunner.eq(
79,
12,
new Mosquitoes()
.getMaximum(
new int[] {-61, 9, 91, -80, -76, -10, 53, -11, 67, 6, 71, -86, 47, 100, -3},
new int[] {11, 2, -19, 15, 63, 5, -7, 19, -15, -1, -16, 59, -6, -18, 1},
13));
ExampleRunner.eq(
80,
14,
new Mosquitoes()
.getMaximum(
new int[] {
-59, 94, 82, -12, 0, -62, 98, -58, -6, -26, -48, -98, 95, 26, -34, 48, -19
},
new int[] {5, -88, -7, 2, -2, 8, -12, 7, 1, 4, 3, 11, -9, -4, -30, -53, 0},
17));
ExampleRunner.eq(
81,
17,
new Mosquitoes()
.getMaximum(
new int[] {
-69, -9, 92, 49, 74, 73, 59, -19, 4, -36, 49, -65, -98, -80, -65, -22, -78, 87, 29
},
new int[] {
15, 4, -13, -8, -15, 64, -9, 1, -5, 8, -6, -36, 13, 14, 7, 6, 10, -19, -7
},
21));
ExampleRunner.eq(
82,
20,
new Mosquitoes()
.getMaximum(
new int[] {
3, -11, -1, -74, 36, 95, 62, -71, -34, -45, -13, 16, -32, 85, 5, 98, 46, -78, 38,
-56, -79, 70, -99, 17, 61, -62, 33, -44, -28, -32, 14, 69, -81, -63, 73, -66, -58,
4, -60, -93, 3, 85, -94, -20, -47, 75, 19, -57, -76, -81
},
new int[] {
-51, 3, -2, -54, -29, -75, -49, 60, 27, -48, 9, -16, 80, 45, -6, -82, -58, 18,
-36, 42, 7, 91, 89, 34, -18, 53, -27, 87, 28, 39, 95, 56, 66, 20, -65, -14, 48,
38, -81, 81, -74, 8, -38, 90, 40, 11, -98, 49, -80, 88
},
5));
ExampleRunner.eq(
83,
23,
new Mosquitoes()
.getMaximum(
new int[] {
19, 83, 64, -61, 13, 6, 81, 7, 34, -9, 35, 30, 80, 72, -22, 57, 30, 60, 46, 46,
60, 12, -81, 84, 43, -14, -38, 26, 34, -59, 20, -86, 46, 74, -73, 31, -77, -45,
-58, 92, 19, 20, 46, 15, 83, 9, -32, -4, 40, -71
},
new int[] {
-20, -66, -91, 55, -11, 40, 73, -18, -37, -29, -51, 29, -95, -42, 15, 74, -28, 7,
-54, -71, -45, -69, 94, 8, -65, 20, 58, -49, -19, -78, 9, 91, -53, -94, -55, 86,
96, 6, 66, -81, -80, -90, -63, -17, 37, 79, 43, 87, 2, 80
},
9));
ExampleRunner.eq(
84,
25,
new Mosquitoes()
.getMaximum(
new int[] {
-91, -67, -46, 55, -8, -93, 37, 77, 18, -18, 7, -28, -77, -22, 33, 78, -38, 41,
-31, 55, 48, 95, 33, 25, 1, 26, 53, -66, -65, 5, -20, 66, 16, 9, -65, -98, 63, -1,
-80, 81, -27, -16, -30, 28, 61, 20, -22, 80, -10, 21
},
new int[] {
-90, 44, 83, -49, 58, 72, 63, -27, 86, 5, 9, 32, 66, -99, -97, 46, -70, 39, -8,
-63, 26, 54, 97, -32, 3, -30, -35, -20, 61, 6, -31, -46, -11, -17, 43, 78, -66,
-2, -7, -68, 18, 7, 31, -13, -50, -25, 80, -10, -83, 12
},
13));
ExampleRunner.eq(
85,
29,
new Mosquitoes()
.getMaximum(
new int[] {
-58, -58, -39, 5, -99, -21, 53, -52, 63, 91, 46, 75, 14, -15, 23, 36, -7, 77, -37,
-43, 64, -55, -59, 55, -61, -1, 18, 36, 11, -53, -28, 6, -51, -68, 68, -25, -99,
89, 19, -82, 73, -16, 6, 72, 39, 40, 88, -67, -48, -32
},
new int[] {
12, 59, -33, -1, 74, 16, 88, -91, -63, -86, -27, 39, -22, 11, -13, -72, 9, -36,
-79, 20, -23, 18, 42, -46, 70, 47, -2, 15, 1, 45, 22, 31, 60, -9, -47, 13, 67,
-58, -28, 53, -71, 4, -19, -48, 92, -11, 77, 79, 34, -59
},
17));
ExampleRunner.eq(
86,
26,
new Mosquitoes()
.getMaximum(
new int[] {
-5, -32, 57, 75, -63, 81, 18, -75, 12, 28, 43, -55, -5, 40, 62, -79, 68, 84, 64,
80, -97, -51, -11, 76, -40, 41, -50, -99, 32, -32, -50, 94, 69, 65, 26, 79, -64,
-27, 44, 55, -64, 71, 10, 1, -5, -59, 36, -40, -88, 47
},
new int[] {
4, -55, -42, -59, 46, -20, -18, 55, -8, -36, 91, -33, 1, -31, -48, 61, 47, -63,
-98, -91, 66, 50, 5, -6, 30, 84, 36, 72, -24, 79, 39, -64, -51, -79, -23, 73, 24,
27, 71, 3, 49, -56, -86, -3, 2, 43, -28, -30, 7, -35
},
3));
ExampleRunner.eq(
87,
26,
new Mosquitoes()
.getMaximum(
new int[] {
-28, -17, 45, -63, 76, 44, 97, 1, -1, 36, 36, -81, 84, -67, 26, 41, 37, 36, 1,
-54, 71, 28, 7, 12, 74, 15, -26, -64, 18, -65, 64, 89, 48, 36, 2, 43, -85, -17,
74, 29, 94, -26, -78, -48, 12, -14, 93, -87, -62, -48
},
new int[] {
44, 15, 26, 36, -57, -25, -16, 9, -2, -20, -23, 89, 1, 38, -14, -34, 45, -22, -4,
11, 86, -58, 0, -12, -49, 84, -78, 39, -13, -67, -36, -54, -28, -77, -59, -31, 50,
7, -45, -9, -39, 12, -47, 74, 68, 6, -56, 59, -7, -70
},
7));
ExampleRunner.eq(
88,
27,
new Mosquitoes()
.getMaximum(
new int[] {
10, -15, -57, -67, -66, -69, 43, 13, -32, 0, -79, -80, 22, 76, 47, -89, 34, -43,
100, 26, -80, 44, -73, -88, 19, 7, 39, -27, -20, -30, 89, -76, -87, -20, 38, 68,
-86, -10, -8, -56, 50, 5, 100, -73, -48, 75, 15, -30, 96, -28
},
new int[] {
-10, 81, 34, -36, 42, -18, -31, -9, 27, -1, -77, 56, -12, 55, -32, -95, -27, -66,
-54, -15, 18, -33, 46, -61, -21, -2, 97, 12, 14, 25, -70, 43, 17, 15, 89, -39, 52,
0, 83, -41, -28, -26, 96, -44, -81, 60, 66, 13, -57, -84
},
11));
ExampleRunner.eq(
89,
32,
new Mosquitoes()
.getMaximum(
new int[] {
-51, 46, 42, 36, -21, -79, 55, -80, -11, 23, -8, 84, -84, -60, 46, -88, -54, 16,
81, 23, 2, 48, 25, 64, 65, 74, 25, 68, -71, -12, -60, 82, 50, 9, -18, 81, 44, -8,
17, -75, -68, -63, -24, -19, 40, -4, 21, 27, -42, 65
},
new int[] {
-85, -40, -46, 80, -7, 66, -48, 57, 12, -23, 11, -69, 73, 65, -38, 70, 28, -51,
-78, -25, -88, -47, -31, 77, -66, 30, 0, 81, 9, 20, 49, -90, -55, -75, 78, -63,
-26, 19, -18, 86, 72, 67, 32, -53, -33, 21, -11, 10, 54, -27
},
15));
ExampleRunner.eq(
90,
30,
new Mosquitoes()
.getMaximum(
new int[] {
86, 6, 42, 29, 34, 98, -42, -21, -6, -25, -39, -5, 38, -52, 40, 24, 61, -52, -72,
-14, -51, 45, -86, -50, 3, -40, 26, -78, -23, 30, -54, -8, -93, 15, 91, -6, 30,
25, 45, 38, -64, 4, 77, -13, -89, 59, 45, 59, 15, 44
},
new int[] {
-93, -11, 86, -34, -95, -80, 47, -16, -72, 33, 46, 0, -46, 90, -43, -26, -63, -67,
82, 17, 29, -44, 98, 54, -71, -47, 2, 88, 27, -31, 58, 71, 69, -21, -97, 95, -54,
-32, -27, -45, 79, -5, -85, -9, -23, -66, -99, -62, -22, -52
},
5));
ExampleRunner.eq(
91,
31,
new Mosquitoes()
.getMaximum(
new int[] {
86, 34, -92, -48, -51, -90, -32, -19, 47, -90, 46, -84, 18, -94, -19, 81, 59, -60,
92, 47, 45, -99, 26, 9, -35, -71, 68, 46, -98, -39, -19, 39, 13, 50, -91, 41, 73,
-29, -7, -67, 91, -90, -77, 69, -34, -54, 16, 14, 31, -35
},
new int[] {
-50, -72, 57, 29, 32, 86, 20, 51, -35, 54, 38, -76, -10, -78, 16, -47, -39, 44,
-54, -12, -28, 97, 17, -94, -15, 53, -42, -29, 61, 62, -75, -30, -11, -36, 80,
-58, -44, 26, 78, 41, -53, 74, -13, -43, 21, 39, -4, -2, 92, 27
},
9));
ExampleRunner.eq(
92,
36,
new Mosquitoes()
.getMaximum(
new int[] {
-83, 65, 5, -63, -18, 19, -45, -17, -100, -32, -92, 7, 38, -30, 47, 50, -79, 75,
99, -65, 99, -6, 2, -31, 48, 42, -90, 22, -64, 61, -25, -87, 59, -23, 56, -42, 12,
32, 85, -69, -63, 10, 98, -14, 1, -87, -23, 69, -64, 49
},
new int[] {
82, -62, 6, 55, -3, 30, 32, 19, -81, 17, 71, -14, -27, 59, -43, -50, 61, -68, 99,
47, -87, 11, -6, 28, -29, -69, -91, -12, 65, -60, -98, 86, -51, 26, -36, 40, -94,
-30, -67, 58, -74, 2, 92, 7, -4, 83, -38, 63, 78, -52
},
13));
ExampleRunner.eq(
93,
35,
new Mosquitoes()
.getMaximum(
new int[] {
-44, 25, 44, 37, 42, -86, 60, 37, -68, -84, 63, 10, 47, 21, 58, -16, -30, 54, -36,
-2, -29, 90, -42, 92, -49, 17, 26, 11, 64, -49, 57, -20, 36, 39, -58, -82, -7,
-88, 19, -62, -41, -18, 16, 9, -37, -22, 5, -8, 45, -20
},
new int[] {
33, -20, 25, -42, -27, 95, -99, -68, -43, 73, -70, -65, 43, -44, -82, 13, 99, -73,
66, -54, 26, -100, -50, -34, 100, -33, -38, 16, -95, 76, -79, 12, -40, -35, 55,
82, 9, 91, -5, 92, -7, 23, 0, -13, 53, 56, -86, 6, -60, 40
},
17));
ExampleRunner.eq(
94,
4,
new Mosquitoes()
.getMaximum(new int[] {0, -1, 10, -11, 99, -99}, new int[] {1, -1, -3, 3, 47, -47}, 3));
ExampleRunner.eq(95, 1, new Mosquitoes().getMaximum(new int[] {5}, new int[] {2}, 8));
ExampleRunner.eq(96, 1, new Mosquitoes().getMaximum(new int[] {100}, new int[] {1}, 3));
ExampleRunner.eq(
97,
40,
new Mosquitoes()
.getMaximum(
new int[] {
41, -72, -80, -65, -96, 49, 51, 63, -66, -80, -71, 64, -90, -49, 23, -94, -25,
-51, 13, -67, 19, 12, -99, 92, -74, -95, 39, 39, 37, -57, 95, -71, -86, -51, -74,
75, 33, -29, 58, -52, 35, -46, -71, -17, -94, 77, 83, -83, -59, 2
},
new int[] {
86, -94, -80, -39, -60, 72, -58, 8, 12, -47, -49, -71, 34, -21, -92, -74, -28,
100, 29, 4, 79, 98, -91, -82, -59, -34, -51, 92, 77, 38, 51, 35, 22, -67, -90, 78,
-100, 53, -57, -32, 48, 31, 69, -88, -68, 97, -56, 73, -63, 87
},
71));
ExampleRunner.eq(
98,
4,
new Mosquitoes().getMaximum(new int[] {-100, -33, 33, 100}, new int[] {3, 1, -1, -3}, 1));
ExampleRunner.eq(
99,
3,
new Mosquitoes()
.getMaximum(new int[] {12, 34, 56, 78, 90}, new int[] {-1, 2, -3, 4, -5}, 6));
ExampleRunner.eq(
100,
50,
new Mosquitoes()
.getMaximum(
new int[] {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
},
new int[] {
-100, -96, -92, -88, -84, -80, -76, -72, -68, -64, -60, -56, -52, -48, -44, -40,
-36, -32, -28, -24, -20, -16, -12, -8, -4, 0, 4, 8, 12, 16, 20, 24, 28, 32, 36,
40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96
},
100));
ExampleRunner.eq(
101, 2, new Mosquitoes().getMaximum(new int[] {0, -10}, new int[] {0, 100}, 1));
ExampleRunner.eq(
102, 2, new Mosquitoes().getMaximum(new int[] {1, -2}, new int[] {-100, 100}, 1));
ExampleRunner.eq(
103, 2, new Mosquitoes().getMaximum(new int[] {100, -100}, new int[] {0, 1}, 10));
ExampleRunner.eq(
104, 2, new Mosquitoes().getMaximum(new int[] {-10, 0}, new int[] {100, 0}, 1));
ExampleRunner.eq(
105,
2,
new Mosquitoes()
.getMaximum(new int[] {1, -30, -60, 100, 90}, new int[] {-1, 2, -3, 4, -5}, 1));
ExampleRunner.eq(
106, 2, new Mosquitoes().getMaximum(new int[] {-100, 100}, new int[] {100, 99}, 1));
ExampleRunner.eq(
107, 3, new Mosquitoes().getMaximum(new int[] {0, 1, -1}, new int[] {0, -1, 1}, 10));
ExampleRunner.eq(108, 2, new Mosquitoes().getMaximum(new int[] {0, 6}, new int[] {70, -70}, 1));
ExampleRunner.eq(
109,
15,
new Mosquitoes()
.getMaximum(
new int[] {
100, 100, -100, -100, 44, 55, 66, 77, -22, -33, -55, -66, -77, -11, -12, -34, -56,
-45, -23, 12, 45, 67, 89, 45, 34, 78, 54, 34, 88, 65, 45, -45, -45, -87
},
new int[] {
1, 100, 12, 13, 14, 15, 16, 17, 18, 19, -20, -21, -22, -23, -24, -25, 26, 27, 30,
40, 41, 42, 80, -81, -82, 82, -83, 60, 61, 62, -62, -63, -64, 65
},
30));
ExampleRunner.eq(
110, 2, new Mosquitoes().getMaximum(new int[] {100, 95}, new int[] {-100, -1}, 1));
ExampleRunner.eq(
111,
5,
new Mosquitoes()
.getMaximum(new int[] {2, 0, 86, 12, 16, -32}, new int[] {1, 2, -40, -1, -2, 10}, 1));
ExampleRunner.eq(
112,
17,
new Mosquitoes()
.getMaximum(
new int[] {
60, 53, 63, 39, 7, 80, 86, 57, 31, 3, 66, 40, 31, 3, 57, 78, 53, 0, 23, 73, 71,
53, 25, 36, 37, 54, 47, 80, 71, 27, 71, 85, 73, 41, 97, 29, 85, 33, 83, 56, 60,
13, 27, 27, 20
},
new int[] {
41, 1, 36, 45, 2, 42, 3, 8, 40, 6, 25, 16, 26, 19, 48, 14, 30, 24, 10, 23, 7, 17,
21, 37, 18, 0, 32, 5, 4, 22, 12, 31, 35, 29, 44, 9, 46, 38, 39, 13, 47, 34, 28,
11, 27
},
12));
ExampleRunner.eq(113, 2, new Mosquitoes().getMaximum(new int[] {-2, 2}, new int[] {-2, 2}, 3));
ExampleRunner.eq(
114, 3, new Mosquitoes().getMaximum(new int[] {-2, 0, 2}, new int[] {100, 0, -100}, 1));
ExampleRunner.eq(
115,
7,
new Mosquitoes()
.getMaximum(
new int[] {
1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, -9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 40, 41,
43, 45, 56, 78, 99, 100, -23
},
new int[] {
1, 2, 3, 4, -1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 45, 46, 47, 48, 49, 50, 52, 53,
54, 56, 57, 58, 59, 90, 92
},
2));
ExampleRunner.eq(
116,
7,
new Mosquitoes()
.getMaximum(
new int[] {
0, -1, 10, -11, 99, -99, 39, 1, -2, 11, -12, 98, -98, 38, 4, -3, 13, -16, 92, -93,
34, 6, -4, 15, -21, 95, -96, 37
},
new int[] {
1, -1, -3, 3, 47, -47, -80, 12, -12, -32, 32, 42, -42, -81, 13, -13, -33, 0, 15,
-52, -21, 2, 4, -2, -4, 6, -6, 8
},
3));
}
public static void main(String[] args) {
ExampleRunner.eq(1, 2L, new MagicDiamonds().minimalTransfer(2L));
ExampleRunner.eq(2, 1L, new MagicDiamonds().minimalTransfer(4294967297L));
ExampleRunner.eq(3, 2L, new MagicDiamonds().minimalTransfer(2147483647L));
ExampleRunner.eq(4, 1L, new MagicDiamonds().minimalTransfer(1L));
ExampleRunner.eq(5, 1L, new MagicDiamonds().minimalTransfer(8566L));
ExampleRunner.eq(6, 1L, new MagicDiamonds().minimalTransfer(6308L));
ExampleRunner.eq(7, 1L, new MagicDiamonds().minimalTransfer(4081L));
ExampleRunner.eq(8, 1L, new MagicDiamonds().minimalTransfer(5680L));
ExampleRunner.eq(9, 1L, new MagicDiamonds().minimalTransfer(4427L));
ExampleRunner.eq(10, 1L, new MagicDiamonds().minimalTransfer(2739L));
ExampleRunner.eq(11, 1L, new MagicDiamonds().minimalTransfer(6181L));
ExampleRunner.eq(12, 1L, new MagicDiamonds().minimalTransfer(6274L));
ExampleRunner.eq(13, 1L, new MagicDiamonds().minimalTransfer(3601L));
ExampleRunner.eq(14, 1L, new MagicDiamonds().minimalTransfer(7506L));
ExampleRunner.eq(15, 2L, new MagicDiamonds().minimalTransfer(8951L));
ExampleRunner.eq(16, 1L, new MagicDiamonds().minimalTransfer(5345L));
ExampleRunner.eq(17, 1L, new MagicDiamonds().minimalTransfer(9621L));
ExampleRunner.eq(18, 1L, new MagicDiamonds().minimalTransfer(9300L));
ExampleRunner.eq(19, 2L, new MagicDiamonds().minimalTransfer(23L));
ExampleRunner.eq(20, 1L, new MagicDiamonds().minimalTransfer(720L));
ExampleRunner.eq(21, 1L, new MagicDiamonds().minimalTransfer(2151L));
ExampleRunner.eq(22, 1L, new MagicDiamonds().minimalTransfer(7854L));
ExampleRunner.eq(23, 2L, new MagicDiamonds().minimalTransfer(3607L));
ExampleRunner.eq(24, 1L, new MagicDiamonds().minimalTransfer(1881L));
ExampleRunner.eq(25, 1L, new MagicDiamonds().minimalTransfer(6076L));
ExampleRunner.eq(26, 1L, new MagicDiamonds().minimalTransfer(9369L));
ExampleRunner.eq(27, 2L, new MagicDiamonds().minimalTransfer(3853L));
ExampleRunner.eq(28, 1L, new MagicDiamonds().minimalTransfer(8229L));
ExampleRunner.eq(29, 1L, new MagicDiamonds().minimalTransfer(205L));
ExampleRunner.eq(30, 1L, new MagicDiamonds().minimalTransfer(980L));
ExampleRunner.eq(31, 1L, new MagicDiamonds().minimalTransfer(4197L));
ExampleRunner.eq(32, 1L, new MagicDiamonds().minimalTransfer(1460L));
ExampleRunner.eq(33, 2L, new MagicDiamonds().minimalTransfer(320020303L));
ExampleRunner.eq(34, 1L, new MagicDiamonds().minimalTransfer(1021932001L));
ExampleRunner.eq(35, 1L, new MagicDiamonds().minimalTransfer(1804873438L));
ExampleRunner.eq(36, 1L, new MagicDiamonds().minimalTransfer(625102087L));
ExampleRunner.eq(37, 1L, new MagicDiamonds().minimalTransfer(298989654L));
ExampleRunner.eq(38, 1L, new MagicDiamonds().minimalTransfer(713692516L));
ExampleRunner.eq(39, 1L, new MagicDiamonds().minimalTransfer(2019257625L));
ExampleRunner.eq(40, 1L, new MagicDiamonds().minimalTransfer(1567124116L));
ExampleRunner.eq(41, 1L, new MagicDiamonds().minimalTransfer(196044214L));
ExampleRunner.eq(42, 1L, new MagicDiamonds().minimalTransfer(436143805L));
ExampleRunner.eq(43, 1L, new MagicDiamonds().minimalTransfer(1906602942L));
ExampleRunner.eq(44, 1L, new MagicDiamonds().minimalTransfer(1651588877L));
ExampleRunner.eq(45, 1L, new MagicDiamonds().minimalTransfer(1477002708L));
ExampleRunner.eq(46, 1L, new MagicDiamonds().minimalTransfer(1117874276L));
ExampleRunner.eq(47, 1L, new MagicDiamonds().minimalTransfer(378147332L));
ExampleRunner.eq(48, 1L, new MagicDiamonds().minimalTransfer(557741133L));
ExampleRunner.eq(49, 1L, new MagicDiamonds().minimalTransfer(668154454L));
ExampleRunner.eq(50, 1L, new MagicDiamonds().minimalTransfer(570251827L));
ExampleRunner.eq(51, 1L, new MagicDiamonds().minimalTransfer(1039736738L));
ExampleRunner.eq(52, 1L, new MagicDiamonds().minimalTransfer(2099585234L));
ExampleRunner.eq(53, 1L, new MagicDiamonds().minimalTransfer(1981093541L));
ExampleRunner.eq(54, 1L, new MagicDiamonds().minimalTransfer(1884363755L));
ExampleRunner.eq(55, 1L, new MagicDiamonds().minimalTransfer(1865560917L));
ExampleRunner.eq(56, 1L, new MagicDiamonds().minimalTransfer(745615932L));
ExampleRunner.eq(57, 1L, new MagicDiamonds().minimalTransfer(1214865010L));
ExampleRunner.eq(58, 1L, new MagicDiamonds().minimalTransfer(1695760303L));
ExampleRunner.eq(59, 1L, new MagicDiamonds().minimalTransfer(1246390622L));
ExampleRunner.eq(60, 1L, new MagicDiamonds().minimalTransfer(1692493778L));
ExampleRunner.eq(61, 1L, new MagicDiamonds().minimalTransfer(1065227310L));
ExampleRunner.eq(62, 1L, new MagicDiamonds().minimalTransfer(1265265799L));
ExampleRunner.eq(63, 1L, new MagicDiamonds().minimalTransfer(1084963329L));
ExampleRunner.eq(64, 1L, new MagicDiamonds().minimalTransfer(1478843645L));
ExampleRunner.eq(65, 1L, new MagicDiamonds().minimalTransfer(2006456208L));
ExampleRunner.eq(66, 1L, new MagicDiamonds().minimalTransfer(1722953950L));
ExampleRunner.eq(67, 1L, new MagicDiamonds().minimalTransfer(496132103L));
ExampleRunner.eq(68, 1L, new MagicDiamonds().minimalTransfer(6562762L));
ExampleRunner.eq(69, 1L, new MagicDiamonds().minimalTransfer(957223956L));
ExampleRunner.eq(70, 1L, new MagicDiamonds().minimalTransfer(654140677L));
ExampleRunner.eq(71, 1L, new MagicDiamonds().minimalTransfer(1586450237L));
ExampleRunner.eq(72, 1L, new MagicDiamonds().minimalTransfer(1018720108L));
ExampleRunner.eq(73, 1L, new MagicDiamonds().minimalTransfer(2026536822L));
ExampleRunner.eq(74, 1L, new MagicDiamonds().minimalTransfer(764222894L));
ExampleRunner.eq(75, 1L, new MagicDiamonds().minimalTransfer(1544043251L));
ExampleRunner.eq(76, 1L, new MagicDiamonds().minimalTransfer(1034964664L));
ExampleRunner.eq(77, 1L, new MagicDiamonds().minimalTransfer(684533819L));
ExampleRunner.eq(78, 2L, new MagicDiamonds().minimalTransfer(559623793L));
ExampleRunner.eq(79, 1L, new MagicDiamonds().minimalTransfer(1102523518L));
ExampleRunner.eq(80, 1L, new MagicDiamonds().minimalTransfer(1103984296L));
ExampleRunner.eq(81, 1L, new MagicDiamonds().minimalTransfer(1487426600L));
ExampleRunner.eq(82, 1L, new MagicDiamonds().minimalTransfer(1402158154L));
ExampleRunner.eq(83, 1L, new MagicDiamonds().minimalTransfer(1000000000000L));
ExampleRunner.eq(84, 3L, new MagicDiamonds().minimalTransfer(3L));
ExampleRunner.eq(85, 1L, new MagicDiamonds().minimalTransfer(1L));
ExampleRunner.eq(86, 1L, new MagicDiamonds().minimalTransfer(4L));
ExampleRunner.eq(87, 2L, new MagicDiamonds().minimalTransfer(5L));
ExampleRunner.eq(88, 1L, new MagicDiamonds().minimalTransfer(6L));
ExampleRunner.eq(89, 2L, new MagicDiamonds().minimalTransfer(7L));
ExampleRunner.eq(90, 1L, new MagicDiamonds().minimalTransfer(8L));
ExampleRunner.eq(91, 1L, new MagicDiamonds().minimalTransfer(9L));
ExampleRunner.eq(92, 1L, new MagicDiamonds().minimalTransfer(10L));
ExampleRunner.eq(93, 1L, new MagicDiamonds().minimalTransfer(1000000000000L));
ExampleRunner.eq(94, 1L, new MagicDiamonds().minimalTransfer(999999999997L));
ExampleRunner.eq(95, 2L, new MagicDiamonds().minimalTransfer(999999999989L));
ExampleRunner.eq(96, 2L, new MagicDiamonds().minimalTransfer(22222223L));
ExampleRunner.eq(97, 1L, new MagicDiamonds().minimalTransfer(524524524524L));
ExampleRunner.eq(98, 2L, new MagicDiamonds().minimalTransfer(524524524521L));
ExampleRunner.eq(99, 2L, new MagicDiamonds().minimalTransfer(51432121451L));
ExampleRunner.eq(100, 1L, new MagicDiamonds().minimalTransfer(25L));
ExampleRunner.eq(101, 2L, new MagicDiamonds().minimalTransfer(11L));
ExampleRunner.eq(102, 2L, new MagicDiamonds().minimalTransfer(999999000001L));
ExampleRunner.eq(103, 1L, new MagicDiamonds().minimalTransfer(66L));
ExampleRunner.eq(104, 1L, new MagicDiamonds().minimalTransfer(16L));
ExampleRunner.eq(105, 1L, new MagicDiamonds().minimalTransfer(49L));
ExampleRunner.eq(106, 2L, new MagicDiamonds().minimalTransfer(100000000019L));
ExampleRunner.eq(107, 2L, new MagicDiamonds().minimalTransfer(982451653L));
ExampleRunner.eq(108, 2L, new MagicDiamonds().minimalTransfer(31L));
ExampleRunner.eq(109, 1L, new MagicDiamonds().minimalTransfer(424248523252L));
ExampleRunner.eq(110, 1L, new MagicDiamonds().minimalTransfer(27L));
ExampleRunner.eq(111, 1L, new MagicDiamonds().minimalTransfer(999966000289L));
ExampleRunner.eq(112, 1L, new MagicDiamonds().minimalTransfer(10010602793L));
ExampleRunner.eq(113, 1L, new MagicDiamonds().minimalTransfer(97969L));
ExampleRunner.eq(114, 1L, new MagicDiamonds().minimalTransfer(1000000000L));
ExampleRunner.eq(115, 2L, new MagicDiamonds().minimalTransfer(13L));
ExampleRunner.eq(116, 2L, new MagicDiamonds().minimalTransfer(1000000007L));
}
