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)); }