{"problem": "You have a permutation: an array a = [a_1, a_2, …, a_n] of distinct integers from 1 to n. The length of the permutation n is odd.\n\nConsider the following algorithm of sorting the permutation in increasing order.\n\nA helper procedure of the algorithm, f(i), takes a single argument i (1 ≤ i ≤ n-1) and does the following. If a_i > a_{i+1}, the values of a_i and a_{i+1} are exchanged. Otherwise, the permutation doesn't change.\n\nThe algorithm consists of iterations, numbered with consecutive integers starting with 1. On the i-th iteration, the algorithm does the following: \n\n  * if i is odd, call f(1), f(3), …, f(n - 2); \n  * if i is even, call f(2), f(4), …, f(n - 1). \n\n\n\nIt can be proven that after a finite number of iterations the permutation will be sorted in increasing order.\n\nAfter how many iterations will this happen for the first time?\n\nInput\n\nEach test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.\n\nThe first line of each test case contains a single integer n (3 ≤ n ≤ 999; n is odd) — the length of the permutation.\n\nThe second line contains n distinct integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — the permutation itself. \n\nIt is guaranteed that the sum of n over all test cases does not exceed 999.\n\nOutput\n\nFor each test case print the number of iterations after which the permutation will become sorted in increasing order for the first time.\n\nIf the given permutation is already sorted, print 0.\n\nExample\n\nInput\n\n\n3\n3\n3 2 1\n7\n4 5 7 1 3 2 6\n5\n1 2 3 4 5\n\n\nOutput\n\n\n3\n5\n0\n\nNote\n\nIn the first test case, the permutation will be changing as follows: \n\n  * after the 1-st iteration: [2, 3, 1]; \n  * after the 2-nd iteration: [2, 1, 3]; \n  * after the 3-rd iteration: [1, 2, 3]. \n\n\n\nIn the second test case, the permutation will be changing as follows: \n\n  * after the 1-st iteration: [4, 5, 1, 7, 2, 3, 6]; \n  * after the 2-nd iteration: [4, 1, 5, 2, 7, 3, 6]; \n  * after the 3-rd iteration: [1, 4, 2, 5, 3, 7, 6]; \n  * after the 4-th iteration: [1, 2, 4, 3, 5, 6, 7]; \n  * after the 5-th iteration: [1, 2, 3, 4, 5, 6, 7]. \n\n\n\nIn the third test case, the permutation is already sorted and the answer is 0.", "test_cases": {"inputs": ["3\n3\n3 2 1\n7\n4 5 7 1 3 2 6\n5\n1 2 3 4 5\n", "3\n3\n3 2 1\n7\n4 5 7 1 3 2 6\n5\n1 3 2 4 5\n", "3\n3\n2 3 1\n7\n4 5 7 1 3 2 6\n5\n1 2 3 4 5\n", "3\n3\n3 2 1\n7\n4 5 6 1 3 2 7\n5\n1 2 3 4 5\n", "3\n3\n3 2 1\n7\n4 5 7 2 3 1 6\n5\n1 3 2 4 5\n", "3\n3\n3 2 1\n7\n4 5 7 1 3 2 6\n5\n1 3 2 5 4\n"], "outputs": ["3\n5\n0\n", "3\n5\n2\n", "3\n5\n0\n", "3\n5\n0\n", "3\n5\n2\n", "3\n5\n2\n"]}, "starter_code": "", "problem_sha1": "bfc30790375e19a5de0b0da0ee3a36e63cc2a475", "n_test_cases_total": 6, "n_test_cases_kept": 6, "test_cases_truncated": false, "seed_id": "cc-06488", "original_id": null, "source": "code_contests", "domain": "code", "test_case_format": "stdin_stdout", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": null}
{"problem": "This is the easy version of the problem. The difference between the versions is that the easy version does not require you to output the numbers of the rods to be removed. You can make hacks only if all versions of the problem are solved.\n\nStitch likes experimenting with different machines with his friend Sparky. Today they built another machine.\n\nThe main element of this machine are n rods arranged along one straight line and numbered from 1 to n inclusive. Each of these rods must carry an electric charge quantitatively equal to either 1 or -1 (otherwise the machine will not work). Another condition for this machine to work is that the sign-variable sum of the charge on all rods must be zero.\n\nMore formally, the rods can be represented as an array of n numbers characterizing the charge: either 1 or -1. Then the condition must hold: a_1 - a_2 + a_3 - a_4 + … = 0, or ∑_{i=1}^n (-1)^{i-1} ⋅ a_i = 0.\n\nSparky charged all n rods with an electric current, but unfortunately it happened that the rods were not charged correctly (the sign-variable sum of the charge is not zero). The friends decided to leave only some of the rods in the machine. Sparky has q questions. In the ith question Sparky asks: if the machine consisted only of rods with numbers l_i to r_i inclusive, what minimal number of rods could be removed from the machine so that the sign-variable sum of charges on the remaining ones would be zero? Perhaps the friends got something wrong, and the sign-variable sum is already zero. In that case, you don't have to remove the rods at all.\n\nIf the number of rods is zero, we will assume that the sign-variable sum of charges is zero, that is, we can always remove all rods.\n\nHelp your friends and answer all of Sparky's questions!\n\nInput\n\nEach test contains multiple test cases.\n\nThe first line contains one positive integer t (1 ≤ t ≤ 10^3), denoting the number of test cases. Description of the test cases follows.\n\nThe first line of each test case contains two positive integers n and q (1 ≤ n, q ≤ 3 ⋅ 10^5) — the number of rods and the number of questions.\n\nThe second line of each test case contains a non-empty string s of length n, where the charge of the i-th rod is 1 if s_i is the \"+\" symbol, or -1 if s_i is the \"-\" symbol.\n\nEach next line from the next q lines contains two positive integers l_i ans r_i (1 ≤ l_i ≤ r_i ≤ n) — numbers, describing Sparky's questions.\n\nIt is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.\n\nOutput\n\nFor each test case, print a single integer — the minimal number of rods that can be removed.\n\nExample\n\nInput\n\n\n3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n\n\nOutput\n\n\n2\n2\n1\n0\n1\n2\n1\n2\n1\n2\n1\n1\n2\n1\n\nNote\n\nIn the first test case for the first query you can remove the rods numbered 5 and 8, then the following set of rods will remain: +--+--++-++-. It is easy to see that here the sign-variable sum is zero.\n\nIn the second test case:\n\n  * For the first query, we can remove the rods numbered 1 and 11, then the following set of rods will remain: --++---++---. It is easy to see that here the sign-variable sum is zero. \n  * For the second query we can remove the rod numbered 9, then the following set of rods will remain: ---++-. It is easy to see that here the variable sum is zero. \n  * For the third query we can not remove the rods at all. ", "test_cases": {"inputs": ["3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n-++-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n6 10\n4 10\n-++-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n2 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n1 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n2 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 4\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 1\n1 3\n1 4\n2 2\n1 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n2 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 4\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n2 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 4\n2 4\n3 4\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 3\n2 4\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 4\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n2 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n1 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n2 4\n2 2\n2 3\n2 4\n2 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 11\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 4\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n2 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n2 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 2\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 4\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 13\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n2 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 1\n1 4\n1 4\n2 2\n1 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 3\n2 4\n2 3\n2 4\n3 3\n4 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n2 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 1\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n7 12\n4 10\n4 4\n+-+-\n1 1\n1 2\n1 3\n1 4\n0 2\n2 3\n3 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n2 14\n6 3\n3 10\n4 10\n+-+-\n1 1\n1 1\n1 2\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n2 14\n6 3\n3 10\n4 10\n+-+-\n1 2\n1 1\n1 2\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n2 14\n6 3\n3 10\n4 10\n+-+-\n1 2\n1 1\n1 1\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n2 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n-++-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n6 10\n4 10\n-++-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 4\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n2 14\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n2 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 13\n7 12\n3 10\n4 4\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 11\n14 3\n+--++---+++---\n1 14\n2 12\n3 10\n4 4\n+-+-\n1 1\n1 2\n1 3\n1 4\n3 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 13\n4 10\n-+-+\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n1 4\n2 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 2\n2 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n2 14\n14 3\n+--++---+++---\n1 14\n7 12\n3 14\n4 10\n+-+-\n1 1\n1 2\n2 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 11\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 4\n+--+\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 2\n", "3\n14 1\n+--++---++-++-\n1 8\n14 3\n+--++---+++---\n1 14\n2 12\n3 10\n4 4\n+-+-\n1 1\n1 2\n1 3\n1 4\n3 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n2 14\n14 3\n+--++---+++---\n1 14\n7 12\n3 14\n4 10\n+-+-\n1 1\n1 2\n2 4\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 11\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 4\n+--+\n1 1\n1 1\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 2\n", "3\n14 1\n+--++---++-++-\n1 8\n14 3\n+--++---+++---\n1 14\n2 12\n3 10\n4 0\n+-+-\n1 1\n1 2\n1 3\n1 4\n1 2\n2 3\n2 4\n3 3\n3 4\n5 4\n", "3\n14 1\n+--++---++-++-\n1 8\n14 3\n+--++---+++---\n1 14\n2 12\n3 10\n4 1\n+-+-\n1 1\n1 4\n1 3\n1 4\n1 2\n2 3\n2 4\n3 3\n3 4\n5 4\n", "3\n14 1\n+--++---++-++-\n1 8\n14 3\n+--++---+++---\n1 14\n2 12\n3 5\n4 1\n+-+-\n1 1\n1 4\n1 3\n1 4\n1 1\n4 3\n2 4\n3 3\n0 4\n5 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 13\n7 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n1 3\n2 3\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n2 14\n6 7\n3 10\n4 10\n+-+-\n1 1\n1 1\n1 3\n1 4\n2 2\n1 3\n2 4\n3 3\n3 4\n3 4\n", "3\n14 1\n+--++---++-++-\n1 14\n14 3\n+--++---+++---\n1 14\n2 12\n3 10\n4 10\n+-+-\n1 2\n1 2\n1 3\n1 4\n2 2\n2 4\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 11\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 4\n+-+-\n1 1\n1 2\n1 3\n2 4\n2 2\n2 3\n2 4\n3 3\n3 4\n4 4\n", "3\n14 1\n+--++---++-++-\n1 4\n14 3\n+--++---+++---\n1 14\n7 12\n3 10\n4 10\n+-+-\n1 1\n1 2\n1 3\n1 4\n2 2\n3 3\n2 4\n3 3\n3 4\n4 4\n"], "outputs": ["2\n2\n1\n0\n1\n2\n1\n2\n1\n2\n1\n1\n2\n1\n", "2\n2\n0\n0\n1\n2\n1\n2\n1\n2\n1\n1\n2\n1\n", "2\n2\n2\n0\n1\n2\n1\n2\n1\n2\n1\n1\n2\n1\n", "2\n2\n0\n0\n1\n2\n1\n0\n1\n0\n1\n1\n2\n1\n", "2\n2\n0\n1\n1\n2\n1\n0\n1\n0\n1\n1\n2\n1\n", "2\n2\n0\n0\n1\n2\n1\n2\n1\n2\n1\n1\n2\n2\n", "2\n2\n2\n0\n1\n2\n2\n2\n1\n2\n1\n1\n2\n1\n", "2\n2\n0\n0\n1\n2\n1\n2\n1\n1\n1\n1\n2\n2\n", "2\n2\n0\n0\n1\n2\n1\n2\n1\n2\n1\n2\n2\n1\n", "2\n2\n2\n0\n1\n2\n1\n2\n1\n1\n1\n1\n2\n1\n", "2\n2\n0\n0\n1\n1\n1\n2\n1\n1\n1\n1\n2\n2\n", "2\n2\n1\n0\n1\n2\n1\n2\n1\n1\n1\n1\n2\n1\n", "2\n2\n1\n0\n1\n2\n1\n2\n1\n1\n1\n2\n2\n1\n", "2\n2\n0\n0\n1\n2\n1\n1\n1\n2\n1\n1\n2\n1\n", "2\n2\n2\n0\n1\n2\n1\n2\n", "2\n1\n0\n0\n1\n2\n1\n2\n1\n1\n1\n1\n2\n2\n", "2\n2\n0\n0\n1\n2\n1\n1\n1\n2\n1\n2\n2\n1\n", "1\n2\n2\n0\n1\n2\n1\n2\n", "2\n1\n0\n0\n1\n2\n1\n2\n1\n2\n1\n1\n2\n2\n", "2\n1\n0\n0\n1\n2\n2\n2\n1\n2\n1\n1\n2\n2\n", "0\n2\n2\n0\n1\n2\n1\n2\n1\n2\n1\n1\n2\n1\n", "2\n2\n0\n1\n1\n2\n1\n2\n1\n2\n1\n2\n2\n1\n", "2\n2\n0\n0\n1\n1\n2\n2\n1\n1\n1\n1\n2\n2\n", "2\n2\n0\n0\n1\n2\n1\n1\n1\n2\n1\n1\n1\n1\n", "2\n1\n0\n0\n1\n1\n1\n2\n1\n2\n1\n1\n2\n2\n", "2\n2\n2\n1\n1\n2\n1\n2\n", "2\n1\n0\n0\n1\n1\n2\n2\n1\n2\n1\n1\n2\n2\n", "2\n1\n0\n0\n2\n1\n2\n2\n1\n2\n1\n1\n2\n2\n", "2\n1\n0\n0\n2\n1\n1\n2\n1\n2\n1\n1\n2\n2\n", "1\n2\n0\n0\n1\n2\n1\n0\n1\n0\n1\n1\n2\n1\n", "2\n2\n0\n1\n1\n2\n1\n0\n1\n1\n1\n1\n2\n1\n", "1\n2\n2\n0\n1\n2\n2\n2\n1\n2\n1\n1\n2\n1\n", "2\n1\n2\n0\n1\n2\n1\n2\n", "1\n2\n1\n0\n1\n2\n1\n2\n", "2\n2\n0\n1\n1\n2\n1\n2\n1\n2\n2\n2\n2\n1\n", "2\n2\n0\n0\n1\n2\n1\n2\n1\n2\n1\n2\n2\n2\n", "1\n2\n2\n2\n1\n2\n2\n2\n1\n2\n1\n1\n2\n1\n", "1\n2\n2\n0\n1\n2\n1\n0\n", "2\n2\n1\n0\n1\n2\n1\n2\n", "1\n2\n2\n2\n1\n2\n1\n2\n1\n2\n1\n1\n2\n1\n", "1\n2\n2\n0\n1\n1\n1\n0\n", "2\n2\n1\n0\n", "2\n2\n1\n0\n1\n", "2\n2\n1\n1\n1\n", "2\n1\n2\n0\n1\n2\n1\n2\n1\n2\n1\n1\n2\n1\n", "2\n2\n0\n0\n1\n2\n1\n2\n1\n1\n2\n1\n2\n2\n", "2\n1\n0\n0\n1\n1\n1\n2\n1\n1\n1\n1\n2\n2\n", "2\n2\n1\n0\n2\n2\n1\n2\n1\n1\n1\n1\n2\n1\n", "1\n2\n2\n0\n1\n2\n1\n1\n", "0\n2\n2\n0\n1\n2\n1\n2\n1\n1\n1\n1\n2\n1\n"]}, "starter_code": "", "problem_sha1": "bc425422a90e0a69abf37366e2e023b4870debd6", "n_test_cases_total": 201, "n_test_cases_kept": 50, "test_cases_truncated": true, "seed_id": "cc-06493", "original_id": null, "source": "code_contests", "domain": "code", "test_case_format": "stdin_stdout", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": null}
{"problem": "Alice gave Bob two integers a and b (a > 0 and b ≥ 0). Being a curious boy, Bob wrote down an array of non-negative integers with \\operatorname{MEX} value of all elements equal to a and \\operatorname{XOR} value of all elements equal to b.\n\nWhat is the shortest possible length of the array Bob wrote?\n\nRecall that the \\operatorname{MEX} (Minimum EXcluded) of an array is the minimum non-negative integer that does not belong to the array and the \\operatorname{XOR} of an array is the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of all the elements of the array.\n\nInput\n\nThe input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5 ⋅ 10^4) — the number of test cases. The description of the test cases follows.\n\nThe only line of each test case contains two integers a and b (1 ≤ a ≤ 3 ⋅ 10^5; 0 ≤ b ≤ 3 ⋅ 10^5) — the \\operatorname{MEX} and \\operatorname{XOR} of the array, respectively.\n\nOutput\n\nFor each test case, output one (positive) integer — the length of the shortest array with \\operatorname{MEX} a and \\operatorname{XOR} b. We can show that such an array always exists.\n\nExample\n\nInput\n\n\n5\n1 1\n2 1\n2 0\n1 10000\n2 10000\n\n\nOutput\n\n\n3\n2\n3\n2\n3\n\nNote\n\nIn the first test case, one of the shortest arrays with \\operatorname{MEX} 1 and \\operatorname{XOR} 1 is [0, 2020, 2021].\n\nIn the second test case, one of the shortest arrays with \\operatorname{MEX} 2 and \\operatorname{XOR} 1 is [0, 1].\n\nIt can be shown that these arrays are the shortest arrays possible.", "test_cases": {"inputs": ["5\n1 1\n2 1\n2 0\n1 10000\n2 10000\n", "1\n187994 180766\n", "1\n187994 204747\n", "1\n246904 204747\n", "1\n85497 204747\n", "1\n131971 84448\n", "1\n234010 8121\n", "1\n276349 15514\n", "1\n66857 12385\n", "1\n80122 12385\n", "1\n118142 12385\n", "1\n165283 12385\n", "1\n246094 37681\n", "1\n53227 37681\n", "1\n40413 15647\n", "1\n25777 10340\n", "1\n6051 10340\n", "1\n1001 10340\n", "1\n1101 46\n", "1\n1000 46\n", "1\n32595 180766\n", "1\n142906 204747\n", "1\n137076 204747\n", "1\n134651 84448\n", "1\n45090 25606\n", "1\n162848 8121\n", "1\n148388 15514\n", "1\n194628 15514\n", "1\n201802 12385\n", "1\n153543 12385\n", "1\n142997 20642\n", "1\n287909 37681\n", "1\n105847 37681\n", "1\n927 15647\n", "1\n31752 15647\n", "1\n26952 9625\n", "1\n3160 7873\n", "1\n0001 10340\n", "1\n1010 46\n", "1\n30779 204747\n", "1\n7309 131326\n", "1\n254048 54416\n", "1\n193413 7858\n", "1\n194896 15514\n", "1\n243298 12385\n", "1\n113889 22065\n", "1\n149114 10437\n", "1\n66068 12385\n", "1\n34657 37681\n", "1\n1465 15647\n"], "outputs": ["3\n2\n3\n2\n3\n", "187995\n", "187995\n", "246905\n", "85498\n", "131972\n", "234011\n", "276350\n", "66858\n", "80123\n", "118143\n", "165284\n", "246095\n", "53228\n", "40414\n", "25778\n", "6052\n", "1002\n", "1102\n", "1001\n", "32596\n", "142907\n", "137077\n", "134652\n", "45091\n", "162849\n", "148389\n", "194629\n", "201803\n", "153544\n", "142998\n", "287910\n", "105848\n", "928\n", "31753\n", "26953\n", "3161\n", "2\n", "1011\n", "30780\n", "7310\n", "254049\n", "193414\n", "194897\n", "243299\n", "113890\n", "149115\n", "66069\n", "34658\n", "1466\n"]}, "starter_code": "", "problem_sha1": "058b765c3fde225ec6d280086bc71a0a80f41d6f", "n_test_cases_total": 202, "n_test_cases_kept": 50, "test_cases_truncated": true, "seed_id": "cc-06498", "original_id": null, "source": "code_contests", "domain": "code", "test_case_format": "stdin_stdout", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": null}
{"problem": "You are given a digital clock with n digits. Each digit shows an integer from 0 to 9, so the whole clock shows an integer from 0 to 10^n-1. The clock will show leading zeroes if the number is smaller than 10^{n-1}.\n\nYou want the clock to show 0 with as few operations as possible. In an operation, you can do one of the following: \n\n  * decrease the number on the clock by 1, or \n  * swap two digits (you can choose which digits to swap, and they don't have to be adjacent). \n\n\n\nYour task is to determine the minimum number of operations needed to make the clock show 0.\n\nInput\n\nEach test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3).\n\nThe first line of each test case contains a single integer n (1 ≤ n ≤ 100) — number of digits on the clock.\n\nThe second line of each test case contains a string of n digits s_1, s_2, …, s_n (0 ≤ s_1, s_2, …, s_n ≤ 9) — the number on the clock.\n\nNote: If the number is smaller than 10^{n-1} the clock will show leading zeroes.\n\nOutput\n\nFor each test case, print one integer: the minimum number of operations needed to make the clock show 0.\n\nExample\n\nInput\n\n\n7\n3\n007\n4\n1000\n5\n00000\n3\n103\n4\n2020\n9\n123456789\n30\n001678294039710047203946100020\n\n\nOutput\n\n\n7\n2\n0\n5\n6\n53\n115\n\nNote\n\nIn the first example, it's optimal to just decrease the number 7 times.\n\nIn the second example, we can first swap the first and last position and then decrease the number by 1.\n\nIn the third example, the clock already shows 0, so we don't have to perform any operations.", "test_cases": {"inputs": ["7\n3\n007\n4\n1000\n5\n00000\n3\n103\n4\n2020\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n103\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n153\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n153\n4\n1293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00001\n3\n103\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1010\n5\n00000\n3\n103\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n10000\n3\n153\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n0000\n5\n00000\n3\n153\n4\n1293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00010\n3\n103\n4\n2020\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n0000\n5\n00001\n3\n153\n4\n1293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n153\n4\n2293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n153\n4\n1293\n9\n115397328\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n10000\n3\n153\n4\n1187\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n262\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1100\n5\n00000\n3\n153\n4\n2293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n262\n4\n1626\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n262\n4\n1648\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00001\n3\n262\n4\n1648\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n103\n4\n2020\n9\n189517537\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1010\n5\n00001\n3\n103\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n10010\n3\n153\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n0010\n5\n00001\n3\n153\n4\n1293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n10000\n3\n153\n4\n1187\n9\n104148660\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n10001\n3\n153\n4\n1187\n9\n104148660\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n103\n4\n1247\n9\n100899543\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1001\n5\n10000\n3\n153\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n0000\n5\n00100\n3\n153\n4\n1293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00010\n3\n153\n4\n2293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00001\n3\n262\n4\n2126\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n10010\n3\n266\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n10000\n3\n153\n4\n1187\n9\n206673923\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n0100\n5\n00001\n3\n153\n4\n1780\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00001\n3\n262\n4\n2126\n9\n138073636\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00001\n3\n262\n4\n3741\n9\n138073636\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n143\n4\n2020\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1001\n5\n00000\n3\n153\n4\n1293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00001\n3\n103\n4\n1537\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1110\n5\n00000\n3\n103\n4\n1247\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n153\n4\n2293\n9\n147925138\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n153\n4\n1800\n9\n115397328\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n0000\n5\n00001\n3\n262\n4\n1648\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n10010\n3\n153\n4\n1247\n9\n129668769\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n103\n4\n1247\n9\n169501199\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n0100\n5\n00100\n3\n153\n4\n1293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n10010\n3\n153\n4\n2293\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00101\n3\n262\n4\n2126\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n10000\n3\n153\n4\n1187\n9\n270923964\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00001\n3\n207\n4\n2126\n9\n138073636\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1000\n5\n00000\n3\n143\n4\n2404\n9\n123456789\n30\n001678294039710047203946100020\n", "7\n3\n007\n4\n1011\n5\n00000\n3\n153\n4\n1293\n9\n123456789\n30\n001678294039710047203946100020\n"], "outputs": ["7\n2\n0\n5\n6\n53\n115\n", "7\n2\n0\n5\n17\n53\n115\n", "7\n2\n0\n11\n17\n53\n115\n", "7\n2\n0\n11\n18\n53\n115\n", "7\n2\n1\n5\n17\n53\n115\n", "7\n4\n0\n5\n17\n53\n115\n", "7\n2\n2\n11\n17\n53\n115\n", "7\n0\n0\n11\n18\n53\n115\n", "7\n2\n2\n5\n6\n53\n115\n", "7\n0\n1\n11\n18\n53\n115\n", "7\n2\n0\n11\n19\n53\n115\n", "7\n2\n0\n11\n18\n47\n115\n", "7\n2\n2\n11\n20\n53\n115\n", "7\n2\n0\n12\n17\n53\n115\n", "7\n4\n0\n11\n19\n53\n115\n", "7\n2\n0\n12\n18\n53\n115\n", "7\n2\n0\n12\n22\n53\n115\n", "7\n2\n1\n12\n22\n53\n115\n", "7\n2\n0\n5\n6\n54\n115\n", "7\n4\n1\n5\n17\n53\n115\n", "7\n2\n4\n11\n17\n53\n115\n", "7\n2\n1\n11\n18\n53\n115\n", "7\n2\n2\n11\n20\n37\n115\n", "7\n2\n3\n11\n20\n37\n115\n", "7\n2\n0\n5\n17\n45\n115\n", "7\n3\n2\n11\n17\n53\n115\n", "7\n0\n2\n11\n18\n53\n115\n", "7\n2\n2\n11\n19\n53\n115\n", "7\n2\n1\n12\n14\n53\n115\n", "7\n2\n4\n16\n17\n53\n115\n", "7\n2\n2\n11\n20\n45\n115\n", "7\n2\n1\n11\n19\n53\n115\n", "7\n2\n1\n12\n14\n44\n115\n", "7\n2\n1\n12\n18\n44\n115\n", "7\n2\n0\n10\n6\n53\n115\n", "7\n3\n0\n11\n18\n53\n115\n", "7\n2\n1\n5\n19\n53\n115\n", "7\n6\n0\n5\n17\n53\n115\n", "7\n2\n0\n11\n19\n48\n115\n", "7\n2\n0\n11\n11\n47\n115\n", "7\n0\n1\n12\n22\n53\n115\n", "7\n2\n4\n11\n17\n62\n115\n", "7\n2\n0\n5\n17\n48\n115\n", "7\n2\n2\n11\n18\n53\n115\n", "7\n2\n4\n11\n19\n53\n115\n", "7\n2\n3\n12\n14\n53\n115\n", "7\n2\n2\n11\n20\n49\n115\n", "7\n2\n1\n10\n14\n44\n115\n", "7\n2\n0\n10\n12\n53\n115\n", "7\n5\n0\n11\n18\n53\n115\n"]}, "starter_code": "", "problem_sha1": "49433deb113103273718500a624a6ac09bbb8527", "n_test_cases_total": 201, "n_test_cases_kept": 50, "test_cases_truncated": true, "seed_id": "cc-06503", "original_id": null, "source": "code_contests", "domain": "code", "test_case_format": "stdin_stdout", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": null}
{"seed_id": "apps-00001", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a permutation $p=[p_1, p_2, \\ldots, p_n]$ of integers from $1$ to $n$. Let's call the number $m$ ($1 \\le m \\le n$) beautiful, if there exists two indices $l, r$ ($1 \\le l \\le r \\le n$), such that the numbers $[p_l, p_{l+1}, \\ldots, p_r]$ is a permutation of numbers $1, 2, \\ldots, m$.\n\nFor example, let $p = [4, 5, 1, 3, 2, 6]$. In this case, the numbers $1, 3, 5, 6$ are beautiful and $2, 4$ are not. It is because:  if $l = 3$ and $r = 3$ we will have a permutation $[1]$ for $m = 1$;  if $l = 3$ and $r = 5$ we will have a permutation $[1, 3, 2]$ for $m = 3$;  if $l = 1$ and $r = 5$ we will have a permutation $[4, 5, 1, 3, 2]$ for $m = 5$;  if $l = 1$ and $r = 6$ we will have a permutation $[4, 5, 1, 3, 2, 6]$ for $m = 6$;  it is impossible to take some $l$ and $r$, such that $[p_l, p_{l+1}, \\ldots, p_r]$ is a permutation of numbers $1, 2, \\ldots, m$ for $m = 2$ and for $m = 4$. \n\nYou are given a permutation $p=[p_1, p_2, \\ldots, p_n]$. For all $m$ ($1 \\le m \\le n$) determine if it is a beautiful number or not.\n\n\n-----Input-----\n\nThe first line contains the only integer $t$ ($1 \\le t \\le 1000$)  — the number of test cases in the input. The next lines contain the description of test cases.\n\nThe first line of a test case contains a number $n$ ($1 \\le n \\le 2 \\cdot 10^5$) — the length of the given permutation $p$. The next line contains $n$ integers $p_1, p_2, \\ldots, p_n$ ($1 \\le p_i \\le n$, all $p_i$ are different) — the given permutation $p$.\n\nIt is guaranteed, that the sum of $n$ from all test cases in the input doesn't exceed $2 \\cdot 10^5$.\n\n\n-----Output-----\n\nPrint $t$ lines — the answers to test cases in the order they are given in the input. \n\nThe answer to a test case is the string of length $n$, there the $i$-th character is equal to $1$ if $i$ is a beautiful number and is equal to $0$ if $i$ is not a beautiful number.\n\n\n-----Example-----\nInput\n3\n6\n4 5 1 3 2 6\n5\n5 3 1 2 4\n4\n1 4 3 2\n\nOutput\n101011\n11111\n1001\n\n\n\n-----Note-----\n\nThe first test case is described in the problem statement.\n\nIn the second test case all numbers from $1$ to $5$ are beautiful:  if $l = 3$ and $r = 3$ we will have a permutation $[1]$ for $m = 1$;  if $l = 3$ and $r = 4$ we will have a permutation $[1, 2]$ for $m = 2$;  if $l = 2$ and $r = 4$ we will have a permutation $[3, 1, 2]$ for $m = 3$;  if $l = 2$ and $r = 5$ we will have a permutation $[3, 1, 2, 4]$ for $m = 4$;  if $l = 1$ and $r = 5$ we will have a permutation $[5, 3, 1, 2, 4]$ for $m = 5$.", "starter_code": "", "test_cases": {"inputs": ["3\n6\n4 5 1 3 2 6\n5\n5 3 1 2 4\n4\n1 4 3 2\n"], "outputs": ["101011\n11111\n1001\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "669a21c31720ff5a91b2e4a05b8df14114e6ecc8", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00006", "original_id": null, "source": "apps", "domain": "code", "problem": "Let's define the following recurrence: $$a_{n+1} = a_{n} + minDigit(a_{n}) \\cdot maxDigit(a_{n}).$$\n\nHere $minDigit(x)$ and $maxDigit(x)$ are the minimal and maximal digits in the decimal representation of $x$ without leading zeroes. For examples refer to notes.\n\nYour task is calculate $a_{K}$ for given $a_{1}$ and $K$.\n\n\n-----Input-----\n\nThe first line contains one integer $t$ ($1 \\le t \\le 1000$) — the number of independent test cases.\n\nEach test case consists of a single line containing two integers $a_{1}$ and $K$ ($1 \\le a_{1} \\le 10^{18}$, $1 \\le K \\le 10^{16}$) separated by a space.\n\n\n-----Output-----\n\nFor each test case print one integer $a_{K}$ on a separate line.\n\n\n-----Example-----\nInput\n8\n1 4\n487 1\n487 2\n487 3\n487 4\n487 5\n487 6\n487 7\n\nOutput\n42\n487\n519\n528\n544\n564\n588\n628\n\n\n\n-----Note-----\n\n$a_{1} = 487$ \n\n $a_{2} = a_{1} + minDigit(a_{1}) \\cdot maxDigit(a_{1}) = 487 + \\min (4, 8, 7) \\cdot \\max (4, 8, 7) = 487 + 4 \\cdot 8 = 519$ \n\n $a_{3} = a_{2} + minDigit(a_{2}) \\cdot maxDigit(a_{2}) = 519 + \\min (5, 1, 9) \\cdot \\max (5, 1, 9) = 519 + 1 \\cdot 9 = 528$ \n\n $a_{4} = a_{3} + minDigit(a_{3}) \\cdot maxDigit(a_{3}) = 528 + \\min (5, 2, 8) \\cdot \\max (5, 2, 8) = 528 + 2 \\cdot 8 = 544$ \n\n $a_{5} = a_{4} + minDigit(a_{4}) \\cdot maxDigit(a_{4}) = 544 + \\min (5, 4, 4) \\cdot \\max (5, 4, 4) = 544 + 4 \\cdot 5 = 564$ \n\n $a_{6} = a_{5} + minDigit(a_{5}) \\cdot maxDigit(a_{5}) = 564 + \\min (5, 6, 4) \\cdot \\max (5, 6, 4) = 564 + 4 \\cdot 6 = 588$ \n\n $a_{7} = a_{6} + minDigit(a_{6}) \\cdot maxDigit(a_{6}) = 588 + \\min (5, 8, 8) \\cdot \\max (5, 8, 8) = 588 + 5 \\cdot 8 = 628$", "starter_code": "", "test_cases": {"inputs": ["8\n1 4\n487 1\n487 2\n487 3\n487 4\n487 5\n487 6\n487 7\n"], "outputs": ["42\n487\n519\n528\n544\n564\n588\n628\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "68b2039327bbd5dc9a8eb3bb79b619f85d87978b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00011", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a binary string $s$ (recall that a string is binary if each character is either $0$ or $1$).\n\nLet $f(t)$ be the decimal representation of integer $t$ written in binary form (possibly with leading zeroes). For example $f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0$ and $f(000100) = 4$.\n\nThe substring $s_{l}, s_{l+1}, \\dots , s_{r}$ is good if $r - l + 1 = f(s_l \\dots s_r)$.\n\nFor example string $s = 1011$ has $5$ good substrings: $s_1 \\dots s_1 = 1$, $s_3 \\dots s_3 = 1$, $s_4 \\dots s_4 = 1$, $s_1 \\dots s_2 = 10$ and $s_2 \\dots s_4 = 011$. \n\nYour task is to calculate the number of good substrings of string $s$.\n\nYou have to answer $t$ independent queries.\n\n\n-----Input-----\n\nThe first line contains one integer $t$ ($1 \\le t \\le 1000$) — the number of queries.\n\nThe only line of each query contains string $s$ ($1 \\le |s| \\le 2 \\cdot 10^5$), consisting of only digits $0$ and $1$.\n\nIt is guaranteed that $\\sum\\limits_{i=1}^{t} |s_i| \\le 2 \\cdot 10^5$.\n\n\n-----Output-----\n\nFor each query print one integer — the number of good substrings of string $s$.\n\n\n-----Example-----\nInput\n4\n0110\n0101\n00001000\n0001000\n\nOutput\n4\n3\n4\n3", "starter_code": "", "test_cases": {"inputs": ["4\n0110\n0101\n00001000\n0001000\n"], "outputs": ["4\n3\n4\n3\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "00275335c12c1da3036033aa2e25e08b699100b3", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00016", "original_id": null, "source": "apps", "domain": "code", "problem": "Word $s$ of length $n$ is called $k$-complete if   $s$ is a palindrome, i.e. $s_i=s_{n+1-i}$ for all $1 \\le i \\le n$;  $s$ has a period of $k$, i.e. $s_i=s_{k+i}$ for all $1 \\le i \\le n-k$. \n\nFor example, \"abaaba\" is a $3$-complete word, while \"abccba\" is not.\n\nBob is given a word $s$ of length $n$ consisting of only lowercase Latin letters and an integer $k$, such that $n$ is divisible by $k$. He wants to convert $s$ to any $k$-complete word.\n\nTo do this Bob can choose some $i$ ($1 \\le i \\le n$) and replace the letter at position $i$ with some other lowercase Latin letter.\n\nSo now Bob wants to know the minimum number of letters he has to replace to convert $s$ to any $k$-complete word.\n\nNote that Bob can do zero changes if the word $s$ is already $k$-complete.\n\nYou are required to answer $t$ test cases independently.\n\n\n-----Input-----\n\nThe first line contains a single integer $t$ ($1 \\le t\\le 10^5$) — the number of test cases.\n\nThe first line of each test case contains two integers $n$ and $k$ ($1 \\le k < n \\le 2 \\cdot 10^5$, $n$ is divisible by $k$).\n\nThe second line of each test case contains a word $s$ of length $n$.\n\nIt is guaranteed that word $s$ only contains lowercase Latin letters. And it is guaranteed that the sum of $n$ over all test cases will not exceed $2 \\cdot 10^5$.\n\n\n-----Output-----\n\nFor each test case, output one integer, representing the minimum number of characters he has to replace to convert $s$ to any $k$-complete word.\n\n\n-----Example-----\nInput\n4\n6 2\nabaaba\n6 3\nabaaba\n36 9\nhippopotomonstrosesquippedaliophobia\n21 7\nwudixiaoxingxingheclp\n\nOutput\n2\n0\n23\n16\n\n\n\n-----Note-----\n\nIn the first test case, one optimal solution is aaaaaa.\n\nIn the second test case, the given word itself is $k$-complete.", "starter_code": "", "test_cases": {"inputs": ["4\n6 2\nabaaba\n6 3\nabaaba\n36 9\nhippopotomonstrosesquippedaliophobia\n21 7\nwudixiaoxingxingheclp\n"], "outputs": ["2\n0\n23\n16\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "af85848f267a4f8ce4de989942eb1822499e4b38", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00021", "original_id": null, "source": "apps", "domain": "code", "problem": "Berland year consists of $m$ months with $d$ days each. Months are numbered from $1$ to $m$. Berland week consists of $w$ days. The first day of the year is also the first day of the week. Note that the last week of the year might be shorter than $w$ days.\n\nA pair $(x, y)$ such that $x < y$ is ambiguous if day $x$ of month $y$ is the same day of the week as day $y$ of month $x$.\n\nCount the number of ambiguous pairs.\n\n\n-----Input-----\n\nThe first line contains a single integer $t$ ($1 \\le t \\le 1000$) — the number of testcases.\n\nEach of the next $t$ lines contains three integers $m$, $d$ and $w$ ($1 \\le m, d, w \\le 10^9$) — the number of months in a year, the number of days in a month and the number of days in a week.\n\n\n-----Output-----\n\nPrint $t$ integers — for each testcase output the number of pairs $(x, y)$ such that $x < y$ and day $x$ of month $y$ is the same day of the week as day $y$ of month $x$.\n\n\n-----Example-----\nInput\n5\n6 7 4\n10 7 12\n12 30 7\n1 1 1\n3247834 10298779 625324\n\nOutput\n6\n9\n5\n0\n116461800\n\n\n\n-----Note-----\n\nHere are the pairs for the first test case:  $$", "starter_code": "", "test_cases": {"inputs": ["5\n6 7 4\n10 7 12\n12 30 7\n1 1 1\n3247834 10298779 625324\n"], "outputs": ["6\n9\n5\n0\n116461800\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "bd67bebcc19838cb8d71b2bbce47c5709c794b31", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00026", "original_id": null, "source": "apps", "domain": "code", "problem": "Your task is to calculate ab mod 1337 where a is a positive integer and b is an extremely large positive integer given in the form of an array.\n\n\nExample1:\n\na = 2\nb = [3]\n\nResult: 8\n\n\n\nExample2:\n\na = 2\nb = [1,0]\n\nResult: 1024\n\n\n\nCredits:Special thanks to @Stomach_ache for adding this problem and creating all test cases.", "starter_code": "\nclass Solution:\n    def superPow(self, a: int, b: List[int]) -> int:\n        ", "test_cases": {"inputs": [[2, [3]]], "outputs": [8], "fn_name": "superPow"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "a0298302675db23235a4d60abe0e6fc7bd59593e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "superPow"}
{"seed_id": "apps-00031", "original_id": null, "source": "apps", "domain": "code", "problem": "In a country popular for train travel, you have planned some train travelling one year in advance.  The days of the year that you will travel is given as an array days.  Each day is an integer from 1 to 365.\nTrain tickets are sold in 3 different ways:\n\na 1-day pass is sold for costs[0] dollars;\na 7-day pass is sold for costs[1] dollars;\na 30-day pass is sold for costs[2] dollars.\n\nThe passes allow that many days of consecutive travel.  For example, if we get a 7-day pass on day 2, then we can travel for 7 days: day 2, 3, 4, 5, 6, 7, and 8.\nReturn the minimum number of dollars you need to travel every day in the given list of days.\n \nExample 1:\nInput: days = [1,4,6,7,8,20], costs = [2,7,15]\nOutput: 11\nExplanation: \nFor example, here is one way to buy passes that lets you travel your travel plan:\nOn day 1, you bought a 1-day pass for costs[0] = $2, which covered day 1.\nOn day 3, you bought a 7-day pass for costs[1] = $7, which covered days 3, 4, ..., 9.\nOn day 20, you bought a 1-day pass for costs[0] = $2, which covered day 20.\nIn total you spent $11 and covered all the days of your travel.\n\n\nExample 2:\nInput: days = [1,2,3,4,5,6,7,8,9,10,30,31], costs = [2,7,15]\nOutput: 17\nExplanation: \nFor example, here is one way to buy passes that lets you travel your travel plan:\nOn day 1, you bought a 30-day pass for costs[2] = $15 which covered days 1, 2, ..., 30.\nOn day 31, you bought a 1-day pass for costs[0] = $2 which covered day 31.\nIn total you spent $17 and covered all the days of your travel.\n\n \n\nNote:\n\n1 <= days.length <= 365\n1 <= days[i] <= 365\ndays is in strictly increasing order.\ncosts.length == 3\n1 <= costs[i] <= 1000", "starter_code": "\nclass Solution:\n    def mincostTickets(self, days: List[int], costs: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[1, 4, 6, 7, 8, 20], [2, 7, 15]]], "outputs": [11], "fn_name": "mincostTickets"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "7e3b85263c9c7a5b6c58113db40c7b2e674a9f04", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "mincostTickets"}
{"seed_id": "apps-00036", "original_id": null, "source": "apps", "domain": "code", "problem": "We are given an array A of N lowercase letter strings, all of the same length.\nNow, we may choose any set of deletion indices, and for each string, we delete all the characters in those indices.\nFor example, if we have an array A = [\"abcdef\",\"uvwxyz\"] and deletion indices {0, 2, 3}, then the final array after deletions is [\"bef\",\"vyz\"].\nSuppose we chose a set of deletion indices D such that after deletions, the final array has its elements in lexicographic order (A[0] <= A[1] <= A[2] ... <= A[A.length - 1]).\nReturn the minimum possible value of D.length.\n \n\n\n\n\n\n\n\nExample 1:\nInput: [\"ca\",\"bb\",\"ac\"]\nOutput: 1\nExplanation: \nAfter deleting the first column, A = [\"a\", \"b\", \"c\"].\nNow A is in lexicographic order (ie. A[0] <= A[1] <= A[2]).\nWe require at least 1 deletion since initially A was not in lexicographic order, so the answer is 1.\n\n\nExample 2:\nInput: [\"xc\",\"yb\",\"za\"]\nOutput: 0\nExplanation: \nA is already in lexicographic order, so we don't need to delete anything.\nNote that the rows of A are not necessarily in lexicographic order:\nie. it is NOT necessarily true that (A[0][0] <= A[0][1] <= ...)\n\n\nExample 3:\nInput: [\"zyx\",\"wvu\",\"tsr\"]\nOutput: 3\nExplanation: \nWe have to delete every column.\n\n \n\n\nNote:\n\n1 <= A.length <= 100\n1 <= A[i].length <= 100", "starter_code": "\nclass Solution:\n    def minDeletionSize(self, A: List[str]) -> int:\n        ", "test_cases": {"inputs": [[["\"ca\"", "\"bb\"", "\"ac\""]]], "outputs": [1], "fn_name": "minDeletionSize"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d1a73b814014f4db09a29a15e15af18ae85ecce4", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minDeletionSize"}
{"seed_id": "apps-00041", "original_id": null, "source": "apps", "domain": "code", "problem": "Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step: \n\nCopy All: You can copy all the characters present on the notepad (partial copy is not allowed).\nPaste: You can paste the characters which are copied last time.\n\n\n\n\nGiven a number n. You have to get exactly n 'A' on the notepad by performing the minimum number of steps permitted. Output the minimum number of steps to get n 'A'. \n\n\nExample 1:\n\nInput: 3\nOutput: 3\nExplanation:\nIntitally, we have one character 'A'.\nIn step 1, we use Copy All operation.\nIn step 2, we use Paste operation to get 'AA'.\nIn step 3, we use Paste operation to get 'AAA'.\n\n\n\n\nNote:\n\nThe n will be in the range [1, 1000].", "starter_code": "\nclass Solution:\n    def minSteps(self, n: int) -> int:\n        ", "test_cases": {"inputs": [[3]], "outputs": [3], "fn_name": "minSteps"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "55558e2c3162225793c3a0966e5eebf8e8b01769", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minSteps"}
{"seed_id": "apps-00046", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string s, a k duplicate removal consists of choosing k adjacent and equal letters from s and removing them causing the left and the right side of the deleted substring to concatenate together.\nWe repeatedly make k duplicate removals on s until we no longer can.\nReturn the final string after all such duplicate removals have been made.\nIt is guaranteed that the answer is unique.\n \nExample 1:\nInput: s = \"abcd\", k = 2\nOutput: \"abcd\"\nExplanation: There's nothing to delete.\nExample 2:\nInput: s = \"deeedbbcccbdaa\", k = 3\nOutput: \"aa\"\nExplanation: \nFirst delete \"eee\" and \"ccc\", get \"ddbbbdaa\"\nThen delete \"bbb\", get \"dddaa\"\nFinally delete \"ddd\", get \"aa\"\nExample 3:\nInput: s = \"pbbcggttciiippooaais\", k = 2\nOutput: \"ps\"\n\n \nConstraints:\n\n1 <= s.length <= 10^5\n2 <= k <= 10^4\ns only contains lower case English letters.", "starter_code": "\nclass Solution:\n    def removeDuplicates(self, s: str, k: int) -> str:\n        ", "test_cases": {"inputs": [["\"abcd\"", 2]], "outputs": ["\"abcd\""], "fn_name": "removeDuplicates"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b27afa50a93f635f29f6c28bc23f83be4c28949d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "removeDuplicates"}
{"seed_id": "apps-00051", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a rectangular cake with height h and width w, and two arrays of integers horizontalCuts and verticalCuts where horizontalCuts[i] is the distance from the top of the rectangular cake to the ith horizontal cut and similarly, verticalCuts[j] is the distance from the left of the rectangular cake to the jth vertical cut.\nReturn the maximum area of a piece of cake after you cut at each horizontal and vertical position provided in the arrays horizontalCuts and verticalCuts. Since the answer can be a huge number, return this modulo 10^9 + 7.\n \nExample 1:\n\nInput: h = 5, w = 4, horizontalCuts = [1,2,4], verticalCuts = [1,3]\nOutput: 4 \nExplanation: The figure above represents the given rectangular cake. Red lines are the horizontal and vertical cuts. After you cut the cake, the green piece of cake has the maximum area.\n\nExample 2:\n\nInput: h = 5, w = 4, horizontalCuts = [3,1], verticalCuts = [1]\nOutput: 6\nExplanation: The figure above represents the given rectangular cake. Red lines are the horizontal and vertical cuts. After you cut the cake, the green and yellow pieces of cake have the maximum area.\n\nExample 3:\nInput: h = 5, w = 4, horizontalCuts = [3], verticalCuts = [3]\nOutput: 9\n\n \nConstraints:\n\n2 <= h, w <= 10^9\n1 <= horizontalCuts.length < min(h, 10^5)\n1 <= verticalCuts.length < min(w, 10^5)\n1 <= horizontalCuts[i] < h\n1 <= verticalCuts[i] < w\nIt is guaranteed that all elements in horizontalCuts are distinct.\nIt is guaranteed that all elements in verticalCuts are distinct.", "starter_code": "\nclass Solution:\n    def maxArea(self, h: int, w: int, horizontalCuts: List[int], verticalCuts: List[int]) -> int:\n        ", "test_cases": {"inputs": [[5, 4, [1, 2, 4], [1, 3]]], "outputs": [4], "fn_name": "maxArea"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "7a8a401d14e5799217b69d26b9a4b9402f068946", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maxArea"}
{"seed_id": "apps-00056", "original_id": null, "source": "apps", "domain": "code", "problem": "Alex and Lee play a game with piles of stones.  There are an even number of piles arranged in a row, and each pile has a positive integer number of stones piles[i].\nThe objective of the game is to end with the most stones.  The total number of stones is odd, so there are no ties.\nAlex and Lee take turns, with Alex starting first.  Each turn, a player takes the entire pile of stones from either the beginning or the end of the row.  This continues until there are no more piles left, at which point the person with the most stones wins.\nAssuming Alex and Lee play optimally, return True if and only if Alex wins the game.\n \nExample 1:\nInput: piles = [5,3,4,5]\nOutput: true\nExplanation: \nAlex starts first, and can only take the first 5 or the last 5.\nSay he takes the first 5, so that the row becomes [3, 4, 5].\nIf Lee takes 3, then the board is [4, 5], and Alex takes 5 to win with 10 points.\nIf Lee takes the last 5, then the board is [3, 4], and Alex takes 4 to win with 9 points.\nThis demonstrated that taking the first 5 was a winning move for Alex, so we return true.\n\n \nConstraints:\n\n2 <= piles.length <= 500\npiles.length is even.\n1 <= piles[i] <= 500\nsum(piles) is odd.", "starter_code": "\nclass Solution:\n    def stoneGame(self, piles: List[int]) -> bool:\n", "test_cases": {"inputs": [[[5, 3, 4, 5]]], "outputs": [true], "fn_name": "stoneGame"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "016efb554e82c3fc098b75068813135dfe553850", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "stoneGame"}
{"seed_id": "apps-00061", "original_id": null, "source": "apps", "domain": "code", "problem": "Given 3 positives numbers a, b and c. Return the minimum flips required in some bits of a and b to make ( a OR b == c ). (bitwise OR operation).\nFlip operation consists of change any single bit 1 to 0 or change the bit 0 to 1 in their binary representation.\n \nExample 1:\n\nInput: a = 2, b = 6, c = 5\nOutput: 3\nExplanation: After flips a = 1 , b = 4 , c = 5 such that (a OR b == c)\nExample 2:\nInput: a = 4, b = 2, c = 7\nOutput: 1\n\nExample 3:\nInput: a = 1, b = 2, c = 3\nOutput: 0\n\n \nConstraints:\n\n1 <= a <= 10^9\n1 <= b <= 10^9\n1 <= c <= 10^9", "starter_code": "\nclass Solution:\n    def minFlips(self, a: int, b: int, c: int) -> int:\n        ", "test_cases": {"inputs": [[2, 6, 5]], "outputs": [3], "fn_name": "minFlips"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b8f9f1e0a2946c45fafb2c383c3c21f1f459be2e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minFlips"}
{"seed_id": "apps-00066", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an integer array nums, find the contiguous subarray within an array (containing at least one number) which has the largest product.\n\nExample 1:\n\n\nInput: [2,3,-2,4]\nOutput: 6\nExplanation: [2,3] has the largest product 6.\n\n\nExample 2:\n\n\nInput: [-2,0,-1]\nOutput: 0\nExplanation: The result cannot be 2, because [-2,-1] is not a subarray.", "starter_code": "\nclass Solution:\n    def maxProduct(self, nums: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[2, 3, -2, 4]]], "outputs": [6], "fn_name": "maxProduct"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "59eb78449fc4f2e9c076420417645e6a769c266d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maxProduct"}
{"seed_id": "apps-00071", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.\n\nBelow is one possible representation of s1 = \"great\":\n\n\n    great\n   /    \\\n  gr    eat\n / \\    /  \\\ng   r  e   at\n           / \\\n          a   t\n\n\nTo scramble the string, we may choose any non-leaf node and swap its two children.\n\nFor example, if we choose the node \"gr\" and swap its two children, it produces a scrambled string \"rgeat\".\n\n\n    rgeat\n   /    \\\n  rg    eat\n / \\    /  \\\nr   g  e   at\n           / \\\n          a   t\n\n\nWe say that \"rgeat\" is a scrambled string of \"great\".\n\nSimilarly, if we continue to swap the children of nodes \"eat\" and \"at\", it produces a scrambled string \"rgtae\".\n\n\n    rgtae\n   /    \\\n  rg    tae\n / \\    /  \\\nr   g  ta  e\n       / \\\n      t   a\n\n\nWe say that \"rgtae\" is a scrambled string of \"great\".\n\nGiven two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.\n\nExample 1:\n\n\nInput: s1 = \"great\", s2 = \"rgeat\"\nOutput: true\n\n\nExample 2:\n\n\nInput: s1 = \"abcde\", s2 = \"caebd\"\nOutput: false", "starter_code": "\nclass Solution:\n    def isScramble(self, s1: str, s2: str) -> bool:\n        ", "test_cases": {"inputs": [["\"great\"", "\"rgeat\""]], "outputs": [true], "fn_name": "isScramble"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "014e5edaa9601bd6371ceb91af889077deb113df", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "isScramble"}
{"seed_id": "apps-00076", "original_id": null, "source": "apps", "domain": "code", "problem": "Given two arrays nums1 and nums2.\nReturn the maximum dot product between non-empty subsequences of nums1 and nums2 with the same length.\nA subsequence of a array is a new array which is formed from the original array by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, [2,3,5] is a subsequence of [1,2,3,4,5] while [1,5,3] is not).\n \nExample 1:\nInput: nums1 = [2,1,-2,5], nums2 = [3,0,-6]\nOutput: 18\nExplanation: Take subsequence [2,-2] from nums1 and subsequence [3,-6] from nums2.\nTheir dot product is (2*3 + (-2)*(-6)) = 18.\nExample 2:\nInput: nums1 = [3,-2], nums2 = [2,-6,7]\nOutput: 21\nExplanation: Take subsequence [3] from nums1 and subsequence [7] from nums2.\nTheir dot product is (3*7) = 21.\nExample 3:\nInput: nums1 = [-1,-1], nums2 = [1,1]\nOutput: -1\nExplanation: Take subsequence [-1] from nums1 and subsequence [1] from nums2.\nTheir dot product is -1.\n \nConstraints:\n\n1 <= nums1.length, nums2.length <= 500\n-1000 <= nums1[i], nums2[i] <= 1000", "starter_code": "\nclass Solution:\n    def maxDotProduct(self, nums1: List[int], nums2: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[2, 1, -2, 5], [3, 0, -6]]], "outputs": [18], "fn_name": "maxDotProduct"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "721fbd1d8d94932482d12bf0b6b2806af26b2021", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maxDotProduct"}
{"seed_id": "apps-00081", "original_id": null, "source": "apps", "domain": "code", "problem": "Convert a non-negative integer to its english words representation. Given input is guaranteed to be less than 231 - 1.\n\nExample 1:\n\n\nInput: 123\nOutput: \"One Hundred Twenty Three\"\n\n\nExample 2:\n\n\nInput: 12345\nOutput: \"Twelve Thousand Three Hundred Forty Five\"\n\nExample 3:\n\n\nInput: 1234567\nOutput: \"One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven\"\n\n\nExample 4:\n\n\nInput: 1234567891\nOutput: \"One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety One\"", "starter_code": "\nclass Solution:\n    def numberToWords(self, num: int) -> str:\n        ", "test_cases": {"inputs": [[123]], "outputs": ["One Hundred Twenty Three"], "fn_name": "numberToWords"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e208c61565ee9373dce50f2260dbff4452365276", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "numberToWords"}
{"seed_id": "apps-00086", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array of integers nums and a positive integer k, find whether it's possible to divide this array into k non-empty subsets whose sums are all equal.\n\nExample 1:\n\nInput: nums = [4, 3, 2, 3, 5, 2, 1], k = 4\nOutput: True\nExplanation: It's possible to divide it into 4 subsets (5), (1, 4), (2,3), (2,3) with equal sums.\n\n\n\nNote:\n1 .\n0 < nums[i] < 10000.", "starter_code": "\nclass Solution:\n    def canPartitionKSubsets(self, nums: List[int], k: int) -> bool:\n        ", "test_cases": {"inputs": [[[5, 4, 3, 3, 2, 2, 1], 4]], "outputs": [true], "fn_name": "canPartitionKSubsets"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "becbedf33c42fc356272cb8ec60ed2167f41988c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "canPartitionKSubsets"}
{"seed_id": "apps-00091", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an unsorted array of integers, find the length of the longest consecutive elements sequence.\n\nYour algorithm should run in O(n) complexity.\n\nExample:\n\n\nInput: [100, 4, 200, 1, 3, 2]\nOutput: 4\nExplanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.", "starter_code": "\nclass Solution:\n    def longestConsecutive(self, nums: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[100, 4, 200, 1, 3, 2]]], "outputs": [4], "fn_name": "longestConsecutive"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "7e85903b5c035745f04bbb6d7a9acf6be66a17e3", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "longestConsecutive"}
{"seed_id": "apps-00096", "original_id": null, "source": "apps", "domain": "code", "problem": "Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.\n\n(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).\n\nYou are given a target value to search. If found in the array return its index, otherwise return -1.\n\nYou may assume no duplicate exists in the array.\n\nYour algorithm's runtime complexity must be in the order of O(log n).\n\nExample 1:\n\n\nInput: nums = [4,5,6,7,0,1,2], target = 0\nOutput: 4\n\n\nExample 2:\n\n\nInput: nums = [4,5,6,7,0,1,2], target = 3\nOutput: -1", "starter_code": "\nclass Solution:\n    def search(self, nums: List[int], target: int) -> int:\n        ", "test_cases": {"inputs": [[[4, 5, 6, 7, 0, 1, 2], 0]], "outputs": [4], "fn_name": "search"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "06e86afc70691d4e9a17890fc11025af172a12ab", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "search"}
{"seed_id": "apps-00101", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array of integers, find out whether there are two distinct indices i and j in the array such that the absolute difference between nums[i] and nums[j] is at most t and the absolute difference between i and j is at most k.\n\n\nExample 1:\n\n\nInput: nums = [1,2,3,1], k = 3, t = 0\nOutput: true\n\n\n\nExample 2:\n\n\nInput: nums = [1,0,1,1], k = 1, t = 2\nOutput: true\n\n\n\nExample 3:\n\n\nInput: nums = [1,5,9,1,5,9], k = 2, t = 3\nOutput: false", "starter_code": "\nclass Solution:\n    def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:\n        ", "test_cases": {"inputs": [[[1, 2, 3, 1], 3, 0]], "outputs": [true], "fn_name": "containsNearbyAlmostDuplicate"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "7821b25cb2a9765ed7e199e12bf0f0128b6836a6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "containsNearbyAlmostDuplicate"}
{"seed_id": "apps-00106", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array nums of positive integers. Your task is to select some subset of nums, multiply each element by an integer and add all these numbers. The array is said to be good if you can obtain a sum of 1 from the array by any possible subset and multiplicand.\nReturn True if the array is good otherwise return False.\n \nExample 1:\nInput: nums = [12,5,7,23]\nOutput: true\nExplanation: Pick numbers 5 and 7.\n5*3 + 7*(-2) = 1\n\nExample 2:\nInput: nums = [29,6,10]\nOutput: true\nExplanation: Pick numbers 29, 6 and 10.\n29*1 + 6*(-3) + 10*(-1) = 1\n\nExample 3:\nInput: nums = [3,6]\nOutput: false\n\n \nConstraints:\n\n1 <= nums.length <= 10^5\n1 <= nums[i] <= 10^9", "starter_code": "\nclass Solution:\n    def isGoodArray(self, nums: List[int]) -> bool:\n        ", "test_cases": {"inputs": [[[12, 5, 7, 23]]], "outputs": [true], "fn_name": "isGoodArray"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "27ef98324660081ad893d48900049a9ec6d24280", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "isGoodArray"}
{"seed_id": "apps-00111", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string S, consider all duplicated substrings: (contiguous) substrings of S that occur 2 or more times.  (The occurrences may overlap.)\nReturn any duplicated substring that has the longest possible length.  (If S does not have a duplicated substring, the answer is \"\".)\n \nExample 1:\nInput: \"banana\"\nOutput: \"ana\"\n\nExample 2:\nInput: \"abcd\"\nOutput: \"\"\n\n \nNote:\n\n2 <= S.length <= 10^5\nS consists of lowercase English letters.", "starter_code": "\nclass Solution:\n    def longestDupSubstring(self, S: str) -> str:\n        ", "test_cases": {"inputs": [["\"banana\""]], "outputs": ["ana"], "fn_name": "longestDupSubstring"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b6f30fe4edb036e2f76a50a65f3979527ad83d0a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "longestDupSubstring"}
{"seed_id": "apps-00116", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.\nReturn the number of permutations of A that are squareful.  Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].\n \nExample 1:\nInput: [1,17,8]\nOutput: 2\nExplanation: \n[1,8,17] and [17,8,1] are the valid permutations.\n\nExample 2:\nInput: [2,2,2]\nOutput: 1\n\n \nNote:\n\n1 <= A.length <= 12\n0 <= A[i] <= 1e9", "starter_code": "\nclass Solution:\n    def numSquarefulPerms(self, A: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[1, 17, 8]]], "outputs": [2], "fn_name": "numSquarefulPerms"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e1c41b9e95b7188af64e38e41b6aaa200163feb0", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "numSquarefulPerms"}
{"seed_id": "apps-00121", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an unsorted integer array, find the smallest missing positive integer.\n\nExample 1:\n\n\nInput: [1,2,0]\nOutput: 3\n\n\nExample 2:\n\n\nInput: [3,4,-1,1]\nOutput: 2\n\n\nExample 3:\n\n\nInput: [7,8,9,11,12]\nOutput: 1\n\n\nNote:\n\nYour algorithm should run in O(n) time and uses constant extra space.", "starter_code": "\nclass Solution:\n    def firstMissingPositive(self, nums: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[0, 1, 2, 0]]], "outputs": [3], "fn_name": "firstMissingPositive"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d7b0e2f98b034b78b375de424a3b97733f1822a7", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "firstMissingPositive"}
{"seed_id": "apps-00126", "original_id": null, "source": "apps", "domain": "code", "problem": "Say you have an array for which the ith element is the price of a given stock on day i.\n\nDesign an algorithm to find the maximum profit. You may complete at most two transactions.\n\nNote: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).\n\nExample 1:\n\n\nInput: [3,3,5,0,0,3,1,4]\nOutput: 6\nExplanation: Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.\n             Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.\n\nExample 2:\n\n\nInput: [1,2,3,4,5]\nOutput: 4\nExplanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.\n             Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are\n             engaging multiple transactions at the same time. You must sell before buying again.\n\n\nExample 3:\n\n\nInput: [7,6,4,3,1]\nOutput: 0\nExplanation: In this case, no transaction is done, i.e. max profit = 0.", "starter_code": "\nclass Solution:\n    def maxProfit(self, prices: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[3, 3, 5, 0, 0, 3, 1, 4]]], "outputs": [6], "fn_name": "maxProfit"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "3b7c0c199d2e85c3bf40dba417c2afc2db5bd27a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maxProfit"}
{"seed_id": "apps-00131", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a list of positive integers, the adjacent integers will perform the float division. For example, [2,3,4] -> 2 / 3 / 4.\n\nHowever, you can add any number of parenthesis at any position to change the priority of operations. You should find out how to add parenthesis to get the maximum result, and return the corresponding expression in string format. Your expression should NOT contain redundant parenthesis.\n\nExample:\n\nInput: [1000,100,10,2]\nOutput: \"1000/(100/10/2)\"\nExplanation:\n1000/(100/10/2) = 1000/((100/10)/2) = 200\nHowever, the bold parenthesis in \"1000/((100/10)/2)\" are redundant, since they don't influence the operation priority. So you should return \"1000/(100/10/2)\". \n\nOther cases:\n1000/(100/10)/2 = 50\n1000/(100/(10/2)) = 50\n1000/100/10/2 = 0.5\n1000/100/(10/2) = 2\n\n\n\nNote:\n\nThe length of the input array is [1, 10].\nElements in the given array will be in range [2, 1000].\nThere is only one optimal division for each test case.", "starter_code": "\nclass Solution:\n    def optimalDivision(self, nums: List[int]) -> str:\n        ", "test_cases": {"inputs": [[[1000, 100, 10, 2]]], "outputs": ["1000/(100/10/2)"], "fn_name": "optimalDivision"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8fd6ea5371bb7df61f6467b930210e3c54433c5a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "optimalDivision"}
{"seed_id": "apps-00136", "original_id": null, "source": "apps", "domain": "code", "problem": "There is a one-dimensional garden on the x-axis. The garden starts at the point 0 and ends at the point n. (i.e The length of the garden is n).\nThere are n + 1 taps located at points [0, 1, ..., n] in the garden.\nGiven an integer n and an integer array ranges of length n + 1 where ranges[i] (0-indexed) means the i-th tap can water the area [i - ranges[i], i + ranges[i]] if it was open.\nReturn the minimum number of taps that should be open to water the whole garden, If the garden cannot be watered return -1.\n \nExample 1:\n\nInput: n = 5, ranges = [3,4,1,1,0,0]\nOutput: 1\nExplanation: The tap at point 0 can cover the interval [-3,3]\nThe tap at point 1 can cover the interval [-3,5]\nThe tap at point 2 can cover the interval [1,3]\nThe tap at point 3 can cover the interval [2,4]\nThe tap at point 4 can cover the interval [4,4]\nThe tap at point 5 can cover the interval [5,5]\nOpening Only the second tap will water the whole garden [0,5]\n\nExample 2:\nInput: n = 3, ranges = [0,0,0,0]\nOutput: -1\nExplanation: Even if you activate all the four taps you cannot water the whole garden.\n\nExample 3:\nInput: n = 7, ranges = [1,2,1,0,2,1,0,1]\nOutput: 3\n\nExample 4:\nInput: n = 8, ranges = [4,0,0,0,0,0,0,0,4]\nOutput: 2\n\nExample 5:\nInput: n = 8, ranges = [4,0,0,0,4,0,0,0,4]\nOutput: 1\n\n \nConstraints:\n\n1 <= n <= 10^4\nranges.length == n + 1\n0 <= ranges[i] <= 100", "starter_code": "\nclass Solution:\n    def minTaps(self, n: int, ranges: List[int]) -> int:\n        ", "test_cases": {"inputs": [[5, [3, 4, 1, 1, 0, 0]]], "outputs": [1], "fn_name": "minTaps"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "bf85f36c76501a8d8a184591bfea946bdb1a40eb", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minTaps"}
{"seed_id": "apps-00141", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a non-empty string containing an out-of-order English representation of digits 0-9, output the digits in ascending order.\n\nNote:\n\nInput contains only lowercase English letters.\nInput is guaranteed to be valid and can be transformed to its original digits. That means invalid inputs such as \"abc\" or \"zerone\" are not permitted.\nInput length is less than 50,000.\n\n\n\nExample 1:\n\nInput: \"owoztneoer\"\n\nOutput: \"012\"\n\n\n\nExample 2:\n\nInput: \"fviefuro\"\n\nOutput: \"45\"", "starter_code": "\nclass Solution:\n    def originalDigits(self, s: str) -> str:\n        ", "test_cases": {"inputs": [["\"owoztneoer\""]], "outputs": ["012"], "fn_name": "originalDigits"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "7b19aa45eecbd4a198264b3247ef7ceed5ae2314", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "originalDigits"}
{"seed_id": "apps-00146", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array of strings arr. String s is a concatenation of a sub-sequence of arr which have unique characters.\nReturn the maximum possible length of s.\n \nExample 1:\nInput: arr = [\"un\",\"iq\",\"ue\"]\nOutput: 4\nExplanation: All possible concatenations are \"\",\"un\",\"iq\",\"ue\",\"uniq\" and \"ique\".\nMaximum length is 4.\n\nExample 2:\nInput: arr = [\"cha\",\"r\",\"act\",\"ers\"]\nOutput: 6\nExplanation: Possible solutions are \"chaers\" and \"acters\".\n\nExample 3:\nInput: arr = [\"abcdefghijklmnopqrstuvwxyz\"]\nOutput: 26\n\n \nConstraints:\n\n1 <= arr.length <= 16\n1 <= arr[i].length <= 26\narr[i] contains only lower case English letters.", "starter_code": "\nclass Solution:\n    def maxLength(self, arr: List[str]) -> int:\n        ", "test_cases": {"inputs": [[["\"un\"", "\"iq\"", "\"ue\""]]], "outputs": [0], "fn_name": "maxLength"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2d68f27091afee73211b89cfc8b0861f8dd9b893", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maxLength"}
{"seed_id": "apps-00151", "original_id": null, "source": "apps", "domain": "code", "problem": "A happy string is a string that:\n\nconsists only of letters of the set ['a', 'b', 'c'].\ns[i] != s[i + 1] for all values of i from 1 to s.length - 1 (string is 1-indexed).\n\nFor example, strings \"abc\", \"ac\", \"b\" and \"abcbabcbcb\" are all happy strings and strings \"aa\", \"baa\" and \"ababbc\" are not happy strings.\nGiven two integers n and k, consider a list of all happy strings of length n sorted in lexicographical order.\nReturn the kth string of this list or return an empty string if there are less than k happy strings of length n.\n \nExample 1:\nInput: n = 1, k = 3\nOutput: \"c\"\nExplanation: The list [\"a\", \"b\", \"c\"] contains all happy strings of length 1. The third string is \"c\".\n\nExample 2:\nInput: n = 1, k = 4\nOutput: \"\"\nExplanation: There are only 3 happy strings of length 1.\n\nExample 3:\nInput: n = 3, k = 9\nOutput: \"cab\"\nExplanation: There are 12 different happy string of length 3 [\"aba\", \"abc\", \"aca\", \"acb\", \"bab\", \"bac\", \"bca\", \"bcb\", \"cab\", \"cac\", \"cba\", \"cbc\"]. You will find the 9th string = \"cab\"\n\nExample 4:\nInput: n = 2, k = 7\nOutput: \"\"\n\nExample 5:\nInput: n = 10, k = 100\nOutput: \"abacbabacb\"\n\n \nConstraints:\n\n1 <= n <= 10\n1 <= k <= 100", "starter_code": "\nclass Solution:\n    def getHappyString(self, n: int, k: int) -> str:\n        ", "test_cases": {"inputs": [[1, 3]], "outputs": ["c"], "fn_name": "getHappyString"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2ce5c10bc1fdbfb9b2bfc488dcee9025c8aee261", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "getHappyString"}
{"seed_id": "apps-00156", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string containing only three types of characters: '(', ')' and '*', write a function to check whether this string is valid. We define the validity of a string by these rules:\n\nAny left parenthesis '(' must have a corresponding right parenthesis ')'.\nAny right parenthesis ')' must have a corresponding left parenthesis '('.\nLeft parenthesis '(' must go before the corresponding right parenthesis ')'.\n'*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string.\nAn empty string is also valid.\n\n\n\nExample 1:\n\nInput: \"()\"\nOutput: True\n\n\n\nExample 2:\n\nInput: \"(*)\"\nOutput: True\n\n\n\nExample 3:\n\nInput: \"(*))\"\nOutput: True\n\n\n\nNote:\n\nThe string size will be in the range [1, 100].", "starter_code": "\nclass Solution:\n    def checkValidString(self, s: str) -> bool:\n        ", "test_cases": {"inputs": [["\"()\""]], "outputs": [true], "fn_name": "checkValidString"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d0d568340ce70d74e40ea791dc59f4992ae69cd4", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "checkValidString"}
{"seed_id": "apps-00161", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a string s containing lowercase letters and an integer k. You need to :\n\nFirst, change some characters of s to other lowercase English letters.\nThen divide s into k non-empty disjoint substrings such that each substring is palindrome.\n\nReturn the minimal number of characters that you need to change to divide the string.\n \nExample 1:\nInput: s = \"abc\", k = 2\nOutput: 1\nExplanation: You can split the string into \"ab\" and \"c\", and change 1 character in \"ab\" to make it palindrome.\n\nExample 2:\nInput: s = \"aabbc\", k = 3\nOutput: 0\nExplanation: You can split the string into \"aa\", \"bb\" and \"c\", all of them are palindrome.\nExample 3:\nInput: s = \"leetcode\", k = 8\nOutput: 0\n\n \nConstraints:\n\n1 <= k <= s.length <= 100.\ns only contains lowercase English letters.", "starter_code": "\nclass Solution:\n    def palindromePartition(self, s: str, k: int) -> int:\n        ", "test_cases": {"inputs": [["\"abc\"", 2]], "outputs": [2], "fn_name": "palindromePartition"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "7d95ea79ed74b4464fd78d343b2a10956b14da90", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "palindromePartition"}
{"seed_id": "apps-00166", "original_id": null, "source": "apps", "domain": "code", "problem": "Given 2n balls of k distinct colors. You will be given an integer array balls of size k where balls[i] is the number of balls of color i. \nAll the balls will be shuffled uniformly at random, then we will distribute the first n balls to the first box and the remaining n balls to the other box (Please read the explanation of the second example carefully).\nPlease note that the two boxes are considered different. For example, if we have two balls of colors a and b, and two boxes [] and (), then the distribution [a] (b) is considered different than the distribution [b] (a) (Please read the explanation of the first example carefully).\nWe want to calculate the probability that the two boxes have the same number of distinct balls.\n \nExample 1:\nInput: balls = [1,1]\nOutput: 1.00000\nExplanation: Only 2 ways to divide the balls equally:\n- A ball of color 1 to box 1 and a ball of color 2 to box 2\n- A ball of color 2 to box 1 and a ball of color 1 to box 2\nIn both ways, the number of distinct colors in each box is equal. The probability is 2/2 = 1\n\nExample 2:\nInput: balls = [2,1,1]\nOutput: 0.66667\nExplanation: We have the set of balls [1, 1, 2, 3]\nThis set of balls will be shuffled randomly and we may have one of the 12 distinct shuffles with equale probability (i.e. 1/12):\n[1,1 / 2,3], [1,1 / 3,2], [1,2 / 1,3], [1,2 / 3,1], [1,3 / 1,2], [1,3 / 2,1], [2,1 / 1,3], [2,1 / 3,1], [2,3 / 1,1], [3,1 / 1,2], [3,1 / 2,1], [3,2 / 1,1]\nAfter that we add the first two balls to the first box and the second two balls to the second box.\nWe can see that 8 of these 12 possible random distributions have the same number of distinct colors of balls in each box.\nProbability is 8/12 = 0.66667\n\nExample 3:\nInput: balls = [1,2,1,2]\nOutput: 0.60000\nExplanation: The set of balls is [1, 2, 2, 3, 4, 4]. It is hard to display all the 180 possible random shuffles of this set but it is easy to check that 108 of them will have the same number of distinct colors in each box.\nProbability = 108 / 180 = 0.6\n\nExample 4:\nInput: balls = [3,2,1]\nOutput: 0.30000\nExplanation: The set of balls is [1, 1, 1, 2, 2, 3]. It is hard to display all the 60 possible random shuffles of this set but it is easy to check that 18 of them will have the same number of distinct colors in each box.\nProbability = 18 / 60 = 0.3\n\nExample 5:\nInput: balls = [6,6,6,6,6,6]\nOutput: 0.90327\n\n \nConstraints:\n\n1 <= balls.length <= 8\n1 <= balls[i] <= 6\nsum(balls) is even.\nAnswers within 10^-5 of the actual value will be accepted as correct.", "starter_code": "\nclass Solution:\n    def getProbability(self, balls: List[int]) -> float:\n        ", "test_cases": {"inputs": [[[1, 1]]], "outputs": [1.0], "fn_name": "getProbability"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "cb6f15356182d270d7668f2759baec347e86e33b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "getProbability"}
{"seed_id": "apps-00171", "original_id": null, "source": "apps", "domain": "code", "problem": "Given two arrays of integers with equal lengths, return the maximum value of:\n|arr1[i] - arr1[j]| + |arr2[i] - arr2[j]| + |i - j|\nwhere the maximum is taken over all 0 <= i, j < arr1.length.\n \nExample 1:\nInput: arr1 = [1,2,3,4], arr2 = [-1,4,5,6]\nOutput: 13\n\nExample 2:\nInput: arr1 = [1,-2,-5,0,10], arr2 = [0,-2,-1,-7,-4]\nOutput: 20\n\n \nConstraints:\n\n2 <= arr1.length == arr2.length <= 40000\n-10^6 <= arr1[i], arr2[i] <= 10^6", "starter_code": "\nclass Solution:\n    def maxAbsValExpr(self, arr1: List[int], arr2: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[1, 2, 3, 4], [-1, 4, 5, 6]]], "outputs": [13], "fn_name": "maxAbsValExpr"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "645e276652d4c48290d30a190e17718d97950b68", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maxAbsValExpr"}
{"seed_id": "apps-00176", "original_id": null, "source": "apps", "domain": "code", "problem": "You have n  tiles, where each tile has one letter tiles[i] printed on it.\nReturn the number of possible non-empty sequences of letters you can make using the letters printed on those tiles.\n \nExample 1:\nInput: tiles = \"AAB\"\nOutput: 8\nExplanation: The possible sequences are \"A\", \"B\", \"AA\", \"AB\", \"BA\", \"AAB\", \"ABA\", \"BAA\".\n\nExample 2:\nInput: tiles = \"AAABBC\"\nOutput: 188\n\nExample 3:\nInput: tiles = \"V\"\nOutput: 1\n\n \nConstraints:\n\n1 <= tiles.length <= 7\ntiles consists of uppercase English letters.", "starter_code": "\nclass Solution:\n    def numTilePossibilities(self, tiles: str) -> int:\n        ", "test_cases": {"inputs": [["\"AAB\""]], "outputs": [89], "fn_name": "numTilePossibilities"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "c824298d76a15aaaf5c9cbb5dc9d2fc964d0f92d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "numTilePossibilities"}
{"seed_id": "apps-00181", "original_id": null, "source": "apps", "domain": "code", "problem": "Some people will make friend requests. The list of their ages is given and ages[i] is the age of the ith person. \nPerson A will NOT friend request person B (B != A) if any of the following conditions are true:\n\nage[B] <= 0.5 * age[A] + 7\nage[B] > age[A]\nage[B] > 100 && age[A] < 100\n\nOtherwise, A will friend request B.\nNote that if A requests B, B does not necessarily request A.  Also, people will not friend request themselves.\nHow many total friend requests are made?\nExample 1:\nInput: [16,16]\nOutput: 2\nExplanation: 2 people friend request each other.\n\nExample 2:\nInput: [16,17,18]\nOutput: 2\nExplanation: Friend requests are made 17 -> 16, 18 -> 17.\nExample 3:\nInput: [20,30,100,110,120]\nOutput: 3\nExplanation: Friend requests are made 110 -> 100, 120 -> 110, 120 -> 100.\n\n \nNotes:\n\n1 <= ages.length <= 20000.\n1 <= ages[i] <= 120.", "starter_code": "\nclass Solution:\n    def numFriendRequests(self, ages: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[16, 16]]], "outputs": [2], "fn_name": "numFriendRequests"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "61e68ecb1003bea2fc74671aa40c14d2dc742341", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "numFriendRequests"}
{"seed_id": "apps-00186", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a non-negative integer N, find the largest number that is less than or equal to N with monotone increasing digits.\n\n(Recall that an integer has monotone increasing digits if and only if each pair of adjacent digits x and y satisfy x .)\n\n\nExample 1:\n\nInput: N = 10\nOutput: 9\n\n\n\nExample 2:\n\nInput: N = 1234\nOutput: 1234\n\n\n\nExample 3:\n\nInput: N = 332\nOutput: 299\n\n\n\nNote:\nN is an integer in the range [0, 10^9].", "starter_code": "\nclass Solution:\n    def monotoneIncreasingDigits(self, N: int) -> int:\n        ", "test_cases": {"inputs": [[10]], "outputs": [9], "fn_name": "monotoneIncreasingDigits"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "a960238cbc45440ceacf119412c5cb7f08730523", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "monotoneIncreasingDigits"}
{"seed_id": "apps-00191", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given two strings s1 and s2 of equal length consisting of letters \"x\" and \"y\" only. Your task is to make these two strings equal to each other. You can swap any two characters that belong to different strings, which means: swap s1[i] and s2[j].\nReturn the minimum number of swaps required to make s1 and s2 equal, or return -1 if it is impossible to do so.\n \nExample 1:\nInput: s1 = \"xx\", s2 = \"yy\"\nOutput: 1\nExplanation: \nSwap s1[0] and s2[1], s1 = \"yx\", s2 = \"yx\".\nExample 2: \nInput: s1 = \"xy\", s2 = \"yx\"\nOutput: 2\nExplanation: \nSwap s1[0] and s2[0], s1 = \"yy\", s2 = \"xx\".\nSwap s1[0] and s2[1], s1 = \"xy\", s2 = \"xy\".\nNote that you can't swap s1[0] and s1[1] to make s1 equal to \"yx\", cause we can only swap chars in different strings.\nExample 3:\nInput: s1 = \"xx\", s2 = \"xy\"\nOutput: -1\n\nExample 4:\nInput: s1 = \"xxyyxyxyxx\", s2 = \"xyyxyxxxyx\"\nOutput: 4\n\n \nConstraints:\n\n1 <= s1.length, s2.length <= 1000\ns1, s2 only contain 'x' or 'y'.", "starter_code": "\nclass Solution:\n    def minimumSwap(self, s1: str, s2: str) -> int:\n        ", "test_cases": {"inputs": [["\"xx\"", "\"yy\""]], "outputs": [1], "fn_name": "minimumSwap"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "69134231ade342fa1310bba8cebebe9b2003ce9e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minimumSwap"}
{"seed_id": "apps-00196", "original_id": null, "source": "apps", "domain": "code", "problem": "Given two strings: s1 and s2 with the same size, check if some permutation of string s1 can break some permutation of string s2 or vice-versa (in other words s2 can break s1).\nA string x can break string y (both of size n) if x[i] >= y[i] (in alphabetical order) for all i between 0 and n-1.\n \nExample 1:\nInput: s1 = \"abc\", s2 = \"xya\"\nOutput: true\nExplanation: \"ayx\" is a permutation of s2=\"xya\" which can break to string \"abc\" which is a permutation of s1=\"abc\".\n\nExample 2:\nInput: s1 = \"abe\", s2 = \"acd\"\nOutput: false \nExplanation: All permutations for s1=\"abe\" are: \"abe\", \"aeb\", \"bae\", \"bea\", \"eab\" and \"eba\" and all permutation for s2=\"acd\" are: \"acd\", \"adc\", \"cad\", \"cda\", \"dac\" and \"dca\". However, there is not any permutation from s1 which can break some permutation from s2 and vice-versa.\n\nExample 3:\nInput: s1 = \"leetcodee\", s2 = \"interview\"\nOutput: true\n\n \nConstraints:\n\ns1.length == n\ns2.length == n\n1 <= n <= 10^5\nAll strings consist of lowercase English letters.", "starter_code": "\nclass Solution:\n    def checkIfCanBreak(self, s1: str, s2: str) -> bool:\n        ", "test_cases": {"inputs": [["\"abc\"", "\"xya\""]], "outputs": [true], "fn_name": "checkIfCanBreak"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "0abc3e2d98887cf7b550afb9688d778523612d9b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "checkIfCanBreak"}
{"seed_id": "apps-00201", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string, find the length of the longest substring without repeating characters.\n\nExamples:\n\nGiven \"abcabcbb\", the answer is \"abc\", which the length is 3.\n\nGiven \"bbbbb\", the answer is \"b\", with the length of 1.\n\nGiven \"pwwkew\", the answer is \"wke\", with the length of 3. Note that the answer must be a substring, \"pwke\" is a subsequence and not a substring.", "starter_code": "\nclass Solution:\n    def lengthOfLongestSubstring(self, s: str) -> int:\n        ", "test_cases": {"inputs": [["\"abcabcbb\""]], "outputs": [4], "fn_name": "lengthOfLongestSubstring"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "823055fd999142987b828b241897a1c451b5cc03", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "lengthOfLongestSubstring"}
{"seed_id": "apps-00206", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array of integers arr, you are initially positioned at the first index of the array.\nIn one step you can jump from index i to index:\n\ni + 1 where: i + 1 < arr.length.\ni - 1 where: i - 1 >= 0.\nj where: arr[i] == arr[j] and i != j.\n\nReturn the minimum number of steps to reach the last index of the array.\nNotice that you can not jump outside of the array at any time.\n \nExample 1:\nInput: arr = [100,-23,-23,404,100,23,23,23,3,404]\nOutput: 3\nExplanation: You need three jumps from index 0 --> 4 --> 3 --> 9. Note that index 9 is the last index of the array.\n\nExample 2:\nInput: arr = [7]\nOutput: 0\nExplanation: Start index is the last index. You don't need to jump.\n\nExample 3:\nInput: arr = [7,6,9,6,9,6,9,7]\nOutput: 1\nExplanation: You can jump directly from index 0 to index 7 which is last index of the array.\n\nExample 4:\nInput: arr = [6,1,9]\nOutput: 2\n\nExample 5:\nInput: arr = [11,22,7,7,7,7,7,7,7,22,13]\nOutput: 3\n\n \nConstraints:\n\n1 <= arr.length <= 5 * 10^4\n-10^8 <= arr[i] <= 10^8", "starter_code": "\nclass Solution:\n    def minJumps(self, arr: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[100, -23, -23, 404, 100, 23, 23, 23, 3, 404]]], "outputs": [3], "fn_name": "minJumps"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "45974747d045f9aee7aa9bcbcce7888e03bc6dcd", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minJumps"}
{"seed_id": "apps-00211", "original_id": null, "source": "apps", "domain": "code", "problem": "Given two arrays of integers nums1 and nums2, return the number of triplets formed (type 1 and type 2) under the following rules:\n\nType 1: Triplet (i, j, k) if nums1[i]2 == nums2[j] * nums2[k] where 0 <= i < nums1.length and 0 <= j < k < nums2.length.\nType 2: Triplet (i, j, k) if nums2[i]2 == nums1[j] * nums1[k] where 0 <= i < nums2.length and 0 <= j < k < nums1.length.\n\n \nExample 1:\nInput: nums1 = [7,4], nums2 = [5,2,8,9]\nOutput: 1\nExplanation: Type 1: (1,1,2), nums1[1]^2 = nums2[1] * nums2[2]. (4^2 = 2 * 8). \n\nExample 2:\nInput: nums1 = [1,1], nums2 = [1,1,1]\nOutput: 9\nExplanation: All Triplets are valid, because 1^2 = 1 * 1.\nType 1: (0,0,1), (0,0,2), (0,1,2), (1,0,1), (1,0,2), (1,1,2).  nums1[i]^2 = nums2[j] * nums2[k].\nType 2: (0,0,1), (1,0,1), (2,0,1). nums2[i]^2 = nums1[j] * nums1[k].\n\nExample 3:\nInput: nums1 = [7,7,8,3], nums2 = [1,2,9,7]\nOutput: 2\nExplanation: There are 2 valid triplets.\nType 1: (3,0,2).  nums1[3]^2 = nums2[0] * nums2[2].\nType 2: (3,0,1).  nums2[3]^2 = nums1[0] * nums1[1].\n\nExample 4:\nInput: nums1 = [4,7,9,11,23], nums2 = [3,5,1024,12,18]\nOutput: 0\nExplanation: There are no valid triplets.\n\n \nConstraints:\n\n1 <= nums1.length, nums2.length <= 1000\n1 <= nums1[i], nums2[i] <= 10^5", "starter_code": "\nclass Solution:\n    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[7, 4], [5, 2, 8, 9]]], "outputs": [1], "fn_name": "numTriplets"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8235ae4acf939730d76749809656d2966ebfd9a8", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "numTriplets"}
{"seed_id": "apps-00216", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array which consists of non-negative integers and an integer m, you can split the array into m non-empty continuous subarrays. Write an algorithm to minimize the largest sum among these m subarrays.\n\n\nNote:\nIf n is the length of array, assume the following constraints are satisfied:\n\n1 ≤ n ≤ 1000\n1 ≤ m ≤ min(50, n)\n\n\n\nExamples: \n\nInput:\nnums = [7,2,5,10,8]\nm = 2\n\nOutput:\n18\n\nExplanation:\nThere are four ways to split nums into two subarrays.\nThe best way is to split it into [7,2,5] and [10,8],\nwhere the largest sum among the two subarrays is only 18.", "starter_code": "\nclass Solution:\n    def splitArray(self, nums: List[int], m: int) -> int:\n        ", "test_cases": {"inputs": [[[7, 2, 5, 10, 8], 2]], "outputs": [18], "fn_name": "splitArray"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8fc944c03f0d4e07493a107f962ef0cb3fc9953e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "splitArray"}
{"seed_id": "apps-00221", "original_id": null, "source": "apps", "domain": "code", "problem": "On a broken calculator that has a number showing on its display, we can perform two operations:\n\nDouble: Multiply the number on the display by 2, or;\nDecrement: Subtract 1 from the number on the display.\n\nInitially, the calculator is displaying the number X.\nReturn the minimum number of operations needed to display the number Y.\n \nExample 1:\nInput: X = 2, Y = 3\nOutput: 2\nExplanation: Use double operation and then decrement operation {2 -> 4 -> 3}.\n\nExample 2:\nInput: X = 5, Y = 8\nOutput: 2\nExplanation: Use decrement and then double {5 -> 4 -> 8}.\n\nExample 3:\nInput: X = 3, Y = 10\nOutput: 3\nExplanation:  Use double, decrement and double {3 -> 6 -> 5 -> 10}.\n\nExample 4:\nInput: X = 1024, Y = 1\nOutput: 1023\nExplanation: Use decrement operations 1023 times.\n\n \nNote:\n\n1 <= X <= 10^9\n1 <= Y <= 10^9", "starter_code": "\nclass Solution:\n    def brokenCalc(self, X: int, Y: int) -> int:\n        ", "test_cases": {"inputs": [[2, 3]], "outputs": [2], "fn_name": "brokenCalc"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e89c59ef527ccaa3ad5a776a4c939b64e5d785b7", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "brokenCalc"}
{"seed_id": "apps-00226", "original_id": null, "source": "apps", "domain": "code", "problem": "Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:\n\n\n       Integers in each row are sorted from left to right.\n       The first integer of each row is greater than the last integer of the previous row.\n\n\nExample 1:\n\n\nInput:\nmatrix = [\n  [1,   3,  5,  7],\n  [10, 11, 16, 20],\n  [23, 30, 34, 50]\n]\ntarget = 3\nOutput: true\n\n\nExample 2:\n\n\nInput:\nmatrix = [\n  [1,   3,  5,  7],\n  [10, 11, 16, 20],\n  [23, 30, 34, 50]\n]\ntarget = 13\nOutput: false", "starter_code": "\nclass Solution:\n    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:\n        ", "test_cases": {"inputs": [[[[1, 3, 5, 7], [10, 11, 16, 20], [23, 30, 34, 50], [], []], 3]], "outputs": [true], "fn_name": "searchMatrix"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "fd80262472bb6529e943b5c460c3fe5f005a3051", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "searchMatrix"}
{"seed_id": "apps-00231", "original_id": null, "source": "apps", "domain": "code", "problem": "There are n people and 40 types of hats labeled from 1 to 40.\nGiven a list of list of integers hats, where hats[i] is a list of all hats preferred by the i-th person.\nReturn the number of ways that the n people wear different hats to each other.\nSince the answer may be too large, return it modulo 10^9 + 7.\n \nExample 1:\nInput: hats = [[3,4],[4,5],[5]]\nOutput: 1\nExplanation: There is only one way to choose hats given the conditions. \nFirst person choose hat 3, Second person choose hat 4 and last one hat 5.\nExample 2:\nInput: hats = [[3,5,1],[3,5]]\nOutput: 4\nExplanation: There are 4 ways to choose hats\n(3,5), (5,3), (1,3) and (1,5)\n\nExample 3:\nInput: hats = [[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]]\nOutput: 24\nExplanation: Each person can choose hats labeled from 1 to 4.\nNumber of Permutations of (1,2,3,4) = 24.\n\nExample 4:\nInput: hats = [[1,2,3],[2,3,5,6],[1,3,7,9],[1,8,9],[2,5,7]]\nOutput: 111\n\n \nConstraints:\n\nn == hats.length\n1 <= n <= 10\n1 <= hats[i].length <= 40\n1 <= hats[i][j] <= 40\nhats[i] contains a list of unique integers.", "starter_code": "\nclass Solution:\n    def numberWays(self, hats: List[List[int]]) -> int:\n        ", "test_cases": {"inputs": [[[[3, 4], [4, 5], [5], [], []]]], "outputs": [0], "fn_name": "numberWays"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "92e1c319febdd3b8293b947b0ac01b50c997c4e6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "numberWays"}
{"seed_id": "apps-00236", "original_id": null, "source": "apps", "domain": "code", "problem": "A chef has collected data on the satisfaction level of his n dishes. Chef can cook any dish in 1 unit of time.\nLike-time coefficient of a dish is defined as the time taken to cook that dish including previous dishes multiplied by its satisfaction level  i.e.  time[i]*satisfaction[i]\nReturn the maximum sum of Like-time coefficient that the chef can obtain after dishes preparation.\nDishes can be prepared in any order and the chef can discard some dishes to get this maximum value.\n \nExample 1:\nInput: satisfaction = [-1,-8,0,5,-9]\nOutput: 14\nExplanation: After Removing the second and last dish, the maximum total Like-time coefficient will be equal to (-1*1 + 0*2 + 5*3 = 14). Each dish is prepared in one unit of time.\nExample 2:\nInput: satisfaction = [4,3,2]\nOutput: 20\nExplanation: Dishes can be prepared in any order, (2*1 + 3*2 + 4*3 = 20)\n\nExample 3:\nInput: satisfaction = [-1,-4,-5]\nOutput: 0\nExplanation: People don't like the dishes. No dish is prepared.\n\nExample 4:\nInput: satisfaction = [-2,5,-1,0,3,-3]\nOutput: 35\n\n \nConstraints:\n\nn == satisfaction.length\n1 <= n <= 500\n-10^3 <= satisfaction[i] <= 10^3", "starter_code": "\nclass Solution:\n    def maxSatisfaction(self, satisfaction: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[-8, -7, -1, 0, 5]]], "outputs": [14], "fn_name": "maxSatisfaction"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "63bc6fdb04e70ebb33a2e2a9a6e745024e75d236", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maxSatisfaction"}
{"seed_id": "apps-00241", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an unsorted array, find the maximum difference between the successive elements in its sorted form.\n\nReturn 0 if the array contains less than 2 elements.\n\nExample 1:\n\n\nInput: [3,6,9,1]\nOutput: 3\nExplanation: The sorted form of the array is [1,3,6,9], either\n             (3,6) or (6,9) has the maximum difference 3.\n\nExample 2:\n\n\nInput: [10]\nOutput: 0\nExplanation: The array contains less than 2 elements, therefore return 0.\n\nNote:\n\n\n       You may assume all elements in the array are non-negative integers and fit in the 32-bit signed integer range.\n       Try to solve it in linear time/space.", "starter_code": "\nclass Solution:\n    def maximumGap(self, nums: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[3, 6, 9, 1]]], "outputs": [3], "fn_name": "maximumGap"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "0cbabbece18bb9812d428ae9535df31704b78c49", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maximumGap"}
{"seed_id": "apps-00246", "original_id": null, "source": "apps", "domain": "code", "problem": "Write a function to check whether an input string is a valid IPv4 address or IPv6 address or neither.\n\n\n\nIPv4 addresses are canonically represented in dot-decimal notation, which consists of four decimal numbers, each ranging from 0 to 255, separated by dots (\".\"), e.g.,172.16.254.1;\n\n\n\nBesides, leading zeros in the IPv4 is invalid. For example, the address 172.16.254.01 is invalid.\n\n\n\nIPv6 addresses are represented as eight groups of four hexadecimal digits, each group representing 16 bits. The groups are separated by colons (\":\"). For example, the address 2001:0db8:85a3:0000:0000:8a2e:0370:7334 is a valid one. Also, we could omit some leading zeros among four hexadecimal digits and some low-case characters in the address to upper-case ones, so 2001:db8:85a3:0:0:8A2E:0370:7334 is also a valid IPv6 address(Omit leading zeros and using upper cases).\n\n\n\n\nHowever, we don't replace a consecutive group of zero value with a single empty group using two consecutive colons (::) to pursue simplicity. For example, 2001:0db8:85a3::8A2E:0370:7334 is an invalid IPv6 address.\n\n\n\nBesides, extra leading zeros in the IPv6 is also invalid. For example, the address 02001:0db8:85a3:0000:0000:8a2e:0370:7334 is invalid.\n\n\n\nNote:\nYou may assume there is no extra space or special characters in the input string.\n\n\nExample 1:\n\nInput: \"172.16.254.1\"\n\nOutput: \"IPv4\"\n\nExplanation: This is a valid IPv4 address, return \"IPv4\".\n\n\n\n\nExample 2:\n\nInput: \"2001:0db8:85a3:0:0:8A2E:0370:7334\"\n\nOutput: \"IPv6\"\n\nExplanation: This is a valid IPv6 address, return \"IPv6\".\n\n\n\nExample 3:\n\nInput: \"256.256.256.256\"\n\nOutput: \"Neither\"\n\nExplanation: This is neither a IPv4 address nor a IPv6 address.", "starter_code": "\nclass Solution:\n    def validIPAddress(self, IP: str) -> str:\n        ", "test_cases": {"inputs": [["\"172.16.254.1\""]], "outputs": ["Neither"], "fn_name": "validIPAddress"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "afd59659bb258147e28578c34beab67a7d08d421", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "validIPAddress"}
{"seed_id": "apps-00251", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an integer n, your task is to count how many strings of length n can be formed under the following rules:\n\nEach character is a lower case vowel ('a', 'e', 'i', 'o', 'u')\nEach vowel 'a' may only be followed by an 'e'.\nEach vowel 'e' may only be followed by an 'a' or an 'i'.\nEach vowel 'i' may not be followed by another 'i'.\nEach vowel 'o' may only be followed by an 'i' or a 'u'.\nEach vowel 'u' may only be followed by an 'a'.\n\nSince the answer may be too large, return it modulo 10^9 + 7.\n \nExample 1:\nInput: n = 1\nOutput: 5\nExplanation: All possible strings are: \"a\", \"e\", \"i\" , \"o\" and \"u\".\n\nExample 2:\nInput: n = 2\nOutput: 10\nExplanation: All possible strings are: \"ae\", \"ea\", \"ei\", \"ia\", \"ie\", \"io\", \"iu\", \"oi\", \"ou\" and \"ua\".\n\nExample 3: \nInput: n = 5\nOutput: 68\n \nConstraints:\n\n1 <= n <= 2 * 10^4", "starter_code": "\nclass Solution:\n    def countVowelPermutation(self, n: int) -> int:\n        ", "test_cases": {"inputs": [[1]], "outputs": [5], "fn_name": "countVowelPermutation"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "ab88d6a9b82a7f97d6bcf22512765320be930e1e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "countVowelPermutation"}
{"seed_id": "apps-00256", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a binary string s (a string consisting only of '0's and '1's), we can split s into 3 non-empty strings s1, s2, s3 (s1+ s2+ s3 = s).\nReturn the number of ways s can be split such that the number of characters '1' is the same in s1, s2, and s3.\nSince the answer may be too large, return it modulo 10^9 + 7.\n \nExample 1:\nInput: s = \"10101\"\nOutput: 4\nExplanation: There are four ways to split s in 3 parts where each part contain the same number of letters '1'.\n\"1|010|1\"\n\"1|01|01\"\n\"10|10|1\"\n\"10|1|01\"\n\nExample 2:\nInput: s = \"1001\"\nOutput: 0\n\nExample 3:\nInput: s = \"0000\"\nOutput: 3\nExplanation: There are three ways to split s in 3 parts.\n\"0|0|00\"\n\"0|00|0\"\n\"00|0|0\"\n\nExample 4:\nInput: s = \"100100010100110\"\nOutput: 12\n\n \nConstraints:\n\n3 <= s.length <= 10^5\ns[i] is '0' or '1'.", "starter_code": "\nclass Solution:\n    def numWays(self, s: str) -> int:\n        ", "test_cases": {"inputs": [["\"10101\""]], "outputs": [4], "fn_name": "numWays"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "3aa185fd9807fd47e8ae1f3b8097286a9e9f406e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "numWays"}
{"seed_id": "apps-00261", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an integer n, count the total number of digit 1 appearing in all non-negative integers less than or equal to n.\n\nExample:\n\n\nInput: 13\nOutput: 6 \nExplanation: Digit 1 occurred in the following numbers: 1, 10, 11, 12, 13.", "starter_code": "\nclass Solution:\n    def countDigitOne(self, n: int) -> int:\n        ", "test_cases": {"inputs": [[13]], "outputs": [6], "fn_name": "countDigitOne"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "78cab551e7764a746670259cf73ec5178aefa59d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "countDigitOne"}
{"seed_id": "apps-00266", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an unsorted array return whether an increasing subsequence of length 3 exists or not in the array.\n\n\nFormally the function should:\nReturn true if there exists i, j, k  \nsuch that arr[i] < arr[j] < arr[k] given 0 ≤ i < j < k ≤ n-1 \nelse return false.\n\n\n\nYour algorithm should run in O(n) time complexity and O(1) space complexity.\n\n\nExamples:\nGiven [1, 2, 3, 4, 5],\nreturn true.\n\n\nGiven [5, 4, 3, 2, 1],\nreturn false.\n\n\nCredits:Special thanks to @DjangoUnchained for adding this problem and creating all test cases.", "starter_code": "\nclass Solution:\n    def increasingTriplet(self, nums: List[int]) -> bool:\n        ", "test_cases": {"inputs": [[[1, 2, 3, 4, 5]]], "outputs": [true], "fn_name": "increasingTriplet"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "dc7e59dfd16f582da8590cc068987c6ba597c0c3", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "increasingTriplet"}
{"seed_id": "apps-00271", "original_id": null, "source": "apps", "domain": "code", "problem": "The power of an integer x is defined as the number of steps needed to transform x into 1 using the following steps:\n\nif x is even then x = x / 2\nif x is odd then x = 3 * x + 1\n\nFor example, the power of x = 3 is 7 because 3 needs 7 steps to become 1 (3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1).\nGiven three integers lo, hi and k. The task is to sort all integers in the interval [lo, hi] by the power value in ascending order, if two or more integers have the same power value sort them by ascending order.\nReturn the k-th integer in the range [lo, hi] sorted by the power value.\nNotice that for any integer x (lo <= x <= hi) it is guaranteed that x will transform into 1 using these steps and that the power of x is will fit in 32 bit signed integer.\n \nExample 1:\nInput: lo = 12, hi = 15, k = 2\nOutput: 13\nExplanation: The power of 12 is 9 (12 --> 6 --> 3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1)\nThe power of 13 is 9\nThe power of 14 is 17\nThe power of 15 is 17\nThe interval sorted by the power value [12,13,14,15]. For k = 2 answer is the second element which is 13.\nNotice that 12 and 13 have the same power value and we sorted them in ascending order. Same for 14 and 15.\n\nExample 2:\nInput: lo = 1, hi = 1, k = 1\nOutput: 1\n\nExample 3:\nInput: lo = 7, hi = 11, k = 4\nOutput: 7\nExplanation: The power array corresponding to the interval [7, 8, 9, 10, 11] is [16, 3, 19, 6, 14].\nThe interval sorted by power is [8, 10, 11, 7, 9].\nThe fourth number in the sorted array is 7.\n\nExample 4:\nInput: lo = 10, hi = 20, k = 5\nOutput: 13\n\nExample 5:\nInput: lo = 1, hi = 1000, k = 777\nOutput: 570\n\n \nConstraints:\n\n1 <= lo <= hi <= 1000\n1 <= k <= hi - lo + 1", "starter_code": "\nclass Solution:\n    def getKth(self, lo: int, hi: int, k: int) -> int:\n        ", "test_cases": {"inputs": [[12, 15, 2]], "outputs": [13], "fn_name": "getKth"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2a75a440d658ec090c30d4b17aaf7496ecbd3f5c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "getKth"}
{"seed_id": "apps-00276", "original_id": null, "source": "apps", "domain": "code", "problem": "We have two integer sequences A and B of the same non-zero length.\nWe are allowed to swap elements A[i] and B[i].  Note that both elements are in the same index position in their respective sequences.\nAt the end of some number of swaps, A and B are both strictly increasing.  (A sequence is strictly increasing if and only if A[0] < A[1] < A[2] < ... < A[A.length - 1].)\nGiven A and B, return the minimum number of swaps to make both sequences strictly increasing.  It is guaranteed that the given input always makes it possible.\nExample:\nInput: A = [1,3,5,4], B = [1,2,3,7]\nOutput: 1\nExplanation: \nSwap A[3] and B[3].  Then the sequences are:\nA = [1, 3, 5, 7] and B = [1, 2, 3, 4]\nwhich are both strictly increasing.\n\nNote:\n\nA, B are arrays with the same length, and that length will be in the range [1, 1000].\nA[i], B[i] are integer values in the range [0, 2000].", "starter_code": "\nclass Solution:\n    def minSwap(self, A: List[int], B: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[1, 3, 5, 4], [1, 2, 3, 7]]], "outputs": [1], "fn_name": "minSwap"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "411e59247b39fa6cb8c369e56122dfafe75e5993", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minSwap"}
{"seed_id": "apps-00281", "original_id": null, "source": "apps", "domain": "code", "problem": "Given the string s, return the size of the longest substring containing each vowel an even number of times. That is, 'a', 'e', 'i', 'o', and 'u' must appear an even number of times.\n \nExample 1:\nInput: s = \"eleetminicoworoep\"\nOutput: 13\nExplanation: The longest substring is \"leetminicowor\" which contains two each of the vowels: e, i and o and zero of the vowels: a and u.\n\nExample 2:\nInput: s = \"leetcodeisgreat\"\nOutput: 5\nExplanation: The longest substring is \"leetc\" which contains two e's.\n\nExample 3:\nInput: s = \"bcbcbc\"\nOutput: 6\nExplanation: In this case, the given string \"bcbcbc\" is the longest because all vowels: a, e, i, o and u appear zero times.\n\n \nConstraints:\n\n1 <= s.length <= 5 x 10^5\ns contains only lowercase English letters.", "starter_code": "\nclass Solution:\n    def findTheLongestSubstring(self, s: str) -> int:\n        ", "test_cases": {"inputs": [["\"eleetminicoworoep\""]], "outputs": [13], "fn_name": "findTheLongestSubstring"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "92240c8413bcfa67ffbc0206bb4fed107833e2a8", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "findTheLongestSubstring"}
{"seed_id": "apps-00286", "original_id": null, "source": "apps", "domain": "code", "problem": "Starting with a positive integer N, we reorder the digits in any order (including the original order) such that the leading digit is not zero.\nReturn true if and only if we can do this in a way such that the resulting number is a power of 2.\n \n\n\n\nExample 1:\nInput: 1\nOutput: true\n\n\nExample 2:\nInput: 10\nOutput: false\n\n\nExample 3:\nInput: 16\nOutput: true\n\n\nExample 4:\nInput: 24\nOutput: false\n\n\nExample 5:\nInput: 46\nOutput: true\n\n \nNote:\n\n1 <= N <= 10^9", "starter_code": "\nclass Solution:\n    def reorderedPowerOf2(self, N: int) -> bool:\n        ", "test_cases": {"inputs": [[1]], "outputs": [true], "fn_name": "reorderedPowerOf2"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "ad490b46e00047abcd0b30b1c47baf955638bf2f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "reorderedPowerOf2"}
{"seed_id": "apps-00291", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array of integers A, find the sum of min(B), where B ranges over every (contiguous) subarray of A.\nSince the answer may be large, return the answer modulo 10^9 + 7.\n \nExample 1:\nInput: [3,1,2,4]\nOutput: 17\nExplanation: Subarrays are [3], [1], [2], [4], [3,1], [1,2], [2,4], [3,1,2], [1,2,4], [3,1,2,4]. \nMinimums are 3, 1, 2, 4, 1, 1, 2, 1, 1, 1.  Sum is 17.\n \nNote:\n\n1 <= A.length <= 30000\n1 <= A[i] <= 30000", "starter_code": "\nclass Solution:\n    def sumSubarrayMins(self, A: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[3, 1, 2, 4, 0]]], "outputs": [17], "fn_name": "sumSubarrayMins"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8a05f3efaeca53811532ddb066d74a3adfb6f510", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "sumSubarrayMins"}
{"seed_id": "apps-00296", "original_id": null, "source": "apps", "domain": "code", "problem": "There are n oranges in the kitchen and you decided to eat some of these oranges every day as follows:\n\nEat one orange.\nIf the number of remaining oranges (n) is divisible by 2 then you can eat  n/2 oranges.\nIf the number of remaining oranges (n) is divisible by 3 then you can eat  2*(n/3) oranges.\n\nYou can only choose one of the actions per day.\nReturn the minimum number of days to eat n oranges.\n \nExample 1:\nInput: n = 10\nOutput: 4\nExplanation: You have 10 oranges.\nDay 1: Eat 1 orange,  10 - 1 = 9.  \nDay 2: Eat 6 oranges, 9 - 2*(9/3) = 9 - 6 = 3. (Since 9 is divisible by 3)\nDay 3: Eat 2 oranges, 3 - 2*(3/3) = 3 - 2 = 1. \nDay 4: Eat the last orange  1 - 1  = 0.\nYou need at least 4 days to eat the 10 oranges.\n\nExample 2:\nInput: n = 6\nOutput: 3\nExplanation: You have 6 oranges.\nDay 1: Eat 3 oranges, 6 - 6/2 = 6 - 3 = 3. (Since 6 is divisible by 2).\nDay 2: Eat 2 oranges, 3 - 2*(3/3) = 3 - 2 = 1. (Since 3 is divisible by 3)\nDay 3: Eat the last orange  1 - 1  = 0.\nYou need at least 3 days to eat the 6 oranges.\n\nExample 3:\nInput: n = 1\nOutput: 1\n\nExample 4:\nInput: n = 56\nOutput: 6\n\n \nConstraints:\n\n1 <= n <= 2*10^9", "starter_code": "\nclass Solution:\n    def minDays(self, n: int) -> int:\n        ", "test_cases": {"inputs": [[10]], "outputs": [4], "fn_name": "minDays"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "45debaced09fd11c0ade6fe6e1a20da9eb3e43e3", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minDays"}
{"seed_id": "apps-00301", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a positive integer N, how many ways can we write it as a sum of consecutive positive integers?\nExample 1:\nInput: 5\nOutput: 2\nExplanation: 5 = 5 = 2 + 3\nExample 2:\nInput: 9\nOutput: 3\nExplanation: 9 = 9 = 4 + 5 = 2 + 3 + 4\nExample 3:\nInput: 15\nOutput: 4\nExplanation: 15 = 15 = 8 + 7 = 4 + 5 + 6 = 1 + 2 + 3 + 4 + 5\nNote: 1 <= N <= 10 ^ 9.", "starter_code": "\nclass Solution:\n    def consecutiveNumbersSum(self, N: int) -> int:\n        ", "test_cases": {"inputs": [[5]], "outputs": [2], "fn_name": "consecutiveNumbersSum"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "15ac4b3a8ef4dd1c1a94e0a53a758a90571bbeb0", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "consecutiveNumbersSum"}
{"seed_id": "apps-00306", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string which contains only lowercase letters, remove duplicate letters so that every letter appear once and only once. You must make sure your result is the smallest in lexicographical order among all possible results.\n \nExample 1:\n \n \nInput: \"bcabc\"\nOutput: \"abc\"\n \n \nExample 2:\n \n \nInput: \"cbacdcbc\"\nOutput: \"acdb\"", "starter_code": "\nclass Solution:\n    def removeDuplicateLetters(self, s: str) -> str:\n        ", "test_cases": {"inputs": [["\"bcabc\""]], "outputs": ["\"abc"], "fn_name": "removeDuplicateLetters"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "cfc80469ab6c8685c6e809e2133b841e63a41d58", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "removeDuplicateLetters"}
{"seed_id": "apps-00311", "original_id": null, "source": "apps", "domain": "code", "problem": "There is a row of m houses in a small city, each house must be painted with one of the n colors (labeled from 1 to n), some houses that has been painted last summer should not be painted again.\nA neighborhood is a maximal group of continuous houses that are painted with the same color. (For example: houses = [1,2,2,3,3,2,1,1] contains 5 neighborhoods  [{1}, {2,2}, {3,3}, {2}, {1,1}]).\nGiven an array houses, an m * n matrix cost and an integer target where:\n\nhouses[i]: is the color of the house i, 0 if the house is not painted yet.\ncost[i][j]: is the cost of paint the house i with the color j+1.\n\nReturn the minimum cost of painting all the remaining houses in such a way that there are exactly target neighborhoods, if not possible return -1.\n \nExample 1:\nInput: houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3\nOutput: 9\nExplanation: Paint houses of this way [1,2,2,1,1]\nThis array contains target = 3 neighborhoods, [{1}, {2,2}, {1,1}].\nCost of paint all houses (1 + 1 + 1 + 1 + 5) = 9.\n\nExample 2:\nInput: houses = [0,2,1,2,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3\nOutput: 11\nExplanation: Some houses are already painted, Paint the houses of this way [2,2,1,2,2]\nThis array contains target = 3 neighborhoods, [{2,2}, {1}, {2,2}]. \nCost of paint the first and last house (10 + 1) = 11.\n\nExample 3:\nInput: houses = [0,0,0,0,0], cost = [[1,10],[10,1],[1,10],[10,1],[1,10]], m = 5, n = 2, target = 5\nOutput: 5\n\nExample 4:\nInput: houses = [3,1,2,3], cost = [[1,1,1],[1,1,1],[1,1,1],[1,1,1]], m = 4, n = 3, target = 3\nOutput: -1\nExplanation: Houses are already painted with a total of 4 neighborhoods [{3},{1},{2},{3}] different of target = 3.\n\n \nConstraints:\n\nm == houses.length == cost.length\nn == cost[i].length\n1 <= m <= 100\n1 <= n <= 20\n1 <= target <= m\n0 <= houses[i] <= n\n1 <= cost[i][j] <= 10^4", "starter_code": "\nclass Solution:\n    def minCost(self, houses: List[int], cost: List[List[int]], m: int, n: int, target: int) -> int:\n        ", "test_cases": {"inputs": [[[0, 0, 0, 0, 0], [[1, 10], [10, 1], [10, 1], [1, 10], [5, 1], [], []], 5, 2, 3]], "outputs": [9], "fn_name": "minCost"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e8f3f739c55afc3eb84f966f5ff97afa8427188b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minCost"}
{"seed_id": "apps-00316", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string that consists of only uppercase English letters, you can replace any letter in the string with another letter at most k times. Find the length of a longest substring containing all repeating letters you can get after performing the above operations.\n\nNote:\nBoth the string's length and k will not exceed 104.\n\n\n\nExample 1:\n\nInput:\ns = \"ABAB\", k = 2\n\nOutput:\n4\n\nExplanation:\nReplace the two 'A's with two 'B's or vice versa.\n\n\n\n\nExample 2:\n\nInput:\ns = \"AABABBA\", k = 1\n\nOutput:\n4\n\nExplanation:\nReplace the one 'A' in the middle with 'B' and form \"AABBBBA\".\nThe substring \"BBBB\" has the longest repeating letters, which is 4.", "starter_code": "\nclass Solution:\n    def characterReplacement(self, s: str, k: int) -> int:\n        ", "test_cases": {"inputs": [["\"ABAB\"", 2]], "outputs": [4], "fn_name": "characterReplacement"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "acc771aa6b62f2a75e1e908f5318a24ccec6e58d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "characterReplacement"}
{"seed_id": "apps-00321", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string s, partition s such that every substring of the partition is a palindrome.\n\nReturn the minimum cuts needed for a palindrome partitioning of s.\n\nExample:\n\n\nInput: \"aab\"\nOutput: 1\nExplanation: The palindrome partitioning [\"aa\",\"b\"] could be produced using 1 cut.", "starter_code": "\nclass Solution:\n    def minCut(self, s: str) -> int:\n        ", "test_cases": {"inputs": [["\"aab\""]], "outputs": [3], "fn_name": "minCut"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b4cd9e402c40397446a7f8625807e68d18b1c888", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minCut"}
{"seed_id": "apps-00326", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an integer array A, and an integer target, return the number of tuples i, j, k  such that i < j < k and A[i] + A[j] + A[k] == target.\nAs the answer can be very large, return it modulo 109 + 7.\n \nExample 1:\nInput: A = [1,1,2,2,3,3,4,4,5,5], target = 8\nOutput: 20\nExplanation: \nEnumerating by the values (A[i], A[j], A[k]):\n(1, 2, 5) occurs 8 times;\n(1, 3, 4) occurs 8 times;\n(2, 2, 4) occurs 2 times;\n(2, 3, 3) occurs 2 times.\n\nExample 2:\nInput: A = [1,1,2,2,2,2], target = 5\nOutput: 12\nExplanation: \nA[i] = 1, A[j] = A[k] = 2 occurs 12 times:\nWe choose one 1 from [1,1] in 2 ways,\nand two 2s from [2,2,2,2] in 6 ways.\n\n \nConstraints:\n\n3 <= A.length <= 3000\n0 <= A[i] <= 100\n0 <= target <= 300", "starter_code": "\nclass Solution:\n    def threeSumMulti(self, A: List[int], target: int) -> int:\n        ", "test_cases": {"inputs": [[[1, 1, 2, 2, 3, 3, 4, 4, 5, 5], 8]], "outputs": [20], "fn_name": "threeSumMulti"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e0f629d4d5860f8ac697847a8825edcd0fd5d3c9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "threeSumMulti"}
{"seed_id": "apps-00331", "original_id": null, "source": "apps", "domain": "code", "problem": "Given two positive integers n and k, the binary string  Sn is formed as follows:\n\nS1 = \"0\"\nSi = Si-1 + \"1\" + reverse(invert(Si-1)) for i > 1\n\nWhere + denotes the concatenation operation, reverse(x) returns the reversed string x, and invert(x) inverts all the bits in x (0 changes to 1 and 1 changes to 0).\nFor example, the first 4 strings in the above sequence are:\n\nS1 = \"0\"\nS2 = \"011\"\nS3 = \"0111001\"\nS4 = \"011100110110001\"\n\nReturn the kth bit in Sn. It is guaranteed that k is valid for the given n.\n \nExample 1:\nInput: n = 3, k = 1\nOutput: \"0\"\nExplanation: S3 is \"0111001\". The first bit is \"0\".\n\nExample 2:\nInput: n = 4, k = 11\nOutput: \"1\"\nExplanation: S4 is \"011100110110001\". The 11th bit is \"1\".\n\nExample 3:\nInput: n = 1, k = 1\nOutput: \"0\"\n\nExample 4:\nInput: n = 2, k = 3\nOutput: \"1\"\n\n \nConstraints:\n\n1 <= n <= 20\n1 <= k <= 2n - 1", "starter_code": "\nclass Solution:\n    def findKthBit(self, n: int, k: int) -> str:\n        ", "test_cases": {"inputs": [[3, 1]], "outputs": ["0"], "fn_name": "findKthBit"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "6c52a65c3e267dc4aed935fc600289931c741f7f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "findKthBit"}
{"seed_id": "apps-00336", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array arr of positive integers, consider all binary trees such that:\n\nEach node has either 0 or 2 children;\nThe values of arr correspond to the values of each leaf in an in-order traversal of the tree.  (Recall that a node is a leaf if and only if it has 0 children.)\nThe value of each non-leaf node is equal to the product of the largest leaf value in its left and right subtree respectively.\n\nAmong all possible binary trees considered, return the smallest possible sum of the values of each non-leaf node.  It is guaranteed this sum fits into a 32-bit integer.\n \nExample 1:\nInput: arr = [6,2,4]\nOutput: 32\nExplanation:\nThere are two possible trees.  The first has non-leaf node sum 36, and the second has non-leaf node sum 32.\n\n    24            24\n   /  \\          /  \\\n  12   4        6    8\n /  \\               / \\\n6    2             2   4\n\n \nConstraints:\n\n2 <= arr.length <= 40\n1 <= arr[i] <= 15\nIt is guaranteed that the answer fits into a 32-bit signed integer (ie. it is less than 2^31).", "starter_code": "\nclass Solution:\n    def mctFromLeafValues(self, arr: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[6, 2, 4]]], "outputs": [32], "fn_name": "mctFromLeafValues"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "52be0446af5fe219b32f78cccd7fa93e96cb76f7", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "mctFromLeafValues"}
{"seed_id": "apps-00341", "original_id": null, "source": "apps", "domain": "code", "problem": "A string is called happy if it does not have any of the strings 'aaa', 'bbb' or 'ccc' as a substring.\nGiven three integers a, b and c, return any string s, which satisfies following conditions:\n\ns is happy and longest possible.\ns contains at most a occurrences of the letter 'a', at most b occurrences of the letter 'b' and at most c occurrences of the letter 'c'.\ns will only contain 'a', 'b' and 'c' letters.\n\nIf there is no such string s return the empty string \"\".\n \nExample 1:\nInput: a = 1, b = 1, c = 7\nOutput: \"ccaccbcc\"\nExplanation: \"ccbccacc\" would also be a correct answer.\n\nExample 2:\nInput: a = 2, b = 2, c = 1\nOutput: \"aabbc\"\n\nExample 3:\nInput: a = 7, b = 1, c = 0\nOutput: \"aabaa\"\nExplanation: It's the only correct answer in this case.\n\n \nConstraints:\n\n0 <= a, b, c <= 100\na + b + c > 0", "starter_code": "\nclass Solution:\n    def longestDiverseString(self, a: int, b: int, c: int) -> str:\n        ", "test_cases": {"inputs": [[1, 1, 7]], "outputs": ["ccaccbcc"], "fn_name": "longestDiverseString"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "c584b6b638918c18d5d077d8cce8632d5a598744", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "longestDiverseString"}
{"seed_id": "apps-00346", "original_id": null, "source": "apps", "domain": "code", "problem": "We have a collection of rocks, each rock has a positive integer weight.\nEach turn, we choose any two rocks and smash them together.  Suppose the stones have weights x and y with x <= y.  The result of this smash is:\n\nIf x == y, both stones are totally destroyed;\nIf x != y, the stone of weight x is totally destroyed, and the stone of weight y has new weight y-x.\n\nAt the end, there is at most 1 stone left.  Return the smallest possible weight of this stone (the weight is 0 if there are no stones left.)\n \nExample 1:\nInput: [2,7,4,1,8,1]\nOutput: 1\nExplanation: \nWe can combine 2 and 4 to get 2 so the array converts to [2,7,1,8,1] then,\nwe can combine 7 and 8 to get 1 so the array converts to [2,1,1,1] then,\nwe can combine 2 and 1 to get 1 so the array converts to [1,1,1] then,\nwe can combine 1 and 1 to get 0 so the array converts to [1] then that's the optimal value.\n\n \nNote:\n\n1 <= stones.length <= 30\n1 <= stones[i] <= 100", "starter_code": "\nclass Solution:\n    def lastStoneWeightII(self, stones: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[2, 7, 4, 1, 8, 1]]], "outputs": [1], "fn_name": "lastStoneWeightII"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f525424219fd63390b110e923db612d0ff509d23", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "lastStoneWeightII"}
{"seed_id": "apps-00351", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string s, you are allowed to convert it to a palindrome by adding characters in front of it. Find and return the shortest palindrome you can find by performing this transformation.\n\nExample 1:\n\n\nInput: \"aacecaaa\"\nOutput: \"aaacecaaa\"\n\n\nExample 2:\n\n\nInput: \"abcd\"\nOutput: \"dcbabcd\"", "starter_code": "\nclass Solution:\n    def shortestPalindrome(self, s: str) -> str:\n        ", "test_cases": {"inputs": [["\"aacecaaa\""]], "outputs": ["\"aaacecaa\"aacecaaa\""], "fn_name": "shortestPalindrome"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2e7efc48e92de99115f5a7f2f3aa3ccc710af2df", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "shortestPalindrome"}
{"seed_id": "apps-00356", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a sorted array consisting of only integers where every element appears twice except for one element which appears once. Find this single element that appears only once. \n\n\nExample 1:\n\nInput: [1,1,2,3,3,4,4,8,8]\nOutput: 2\n\n\n\nExample 2:\n\nInput: [3,3,7,7,10,11,11]\nOutput: 10\n\n\n\nNote:\nYour solution should run in O(log n) time and O(1) space.", "starter_code": "\nclass Solution:\n    def singleNonDuplicate(self, nums: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[1, 1, 2, 3, 3, 4, 4, 8, 8]]], "outputs": [2], "fn_name": "singleNonDuplicate"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "89401ffa5bc97945bba8c558e7cb46dd9c27c3b6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "singleNonDuplicate"}
{"seed_id": "apps-00361", "original_id": null, "source": "apps", "domain": "code", "problem": "Write a program to take two numbers as input and print their difference if the first number is greater than the second number otherwise$otherwise$ print their sum.\n\n-----Input:-----\n- First line will contain the first number (N1$N1$)\n- Second line will contain the second number (N2$N2$)\n\n-----Output:-----\nOutput a single line containing the difference of 2 numbers (N1−N2)$(N1 - N2)$ if the first number is greater than the second number otherwise output their sum (N1+N2)$(N1 + N2)$.\n\n-----Constraints-----\n- −1000≤N1≤1000$-1000 \\leq N1 \\leq 1000$\n- −1000≤N2≤1000$-1000 \\leq N2 \\leq 1000$\n\n-----Sample Input:-----\n82\n28\n\n-----Sample Output:-----\n54", "starter_code": "", "test_cases": {"inputs": ["82\n28"], "outputs": ["54"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f9ba194a4629b8cb8bcaeb152b27cddd016c232a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00366", "original_id": null, "source": "apps", "domain": "code", "problem": "Write a program that takes in a letterclass ID of a ship and display the equivalent string class description of the given ID. Use the table below.\n\nClass ID Ship ClassB or bBattleShipC or cCruiserD or dDestroyerF or fFrigate\n\n-----Input-----\n\nThe first line contains an integer T, the total number of testcases. Then T lines follow, each line contains a character. \n\n-----Output-----\nFor each test case, display the Ship Class depending on ID, in a new line.\n\n-----Constraints-----\n- 1 ≤ T ≤ 1000\n\n-----Example-----\nInput\n\n3 \nB\nc\nD\n\nOutput\nBattleShip\nCruiser\nDestroyer", "starter_code": "", "test_cases": {"inputs": ["3\nB\nc\nD"], "outputs": ["BattleShip\nCruiser\nDestroyer"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "39b31fb535cb3d4f5d2dd739511fd4a12d3c4a2d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00371", "original_id": null, "source": "apps", "domain": "code", "problem": "Aureole the Techno-cultural fest of JEC thought of conducting a workshop on big data, as the topic is hot everyone wants to take part but due to limited seats in the Jashan Auditorium there is a selection criteria, a problem is given.\nthe problem states a string is to be compressed when two or more consecutive characters are same they are to be compressed into one character and the original number count is to be written after it ex. aaabb -> a3b2\nwhere every character is of 8bits and every integer is of 32bits\nyou are asked to find the difference in size between original string and compressed string\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single line of input $S$ the string to be compressed. \n\n-----Output:-----\nFor each testcase, output in a single line The difference in size.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$\n- $1 \\leq |S| \\leq 10^5$\n\n-----Subtasks-----\n- 40 points : S will contain only a-z\n- 60 points : S will contain 0-9 characters also\n\n-----Sample Input:-----\n1\naaabb\n\n-----Sample Output:-----\n-40\n\n-----EXPLANATION:-----\nthe resulting string will be a3b2 its size will be 80, original string size will be 40 so ans= 40-80", "starter_code": "", "test_cases": {"inputs": ["1\naaabb"], "outputs": ["-40"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "3c8a06a6744c927d0f07bf5084269b469e4d13b9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00376", "original_id": null, "source": "apps", "domain": "code", "problem": "The chef is playing a game of long distance. Chef has a number K and he wants to find the longest distance between the index of the first and the last occurrence of K in a given array of N numbers.\n\n-----Input:-----\n- First-line will contain $T$, the number of test cases. Then the test cases follow. \n- Each test case contains two lines of input.\n- Next line with Two integers in one line $K, N$.\n- Next line with $N$ space-separated integers.\n\n-----Output:-----\nFor each test case, output in a single line answer as the index of first and last occurrence of K in the given array.\nNote: Here Indexing is from 1 not  0 based.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$\n- $1 \\leq k \\leq 10^5$\n- $1 \\leq N \\leq 10^5$\n\n-----Sample Input:-----\n2\n2 6\n2 3 4 2 1 6\n4 6\n2 3 4 2 1 6\n\n-----Sample Output:-----\n3\n0\n\n-----EXPLANATION:-----\nFor 1) Index of First and last occurrence of 2 in the given array is at 1 and 4, i.e. distance is 3. \nFor 2) 4 occurs only once in the given array hence print 0.", "starter_code": "", "test_cases": {"inputs": ["2\n2 6\n2 3 4 2 1 6\n4 6\n2 3 4 2 1 6"], "outputs": ["3\n0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2b601b2dee456fafd1afd828a95a9eff7684a71b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00381", "original_id": null, "source": "apps", "domain": "code", "problem": "Bob has got some injury in his leg and due to this he can take exactly M steps in one move. \nBob enters a square field of size NxN. The field is only having one gate(for both entrance and exit) at its one of the corners. Bob started walking along the perimeter of square field.(remember Bob can only take exactly M steps in one move and cannot reverse his direction of motion).\nBob wants to know how many minimum number of moves he needs to come out(i.e. he reaches the same gate from where he entered into the field) from the square field. Tell the answer to Bob ASAP.\nLuckily, you came to know M=N+1.\n\n-----Input-----\n- The first line of the input contains an integer T denoting the number of test cases.\n-  Each test case contains a single integer N denoting the sides of the square.\n\n-----Output-----\n- For each test case, output a single line containing minimum number of moves Bob required to come out from the field.\n\n-----Constraints-----\n- 1 ≤ T ≤ 10000\n- 1 ≤ N ≤ 1000000000\n\n-----Example-----\nInput:\n2\n1\n2\n\nOutput:\n2\n8\n\n-----Explanation-----\nExample case 1.Let four corners of square be (0,0), (0,1), (1,1), (1,0). Let gate be at (0,0). Bob takes 2 steps in one move. Let movement of Bob be as follows (0,0) -> (1,1) -> (0,0). Thus minimum moves needed were 2. \nExample case 2.Let four corners of square be (0,0), (0,2), (2,2), (2,0). Let gate be at (0,0). Bob takes 3 steps in one move. Let movement of Bob be as follows (0,0) -> (2,1) -> (0,2) -> (1,0) -> (2,2) -> (0,1) -> (2,0) -> (1,2) -> (0,0). Thus minimum number of moves needed are 8.", "starter_code": "", "test_cases": {"inputs": ["2\n1\n2"], "outputs": ["2\n8"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "316a88589b3eff0ceeca4ef71dc5eba02ed43ee7", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00386", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef wants to serve mankind by making people immortal by preparing a dish, a dish of life - a dish with the best taste in the universe, one with the smell and splash of fresh water flowing down the springs of the mountain, one with the smell of the best lily flowers of the garden, one that has contained the very essence of life in a real sense. \nThis dish will contain K ingredients that are found only in remote islands amid mountains. For sake of convenience, we enumerate the ingredients by the integers from 1 to K, both inclusive. There are N islands and each of them offers some ingredients. Chef being a little child did not know how to collect the ingredients for the recipe. He went to all the islands and bought all the ingredients offered in each island. Could he possibly have saved some time by skipping some island? If it was not possible for Chef to collect the required ingredients (i.e. all the K ingredients), output \"sad\". If it was possible for him to skip some islands, output \"some\", otherwise output \"all\".\n\n-----Input-----\nFirst line of the input contains an integer T denoting number of test cases. The description of T test cases follow.\nThe first line of each test case contains two space separated integers N, K.\nThe i-th of the next lines will contain first an integer Pi, denoting the number of ingredients grown in the i-th island, followed by Pi distinct integers in the range [1, K]. All the integers are space separated. \n\n-----Output-----\nFor each test case, output a single line containing one of the strings \"sad\", \"all\" or \"some\" (without quotes) according to the situation. \n\n-----Constraints-----\n- 1 ≤ T  ≤ 10\n- 1 ≤ N, K ≤ 105\n- 1 ≤ Pi ≤ K\n- Sum of Pi over all test cases ≤ 106\n\n-----Subtasks-----\nSubtask #1 (30 points)\n- 1 ≤ N, K ≤ 50\n\nSubtask #2 (30 points)\n- 1 ≤ K ≤ 50\n\nSubtask #3 (40 points)\n- original constraints\n\n-----Example-----\nInput\n3\n3 4\n3 1 2 3\n2 1 3\n2 1 2\n2 3\n3 1 2 3\n2 1 3\n2 3\n2 1 2\n2 1 3\n\nOutput\nsad\nsome\nall\n\n-----Explanation-----\nExample 1. The ingredient 4 is not available in any island, so Chef can't make the dish of life. Hence, the answer is \"sad\".\nExample 2. Chef can just go to the first island and collect all the three ingredients required. He does not need to visit the second island. So, the answer is \"some\".\nExample 3. Chef has to visit both the islands in order to obtain all the three ingredients. So, the answer is \"all\".", "starter_code": "", "test_cases": {"inputs": ["3\n3 4\n3 1 2 3\n2 1 3\n2 1 2\n2 3\n3 1 2 3\n2 1 3\n2 3\n2 1 2\n2 1 3"], "outputs": ["sad\nsome\nall"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8f73568a383ee90b830d993125c35c0b2e370559", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00391", "original_id": null, "source": "apps", "domain": "code", "problem": "Johnny was asked by his math teacher to compute nn (n to the power of n, where n is an integer), and has to read his answer out loud. This is a bit of a tiring task, since the result is probably an extremely large number, and would certainly keep Johnny occupied for a while if he were to do it honestly. But Johnny knows that the teacher will certainly get bored when listening to his answer, and will sleep through most of it! So, Johnny feels he will get away with reading only the first k digits of the result before the teacher falls asleep, and then the last k digits when the teacher wakes up.\n\nWrite a program to help Johnny to compute the digits he will need to read out.\n\n-----Input-----\nThe first line contains t, the number of test cases (about 30000). Then t test cases follow.\nEach test case consists of one line containing two numbers n and k (1 ≤ n ≤ 109, 1 ≤ k ≤ 9). It is guaranteed that k is not more than the number of digits of nn.\n\n-----Output-----\nFor each test case, print out one line containing two numbers, separated by a space, which are the first and the last k digits of nn.\n\n-----Example-----\nInput\n2\n4 2\n9 3\n\nOutput\n25 56\n387 489", "starter_code": "", "test_cases": {"inputs": ["2\n4 2\n9 3"], "outputs": ["25 56\n387 489"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f71144d6491ead3ef4d9f2eaad4b69e7c0d8ecb1", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00396", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef is the judge of a competition. There are two players participating in this competition — Alice and Bob.\nThe competition consists of N races. For each i (1 ≤ i ≤ N), Alice finished the i-th race in Ai minutes, while Bob finished it in Bi minutes. The player with the smallest sum of finish times wins. If this total time is the same for Alice and for Bob, a draw is declared.\nThe rules of the competition allow each player to choose a race which will not be counted towards their total time. That is, Alice may choose an index x and her finish time in the race with this index will be considered zero; similarly, Bob may choose an index y and his finish time in the race with this index will be considered zero. Note that x can be different from y; the index chosen by Alice does not affect Bob's total time or vice versa.\nChef, as the judge, needs to announce the result of the competition. He knows that both Alice and Bob play optimally and will always choose the best option. Please help Chef determine the result!\n\n-----Input-----\n- The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.\n- The first line of each test case contains a single integer N.\n- The second line contains N space-separated integers A1, A2, ..., AN.\n- The third line contains N space-separated integers B1, B2, ..., BN.\n\n-----Output-----\nFor each test case, print a single line containing the string \"Alice\" if Alice wins, \"Bob\" if Bob wins or \"Draw\" if the result is a draw (without quotes).\n\n-----Constraints-----\n- 1 ≤ T ≤ 100\n- 2 ≤ N ≤ 100\n- 1 ≤ Ai ≤ 1000 for each valid i\n- 1 ≤ Bi ≤ 1000 for each valid i\n\n-----Example-----\nInput:\n\n3\n5\n3 1 3 3 4\n1 6 2 5 3\n5\n1 6 2 5 3\n3 1 3 3 4\n3\n4 1 3\n2 2 7\n\nOutput:\n\nAlice\nBob\nDraw\n\n-----Explanation-----\nExample case 1: Alice will choose the finish time in the last race to be considered zero, which means her sum of finish times is 3 + 1 + 3 + 3 + 0 = 10, while Bob will choose the finish time of his second race to be considered zero, so his total sum of finish times is 1 + 0 + 2 + 5 + 3 = 11. Since Alice's sum is smaller, she is considered the winner.\nExample case 2: We're dealing with the same situation as in the previous case, but finish times for the players are swapped, so Bob wins this time.\nExample case 3: Alice will choose the finish time of the first race to be considered zero, which means her total time is 0 + 1 + 3 = 4. Bob will choose the finish time of his last race to be considered zero, which makes his total time 2 + 2 + 0 = 4. The competition is considered a draw because both players have equal sums of finish times.", "starter_code": "", "test_cases": {"inputs": ["3\n5\n3 1 3 3 4\n1 6 2 5 3\n5\n1 6 2 5 3\n3 1 3 3 4\n3\n4 1 3\n2 2 7"], "outputs": ["Alice\nBob\nDraw"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "445b00353ef823e7eb647cda87209755c0a86f2d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00401", "original_id": null, "source": "apps", "domain": "code", "problem": "\"If you didn't copy assignments during your engineering course, did you even do engineering?\"\nThere are $Q$ students in Chef's class. Chef's teacher has given the students a simple assignment:\nWrite a function that takes as arguments an array $A$ containing only unique elements and a number $X$ guaranteed to be present in the array and returns the ($1$-based) index of the element that is equal to $X$.\nThe teacher was expecting a linear search algorithm, but since Chef is such an amazing programmer, he decided to write the following binary search function:\ninteger binary_search(array a, integer n, integer x):\ninteger low, high, mid\nlow := 1\nhigh := n\nwhile low ≤ high:\nmid := (low + high) / 2\nif a[mid] == x:\nbreak\nelse if a[mid] is less than x:\nlow := mid+1\nelse:\nhigh := mid-1\nreturn mid\n\nAll of Chef's classmates have copied his code and submitted it to the teacher.\nChef later realised that since he forgot to sort the array, the binary search algorithm may not work. Luckily, the teacher is tired today, so she asked Chef to assist her with grading the codes. Each student's code is graded by providing an array $A$ and an integer $X$ to it and checking if the returned index is correct. However, the teacher is lazy and provides the exact same array to all codes. The only thing that varies is the value of $X$.\nChef was asked to type in the inputs. He decides that when typing in the input array for each code, he's not going to use the input array he's given, but an array created by swapping some pairs of elements of this original input array. However, he cannot change the position of the element that's equal to $X$ itself, since that would be suspicious.\nFor each of the $Q$ students, Chef would like to know the minimum number of swaps required to make the algorithm find the correct answer.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $Q$ denoting the number of elements in the array and the number of students.\n- The second line contains $N$ space-separated integers $A_1, A_2, \\dots, A_N$.\n- The following $Q$ lines describe queries. Each of these lines contains a single integer $X$.\n\n-----Output-----\nFor each query, print a single line containing one integer — the minimum required number of swaps, or $-1$ if it is impossible to make the algorithm find the correct answer. (Do you really think Chef can fail?)\n\n-----Constraints-----\n- $1 \\le T \\le 10$\n- $1 \\le N, Q \\le 10^5$\n- $1 \\le A_i \\le 10^9$ for each valid $i$\n- $1 \\le X \\le 10^9$\n- all elements of $A$ are pairwise distinct\n- for each query, $X$ is present in $A$\n- sum of $N$ over all test cases $\\le 5\\cdot10^5$\n- sum of $Q$ over all test cases $\\le 5\\cdot10^5$\n\n-----Subtasks-----\nSubtask #1 (20 points): $1 \\le N \\le 10$\nSubtask #2 (30 points):\n- $1 \\le A_i \\le 10^6$ for each valid $i$\n- $1 \\le X \\le 10^6$\nSubtask #3 (50 points): original constraints\n\n-----Example Input-----\n1\n7 7\n3 1 6 7 2 5 4\n1\n2\n3\n4\n5\n6\n7\n\n-----Example Output-----\n0\n1\n1\n2\n1\n0\n0\n\n-----Explanation-----\nExample case 1:\n- Query 1: The algorithm works without any swaps.\n- Query 2: One solution is to swap $A_2$ and $A_4$.\n- Query 3: One solution is to swap $A_2$ and $A_6$.\n- Query 4: One solution is to swap $A_2$ with $A_4$ and $A_5$ with $A_6$.\n- Query 5: One solution is to swap $A_2$ and $A_4$.\n- Query 6: The algorithm works without any swaps.\n- Query 7: The algorithm works without any swaps.", "starter_code": "", "test_cases": {"inputs": ["1\n7 7\n3 1 6 7 2 5 4\n1\n2\n3\n4\n5\n6\n7"], "outputs": ["0\n1\n1\n2\n1\n0\n0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f70562a882db16a628c60becf23c5bf49ea17751", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00406", "original_id": null, "source": "apps", "domain": "code", "problem": "Find out the maximum sub-array of non negative numbers from an array. \n\nThe sub-array should be continuous. That is, a sub-array created by choosing the second and fourth element and skipping the third element is invalid.\n\nMaximum sub-array is defined in terms of the sum of the elements in the sub-array. Sub-array A is greater than sub-array B if sum(A) > sum(B).\n\nNOTE 1 :If there is a tie, then compare with segment's length and return segment which has maximum length \n\nNOTE 2: If there is still a tie, then return the segment with minimum starting index.\n\n-----Input-----\n\nThe first line contains the number of test cases. Each test cases contains an integer N. next line consists of N integers, the elements of the array.\n\n-----Output-----\n\nPrint out the maximum sub-array as stated above.\n\n-----Constraints-----\n-  1  ≤  T  ≤  100 \n-  1  ≤  N  ≤  105 \n-  1  ≤  Ai  ≤  105 \n\n-----Example-----\nInput:\n\n1\n6\n1 2 5 -7 2 3\n\nOutput:\n\n1 2 5", "starter_code": "", "test_cases": {"inputs": ["1\n6\n1 2 5 -7 2 3"], "outputs": ["1 2 5"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "233c9991c89051af8fec1bee567d43ad5a1cc47a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00411", "original_id": null, "source": "apps", "domain": "code", "problem": "Humpy, the little elephant, has his birthday coming up. He invited all his cousins but doesn’t know how many of them are really coming as some of them are having exams coming up. He will only get to know how many of them are coming on the day of his birthday.\n\nHe ordered sugarcane for his party, of length L.\n\nHumpy’s mom decided that she will be dividing the sugarcane among Humty and his friends in a way such that they get the sugarcane in ratio of their ages.\n\nYour task is to determine whether it is possible to serve sugarcane to everyone as integral multiples of their ages.\n\n-----INPUT-----\nFirst line of input contains an integer N, denoting the number of test cases.\n\nThen N test cases follow.\n\nThe first line of each test case contains three integers K, L and E. K denoting the number of friends coming; L denoting the length of the sugarcane and E denoting the age of the little elephant. Next line has  K  space separated integers denoting the age of friends who came to the party.\n\n-----OUTPUT-----\n\nFor each test case, output “YES” (without quotes) if everyone gets their part as integral multiples of their ages; otherwise output “NO”(without quotes).\n\n-----CONSTRAINTS-----\n\n- 1 <= T<=30\n- 1 <= K<=1000\n- 1 <= L<=1000000\n- 1 <= E<=100000\n- 1 <= Age of Cousins<=100000\n\n-----Example-----\nInput:\n2\n4 10 2\n2 2 3 1\n4 12 3\n6 5 7 3\n\nOutput:\nYES \nNO", "starter_code": "", "test_cases": {"inputs": ["2\n4 10 2\n2 2 3 1\n4 12 3\n6 5 7 3"], "outputs": ["YES\nNO"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "6408dd48702e8af62d537895ab0fa1f33c932220", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00416", "original_id": null, "source": "apps", "domain": "code", "problem": "On a planet called RUIZ LAND, which is ruled by the queen, Erika Ruiz. Each person on that planet has a strength value (strength value >0).\nThat planet has a special rule made by the queen that a boy and a girl will form a couple if their Hate value is a prime number where $Hate$ is given by the formula:-\nHate = (boy's strength value)  XOR (girl's strength value )\nYou are given $N$ numbers denoting the strength value of $N$ girls, and each of the $N$ girls has to form a couple with a boy such that sum of $Hate$ value of all the $N$ couples will be minimum.\nYou need to print the strength value of each boy, Where the boy at index $i$ will form a couple with the girl at index $i$, where $1 \\leq i \\leq N$.\nAssume that you can always find at least one boy having that strength for each girl.\n\n-----Input:-----\n- First line will contain $N$, the number of Girls. \n- Next line contains $N$ numbers separated by space denoting strength value for each girl.\n\n-----Output:-----\nPrint the required $N$ numbers denoting strength of boys.\n\n-----Constraints-----\n- $1 \\leq N \\leq 100000$\n- $1 \\leq A_i \\leq 10^9$ , (where $1 \\leq i \\leq N$) and $A_i$ denotes strength of i'th girl.\n\n-----Sample Input:-----\n2\n10 16\n\n-----Sample Output:-----\n8 18", "starter_code": "", "test_cases": {"inputs": ["2\n10 16"], "outputs": ["8 18"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "772f5148d0da931cf9113e17411b3c1217e430c4", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00421", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a string $S$. Find the number of ways to choose an unordered pair of non-overlapping non-empty substrings of this string (let's denote them by $s_1$ and $s_2$ in such a way that $s_2$ starts after $s_1$ ends) such that their concatenation $s_1 + s_2$ is a palindrome.\nTwo pairs $(s_1, s_2)$ and $(s_1', s_2')$ are different if $s_1$ is chosen at a different position from $s_1'$ or $s_2$ is chosen at a different position from $s_2'$.\n\n-----Input-----\nThe first and only line of the input contains a single string $S$.\n\n-----Output-----\nPrint a single line containing one integer — the number of ways to choose a valid pair of substrings.\n\n-----Constraints-----\n- $1 \\le |S| \\le 1,000$\n- $S$ contains only lowercase English letters\n\n-----Subtasks-----\nSubtask #1 (25 points): $|S| \\le 100$\nSubtask #2 (75 points): original constraints\n\n-----Example Input-----\nabba\n\n-----Example Output-----\n7\n\n-----Explanation-----\nThe following pairs of substrings can be chosen: (\"a\", \"a\"), (\"a\", \"ba\"), (\"a\", \"bba\"), (\"ab\", \"a\"), (\"ab\", \"ba\"), (\"abb\", \"a\"), (\"b\", \"b\").", "starter_code": "", "test_cases": {"inputs": ["abba"], "outputs": ["7"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8d1607f201ba64ee8a31d5a3786fcbe717c8dded", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00426", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef Loves to listen to remix songs, but currently he had already finished the entire playlist of remix songs.\nAs Chef is smart, so he thought let's make my own remix songs of the original songs.\nChef is not having much knowledge of making remix songs, so he came up with the simple technique in which he will pick the word which contains the smallest number of characters from the lyrics of the song, and then he will append that word to the start and end of the lyrics, also Chef will insert this word between every two words of the lyrics.\nNote: While inserting a new word Chef will also insert extra white-spaces, so that every word in the final remixed lyrics is separated by space.\nIt is Recommended to use fast Input/Ouput techniques.\n\n-----Input:-----\n- The input contains the text $S$, which denotes the lyrics of the song.\n\n-----Output:-----\n- Print the Remixed, lyrics as done by Chef.\n\n-----Constraints:-----\n- $1 \\leq Length of text $S$ \\leq 10^7$\n\n-----Sample Input:-----\nMai Hu Jiyaan\n\n-----Sample Output:-----\nHu Mai Hu Hu Hu Jiyaan Hu", "starter_code": "", "test_cases": {"inputs": ["Mai Hu Jiyaan"], "outputs": ["Hu Mai Hu Hu Hu Jiyaan Hu"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "5eb24a68f23237ed750e61e284db75a804bb5871", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00431", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef published a blog post, and is now receiving many queries about it. On day $i$, he receives $Q_i$ queries. But Chef can answer at most $k$ queries in a single day. \nChef always answers the maximum number of questions that he can on any given day (note however that this cannot be more than $k$). The remaining questions (if any) will be carried over to the next day.\nFortunately, after $n$ days, the queries have stopped. Chef would like to know the first day during which he has some free time, i.e. the first day when he answered less than $k$ questions. \n\n-----Input:-----\n- First line will contain $T$, the number of testcases. Then the testcases follow.\n- The first line of each testcase contains two space separated integers $n$ and $k$.\n- The second line of each testcase contains $n$ space separated integers, namely $Q_1, Q_2, ... Q_n$.\n\n-----Output:-----\nFor each testcase, output in a single line the first day during which chef answers less than $k$ questions. \n\n-----Constraints-----\n- $1 \\leq T \\leq 10^5$\n- $1 \\leq $ sum of $n$ over all testcases $ \\leq 10^5$\n- $1 \\leq k \\leq 10^8$\n- $0 \\leq Q_i \\leq 10^8$\n\n-----Subtasks-----\n- Subtask 1 - 20% points - Sum of $Q_i$ over all testcases and days $\\leq 3 . 10^6$\n- Subtask 2 - 80% points - Original constraints\n\n-----Sample Input:-----\n2 \n6 5 \n10 5 5 3 2 1 \n1 1\n100\n\n-----Sample Output:-----\n6\n101\n\n-----Explanation:-----\nTest Case 1\nOn the first day, chef answers 5 questions and leaves the remaining 5 (out of the 10) for the future days.\nOn the second day, chef has 10 questions waiting to be answered (5 received on the second day and 5 unanswered questions from day 1). Chef answers 5 of these questions and leaves the remaining 5 for the future.\nOn the third day, chef has 10 questions waiting to be answered (5 received on the third day and 5 unanswered questions from earlier). Chef answers 5 of these questions and leaves the remaining 5 for later.\nOn the fourth day, chef has 8 questions waiting to be answered (3 received on the fourth day and 5 unanswered questions from earlier). Chef answers 5 of these questions and leaves the remaining 3 for later.\nOn the fifth day, chef has 5 questions waiting to be answered (2 received on the fifth day and 3 unanswered questions from earlier). Chef answers all 5 of these questions.\nOn the sixth day, chef has 1 question, which he answers. This is the first day he answers less than 5 questions, and so the answer is 6.\nTest Case 2\nChef answers 1 question a day for the first 100 days. On day 101, he is free.", "starter_code": "", "test_cases": {"inputs": ["2\n6 5\n10 5 5 3 2 1\n1 1\n100"], "outputs": ["6\n101"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2f5317eb98fe84df25198dd8476d7d0275241b0c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00436", "original_id": null, "source": "apps", "domain": "code", "problem": "Nexus 4.O is going to be organized by ASME, GLA University. Shubhanshu, Head of Finance Team is working for it. He has $N$ number of bills of different values as $a$$1$,$ a$$2$, $a$$3$…$a$$n$.\nHe is interested in a game in which one has to do the addition of the bills. But due to privacy concerns, he cannot share the details with others. \nHe can only trust his best friend Avani with such a confidential thing. So, he asked her to play this game.\nRules of the game :\n- Avani needs to answer $Q$ queries.\n- Every $Q$$i$ query has 2 values $X$$i$ and $Y$$i$.\n- Avani needs to find the sum of the values between $X$$i$ and $Y$$i$ (inclusive).\nSo, you need to help Avani in answering the $Q$ queries\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- The first line of each test case contains the value $N$ and $Q$.\n- The second line of each test case contains the $N$ space-separated values as $a$$1$,$ a$$2$, $a$$3$…$a$$n$.\n- The next line of each test case containing $Q$ query with $X$$i$ and $Y$$i$.\n\n-----Output:-----\nFor each test case, Print the total amount between $X$$i$ and $Y$$i$ for $Q$ number of queries.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$\n- $1 \\leq N \\leq 10^5$\n- $1 \\leq Q \\leq 10^5$\n- $1 \\leq a$$i$$ \\leq 10^9$\n\n-----Subtasks (25 points) :-----\n- $1 \\leq N \\leq 10^2$.\n- $1 \\leq Q \\leq 10^2$.\n- $1 \\leq a$$i$$ \\leq 10^5$.\n\n-----Subtasks (25 points) :-----\n- $1 \\leq N \\leq 10^3$.\n- $1 \\leq Q \\leq 10^3$.\n- $1 \\leq a$$i$$ \\leq 10^5$.\n\n-----Subtasks (50 points) :-----\n- $Original  Constraints$.\n\n-----Sample Input:-----\n1\n8 3\n1 2 3 4 5 6 7 8\n2 3\n1 6\n5 8\n\n-----Sample Output:-----\n5\n21\n26\n\n-----EXPLANATION:-----\n$Q$$1$ : (2,3) 2+3=5\n$Q$$2$ : (1,6) 1+2+3+4+5+6=21\n$Q$$3$ : (5,8) 5+6+7+8=26", "starter_code": "", "test_cases": {"inputs": ["1\n8 3\n1 2 3 4 5 6 7 8\n2 3\n1 6\n5 8"], "outputs": ["5\n21\n26"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "0e655af2996e45f2dd88433bd0eaf3340015cfcb", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00441", "original_id": null, "source": "apps", "domain": "code", "problem": "Find the length of the longest contiguous segment in an array, in which if a given element $K$ is inserted, $K$ becomes the second largest element of that subarray.\n\n-----Input:-----\n- The first line will contain $T$, number of test cases. Then the test cases follow. \n- The first line of each test case contains two integers $N$ and $K$.\n- The next line contains N space-separated integers Ai denoting the elements of the array.\n\n-----Output:-----\nPrint a single line corresponding to each test case — the length of the largest segment.\n\n-----Constraints-----\n- $1 \\leq T \\leq 10$\n- $1 \\leq N \\leq 10^6$\n- $1 \\leq Ai, K \\leq 10^9$\n- Sum of N across all test cases doesn't exceed $10^6$\n\n-----Sample Input:-----\n2\n5 3\n2 4 2 4 2\n8 5\n9 3 5 7 8 11 17 2\n\n-----Sample Output:-----\n5\n3\n\n-----EXPLANATION:-----\nIf 3 is inserted at anywhere in the array, it is the second largest element. Hence the maximum length is 5.\nIf 5 is inserted anywhere between 1st and 4th element, it is the second largest element. The length of such subarray is 3.", "starter_code": "", "test_cases": {"inputs": ["2\n5 3\n2 4 2 4 2\n8 5\n9 3 5 7 8 11 17 2"], "outputs": ["5\n3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "294d0d182f9215f5df2058a94823d7f267dd9249", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00446", "original_id": null, "source": "apps", "domain": "code", "problem": "Cersei wants to be the queen of seven kingdoms.\n\nFor this to happen, she needs to address the soldiers in her army. There are n$n$ soldiers in her army (numbered 1$1$ through n$n$). Cersei passes on the message to the first soldier (soldier 1).   \nThis message needs to reach every soldier in the army. For this, the soldiers communicate among themselves by one soldier passing the message to another soldier through some communication links. It is known that the message could reach every soldier using the given links.\nNow, each soldier will receive the message from exactly one soldier or Cersei and could pass on the message to atmost two soldiers. That is each soldier (except soldier 1) has only one incoming link and every soldier (including soldier 1) has atmost two outgoing links.  \nNow, the High Sparrow feels that Cersei is planning to kill his people first. Hence, for the sake of his people, he decided to appoint some sparrows to overhear every conversation between the soldiers (The conversation between Cersei and the first soldier needn't be overheard due to the fear of Ser Gregor Clegane).   \nTo overhear a conversation between soldiers A$A$ and B$B$, there needs to be a sparrow either at soldier A$A$ or soldier B$B$ or both.\nAlso, by his research, the High Sparrow has found that the soldiers are partitioned into some classes (1$1$ to k$k$). That is, every soldier belongs to exactly one class. He then demands the presence of atleast one sparrow with each class he knows (1$1$ to k$k$).\nFind the minimum number of sparrows the High Sparrow needs to recruit for the job or tell that he couldn't.\n\n-----Input:-----\n- The first line of the input contains the number of test cases t$t$.\n- The first line of each test case gives the number of soldiers n$n$ in the army, the number of communication links m$m$ between the soldiers and the number of classes k$k$ in soldiers.\n- The next line of the test case consists of n$n$ integers A1,A2....An$A_1,A_2....A_n$ each denoting the class of the ith$i^{th}$ soldier.\n- The next m$m$ lines of the test case contain two integers u$u$ and v$v$, which denotes that soldier u$u$ can pass a message to soldier v$v$ (u≠v$u \\neq v$).\n\n-----Output:-----\nFor each test case, print in a single line the minimum number of sparrows required for the above task or print −1$-1$ if no such way is possible.\n\n-----Constraints-----\n- 1≤t≤500$1 \\leq t \\leq 500$\n- 1≤n≤2500$1 \\leq n \\leq 2500$\n- m=n−1$m = n - 1$\n- 1≤k≤10$1 \\leq k \\leq 10$\n- 1≤ai≤k$1 \\leq a_i \\leq k$\n- The sum of n$n$ over all test cases is ≤2500$\\leq 2500$.\n\n-----Sample Input:-----\n1\n5 4 3\n1 1 2 2 3\n1 2\n1 3\n2 4\n2 5\n\n-----Sample Output:-----\n3\n\n-----EXPLANATION:-----\nSelecting soldiers 1,4,5 would satisfy all the conditions.\n\n-----Sample Input:-----\n1\n5 4 5\n1 1 2 2 3\n1 2\n1 3\n2 4\n2 5\n\n-----Sample Output:-----\n-1\n\n-----EXPLANATION:-----\nClasses 4 and 5 are not present. So, there is no way possible.", "starter_code": "", "test_cases": {"inputs": ["1\n5 4 3\n1 1 2 2 3\n1 2\n1 3\n2 4\n2 5"], "outputs": ["3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2f06f4f8b9d9d0944ea2b61a477d3b5264f94f17", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00451", "original_id": null, "source": "apps", "domain": "code", "problem": "A balanced parenthesis string is defined as follows:\n- The empty string is balanced\n- If P is balanced, (P) is also \n- If P and Q are balanced, PQ is also balanced\nYou are given two even integers n$n$ and k$k$. Find any balanced paranthesis string of length n$n$ that doesn't contain a balanced substring of length k$k$, or claim that no such string exists.\n\n-----Input-----\n- First line will contain T$T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single line containing n$n$ and k$k$.\n\n-----Output-----\nFor every testcase, print on a new line, any balanced paranthesis string of length n$n$ that doesn't contain a balanced substring of length k$k$. If there doesn't exist any such string, print −1$-1$ instead.\n\n-----Constraints-----\n- 1≤T≤50000$1 \\leq T \\leq 50000$\n- 2≤k≤n≤105$2 \\leq k \\leq n \\leq 10^5$\n- Sum of n$n$ over all testcases doesn't exceed 105$10^5$.\n- n$n$ and k$k$ are both even integers.\n\n-----Example Input-----\n2\n4 2\n8 6\n\n-----Example Output-----\n-1\n(())(())\n\n-----Explanation-----\nIn the first testcase, the only balanced strings of length 4$4$ are (()) and ()(), both of which contain () as a substring.\nIn the second testcase, (())(()) is a balanced string that doesn't contain any balanced substring of length 6$6$.", "starter_code": "", "test_cases": {"inputs": ["2\n4 2\n8 6"], "outputs": ["-1\n(())(())"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "63d5e2cf0ac69490017811accd5e13ad842fe2f6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00456", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef is the leader of Chef's Earth Defense Organization, and his mission is to counter aliens which are threatening the earth. According to information gathered by the organization, there are $N$ alien spaceships (numbered $1$ through $N$) planning to invade the earth. The $i$-th spaceship will appear on the radar at time $C_i$. Each spaceship needs $D$ time to reach earth once it appears on the radar. \nChef's organization owns a huge laser cannon which can destroy one spaceship in one shot. However, once the cannon is used once it needs some amount of cool-down time in order to be used again (first shot doesn't require cool-down time before it is used). This cool-down time, however, is configurable. It has to be set before the first shot, and cannot be changed after that. If Chef sets a lower cool-down time, that would increase the energy consumed by the cannon, and vice-versa - the higher the cool-down time, the lower the energy consumed.\nThis might be a long battle, and Chef wants to use as little energy as possible. So Chef wants to maximize the cool-down time while still being able to destroy all spaceships before any of them arrive on earth. In particular, the $i$-th spaceship should be shot between the times $C_i$ and $C_i + D$ (both end points inclusive).\n\n-----Input:-----\n- The first line of input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two integers $N$ and $D$. \n- The second line contains $N$ space-separated integers $C_1, C_2, \\ldots, C_N$.\n\n-----Output:-----\nFor each test case, print a single line containing one real number― the maximum cool-down time possible. Your answer will be considered correct if the absolute or relative error of the answer does not exceed $10^{-6}$.\n\n-----Constraints-----\n- $1 \\leq T \\leq 1000$\n- $2 \\leq N \\leq 10^5$\n- $1 \\leq C_i \\leq 10^9$ for each valid $i$\n- $1 \\leq D \\leq 10^9$\n- The sum of $N$ over all test cases does not exceed $10^6$\n\n-----Subtasks-----\nSubtask #1 (50 points): \n- $N \\le 1,000$\n- the sum of $N$ over all test cases does not exceed $10,000$\nSubtask #2 (50 points): Original constraints\n\n-----Sample Input:-----\n2\n3 2\n3 2 3\n2 1\n5 6\n\n-----Sample Output:-----\n1.5000000000\n2.0000000000", "starter_code": "", "test_cases": {"inputs": ["2\n3 2\n3 2 3\n2 1\n5 6"], "outputs": ["1.5000000000\n2.0000000000"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "993f56f78bc203a69541357a449246cd380ec468", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00461", "original_id": null, "source": "apps", "domain": "code", "problem": "Ashley wrote a random number generator code.\nDue to some reasons, the code only generates random positive integers which are not evenly divisible by 10. She gives $N$ and $S$ as input to the random number generator. The code generates a random number with number of digits equal to $N$ and sum of digits equal to $S$. The code returns -1 if no number can be generated. Print \"-1\" in such cases (without quotes). Else print the minimum possible product of digits of the random number generated.\n\n-----Input:-----\n- First line will contain a single integer $T$, the number of testcases. \n- Each testcase consists of two space separated integers, $N$ and $S$. \n\n-----Output:-----\nFor each testcase, output the answer on a new line.\n\n-----Constraints-----\n- $1 \\leq T \\leq 10^5$\n- $1 \\leq N \\leq 18$\n- $1 \\leq S \\leq 5 * N$\n\n-----Sample Input:-----\n2\n1 5\n\n2 2\n\n-----Sample Output:-----\n5\n\n1\n\n-----EXPLANATION:-----\nIn first testcase, the only possible number of length 1 having digit sum 5 is 5. And it's product of digits is 5. \nIn second testcase,  only possible two digit number as a generator output is 11(as 20 is divisible by 10, it is never generated) and product of it's digits is 1.", "starter_code": "", "test_cases": {"inputs": ["2\n1 5\n2 2"], "outputs": ["5\n1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "065169e3c3f9af020851d5818dab2baae3a38a61", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00466", "original_id": null, "source": "apps", "domain": "code", "problem": "Shubham recently learned the lexicographical order in strings.\n\nNow, he has two strings s1  and  s2  of the equal size and Shubham wants to compare those two strings lexicographically.\n\nHelp Shubham with the strings comparison.\n\nNote:\n\nLetters are case insensitive. \n\n\n-----Input-----\n\nFirst line contains a integer T denoting the number of test cases. Each test case contains two strings of equal size in two separate lines.\n\n-----Output-----\n\nFor each test case,\n\nIf s1 < s2, print \"first\".\n\nIf s1 > s2, print \"second\".\n\nIf s1=s2, print \"equal\".\n\n\nin separate lines.\n\n-----Constraints-----\n\n- 1 ≤ T ≤ 10^2\n- 1 ≤ Length of the string ≤ 500\n\n-----Example-----\nInput:\n2\nabc\nacb\nAB\nba\n\nOutput:\nfirst\nfirst", "starter_code": "", "test_cases": {"inputs": ["2\nabc\nacb\nAB\nba"], "outputs": ["first\nfirst"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "ada19d58fe4d8aea846518156bdf74e7521faa00", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00471", "original_id": null, "source": "apps", "domain": "code", "problem": "You will be given a two-dimensional array with row consisting values 0 or 1.  \nA move consists of choosing any column or row, and toggling all the 0’s as 1’s and 1’s as 0’s.  \nAfter making the required moves, every row represents a binary number and the score of the matrix will be sum of all the numbers represented as binary numbers in each row.  \nFind the highest possible score.  \n$Example:$ \nInput:\n\n0 0 1 1\n\n1 0 1 0\n\n1 1 0 0  \nOutput:\n\n39\nExplanation:\n\nToggled to\n\n1 1 1 1\n\n1 0 0 1\n\n1 1 1 1  \n0b1111 + 0b1001 + 0b1111 = 15 + 9 + 15 = 39\n\n-----Input:-----\n- First line will contains $m$, $n$ for the size of the 2-D array. \n- Contains $m$ lines of $n$ space-separated values each. \n\n-----Output:-----\nSingle integer which is the maximum score obtained by the sum of binary numbers.\n\n-----Constraints-----\n- $1 \\leq m, n \\leq 20$\n- $A[i][j] = 1$ or $0$ \n\n-----Sample Input:-----\n3 4  \n0 0 1 1  \n1 0 1 0  \n1 1 0 0  \n\n-----Sample Output:-----\n39", "starter_code": "", "test_cases": {"inputs": ["3 4\n0 0 1 1\n1 0 1 0\n1 1 0 0"], "outputs": ["39"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "81a58d67a9961d2fc3a089700bc90b6e937ec848", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00476", "original_id": null, "source": "apps", "domain": "code", "problem": "This year $p$ footballers and $q$ cricketers have been invited to participate in IPL (Indian Programming League) as guests. You have to accommodate them in $r$ rooms such that-\n- No room may remain empty.\n- A room may contain either only footballers or only cricketers, not both.\n- No cricketers are allowed to stay alone in a room.\nFind the number of ways to place the players. Note though, that all the rooms are identical. But each of the cricketers and footballers are unique. \nSince the number of ways can be very large, print the answer modulo $998,244,353$.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first and only line of each test case contains three space-separated integers $p$, $q$ and $r$ denoting the number of footballers, cricketers and rooms.\n\n-----Output-----\nFor each test case, output the number of ways to place the players modulo $998,244,353$.\n\n-----Constraints-----\n- $1 \\le T \\le 100$\n- $1 \\le p, q, r \\le 100$\n\n-----Example Input-----\n4\n2 1 4\n2 4 4\n2 5 4\n2 8 4\n\n-----Example Output-----\n0\n3\n10\n609\n\n-----Explanation-----\nExample case 2: Three possible ways are:\n- {Footballer 1}, {Footballer 2}, {Cricketer 1, Cricketer 2}, {Cricketer 3, Cricketer 4}\n- {Footballer 1}, {Footballer 2}, {Cricketer 1, Cricketer 3}, {Cricketer 2, Cricketer 4}\n- {Footballer 1}, {Footballer 2}, {Cricketer 1, Cricketer 4}, {Cricketer 2, Cricketer 3}    \nPlease note that the rooms are identical.", "starter_code": "", "test_cases": {"inputs": ["4\n2 1 4\n2 4 4\n2 5 4\n2 8 4"], "outputs": ["0\n3\n10\n609"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "1edb83e2e97f81d9e7e2ae8c48eae29521bfe388", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00481", "original_id": null, "source": "apps", "domain": "code", "problem": "Nadaca is a country with N$N$ cities. These cities are numbered 1$1$ through N$N$ and connected by M$M$ bidirectional roads. Each city can be reached from every other city using these roads.\nInitially, Ryan is in city 1$1$. At each of the following K$K$ seconds, he may move from his current city to an adjacent city (a city connected by a road to his current city) or stay at his current city. Ryan also has Q$Q$ conditions (a1,b1),(a2,b2),…,(aQ,bQ)$(a_1, b_1), (a_2, b_2), \\ldots, (a_Q, b_Q)$ meaning that during this K$K$-second trip, for each valid i$i$, he wants to be in city ai$a_i$ after exactly bi$b_i$ seconds.\nSince you are very good with directions, Ryan asked you to tell him how many different trips he could make while satisfying all conditions. Compute this number modulo 109+7$10^9 + 7$. A trip is a sequence of Ryan's current cities after 1,2,…,K$1, 2, \\ldots, K$ seconds.\n\n-----Input-----\n- The first line of the input contains a single integer T$T$ denoting the number of test cases. The description of T$T$ test cases follows.\n- The first line of each test case contains three space-separated integers N$N$, M$M$ and K$K$.\n- Each of the next M$M$ lines contains two space-separated integers u$u$ and v$v$ denoting a road between cities u$u$ and v$v$.\n- The next line contains a single integer Q$Q$.\n- Q$Q$ lines follow. For each i$i$ (1≤i≤Q$1 \\le i \\le Q$), the i$i$-th of these lines contains two space-separated integers ai$a_i$ and bi$b_i$.\n\n-----Output-----\nFor each test case, print a single line containing one integer — the number of trips Ryan can make, modulo 109+7$10^9+7$.\n\n-----Constraints-----\n- 1≤T≤50$1 \\le T \\le 50$\n- 1≤N,M,K,Q≤9,000$1 \\le N, M, K, Q \\le 9,000$\n- 1≤ui,vi≤N$1 \\le u_i, v_i \\le N$ for each valid i$i$\n- ui≠vi$u_i \\neq v_i$ for each valid i$i$\n- there is at most one road between each pair of cities\n- each city is reachable from every other city\n- 1≤ai≤N$1 \\le a_i \\le N$ for each valid i$i$\n- 0≤bi≤K$0 \\le b_i \\le K$ for each valid i$i$\n- the sum of N$N$ over all test cases does not exceed 9,000$9,000$\n- the sum of K$K$ over all test cases does not exceed 9,000$9,000$\n- the sum of M$M$ over all test cases does not exceed 9,000$9,000$\n- the sum of Q$Q$ over all test cases does not exceed 9,000$9,000$\n\n-----Subtasks-----\nSubtask #1 (20 points):\n- the sum of N$N$ over all test cases does not exceed 400$400$\n- the sum of K$K$ over all test cases does not exceed 400$400$\n- the sum of M$M$ over all test cases does not exceed 400$400$\n- the sum of Q$Q$ over all test cases does not exceed 400$400$\nSubtask #2 (80 points): original constraints\n\n-----Example Input-----\n3\n4 3 3\n1 2\n1 3\n1 4\n0\n4 3 3\n1 2\n1 3\n1 4\n1\n2 2\n4 3 3\n1 2\n1 3\n1 4\n1\n2 1\n\n-----Example Output-----\n28\n4\n6", "starter_code": "", "test_cases": {"inputs": ["3\n4 3 3\n1 2\n1 3\n1 4\n0\n4 3 3\n1 2\n1 3\n1 4\n1\n2 2\n4 3 3\n1 2\n1 3\n1 4\n1\n2 1"], "outputs": ["28\n4\n6"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "32440e6f4883b4b95e613c359dd8634980e12a9f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00486", "original_id": null, "source": "apps", "domain": "code", "problem": "There is an event in DUCS where boys get a chance to show off their skills to impress girls. The boy who impresses the maximum number of girls will be honoured with the title “Charming Boy of the year”.\nThere are $N$ girls in the department. Each girl gives the name of a boy who impressed her the most. You need to find the name of a boy who will be honoured with the title. \nIf there are more than one possible winners, then the one with the lexicographically smallest name is given the title. \nIt is guaranteed that each boy participating in the event has a unique name.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows. \n- The first line of each test case contains an integer $N$ denoting the number of girls.\n- The second line contains $N$ space-separated strings $S_1, S_2, \\ldots, S_N$, denoting the respective names given by the girls.\n\n-----Output-----\nFor each test case, print a single line containing a string — the name of the boy who impressed the maximum number of girls. In case of a tie, print the lexicographically smallest name.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$\n- $1 \\leq N \\leq 10^5$\n- $1 \\leq |S_i| \\leq 10$, for each valid $i$\n$(|S_i|$ is the length of the string $S_i)$\n- For each valid $i$, $S_i$ contains only lowercase English alphabets\n- Sum of $N$ over all the test cases is $\\leq 10^6$\n\n-----Subtasks-----\n- 30 points: $1 \\leq N \\leq 100$\n- 70 points: original constraints\n\n-----Sample Input-----\n2\n\n10\n\njohn berry berry thomas thomas john john berry thomas john\n\n4\n\nramesh suresh suresh ramesh   \n\n-----Sample Output-----\njohn\n\nramesh", "starter_code": "", "test_cases": {"inputs": ["2\n10\njohn berry berry thomas thomas john john berry thomas john\n4\nramesh suresh suresh ramesh"], "outputs": ["john\nramesh"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "4338288df759f61a6b6f34622d189ca5b41e10d1", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00491", "original_id": null, "source": "apps", "domain": "code", "problem": "Congratulations !!! You have successfully completed the heist by looting all the gifts in Santa's locker. Now it's time to decide who gets to take all the gifts, you or the Grinch, there will be no splitting. So you and Grinch decide to play a game.\nTo start the game, an Integer N will be given. The game is played in turns and for each turn, the player can make any one of the following moves:\n- Divide N by any of it's odd divisors greater than 1.\n- Subtract 1 from N if N is greater than 1.\nDivisor of a number includes the number itself.\nThe player who is unable to make a move loses the game.\nSince you are the mastermind of the heist, you get to play the first move.\n\n-----Input-----\nThe first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases. The description of the test cases follows.\nThe only line of each test case contains a single integer — N (1 ≤ N ≤ 109).\n\n-----Output-----\nFor each test case, print \" Me\" if you win, and \" Grinch\" if otherwise (without quotes).\n\n-----Sample Input-----\n7\n1\n2\n3\n4\n5\n6\n12\n\n-----Sample Output-----\nGrinch\nMe\nMe\nGrinch\nMe\nGrinch\nMe", "starter_code": "", "test_cases": {"inputs": ["7\n1\n2\n3\n4\n5\n6\n12"], "outputs": ["Grinch\nMe\nMe\nGrinch\nMe\nGrinch\nMe"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8cc1527ee240db30ebb2550ff9e803e286781149", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00496", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a sequence $A_1, A_2, \\ldots, A_N$. For each valid $i$, the star value of the element $A_i$ is the number of valid indices $j < i$ such that $A_j$ is divisible by $A_i$.\nChef is a curious person, so he wants to know the maximum star value in the given sequence. Help him find it.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ which denotes the number of test cases.\n- The first line of each test case contains a single integer $N$ .\n- The second line of each test case contains $N$ space-separated integers $A_1, A_2, \\ldots, A_N$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the maximum star value.\n\n-----Constraints-----\n- $1 \\le T \\le 10$\n- $1 \\le N \\le 10^5$\n- $1 \\le A_i \\le 10^6$ for each valid $i$ \n- Sum of $N$ over all test cases does not exceed $100,000$.\n\n-----Subtasks-----\nSubtask #1 (20 points): sum  of $N$ over all test cases does not exceed $5,000$\nSubtask #2 (80 points): original constraints\n\n-----Example Input-----\n1\n7\n8 1 28 4 2 6 7\n\n-----Example Output-----\n3\n\n-----Explanation-----\n$A_5 = 2$ divides $4$, $28$ and $8$, so its star value is $3$. There is no element with a higher star value.", "starter_code": "", "test_cases": {"inputs": ["1\n7\n8 1 28 4 2 6 7"], "outputs": ["3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e74bacc69b2734e73f2728c3386d7bae8c9ed28f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00501", "original_id": null, "source": "apps", "domain": "code", "problem": "In Programmers Army Land, people have started preparation as sports day is scheduled next week.\nYou are given a task to form 1 team of $k$ consecutive players, from a list of sports player whose powers are given to you.\nYou want your team to win this championship, so you have to chose your $k$ team players optimally i.e. there must not be any other $k$ consecutive team players who have their total power greater than your team members total power.\n\n-----Input:-----\n- The first line of the input contains a single integer $T$. $T$ denoting the number of test cases. The description of $T$ test cases is as follows.\n- The next line of the input contains 2 space separated integers $N$ and $K$. $N$ denotes the total number of players and $K$ denotes the number of players allowed in a team.\n- The next line of the input contains $N$ space-separated integers $A1, A2, A3...An$ where $ith$ number denotes power of $ith$ player.\nNote: power of players can also be negative\n\n-----Output:-----\n- For each test-case print the total power that your selected team have(each test case output must be printed on a new line).\n\n-----Constraints:-----\n- $1 \\leq T \\leq 10^3$\n- $1 \\leq N,K \\leq 10^5$\n- $-10^7 \\leq A1, A2, A3...An \\leq 10^7$\n\n-----Sample Input:-----\n1\n5 3\n1 2 3 4 5\n\n-----Sample Output:-----\n12", "starter_code": "", "test_cases": {"inputs": ["1\n5 3\n1 2 3 4 5"], "outputs": ["12"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "7c8869d5526d752aba1bb7e30f0e6c9898e2ef70", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00506", "original_id": null, "source": "apps", "domain": "code", "problem": "This is a peculiar functioning setup.\nTwo Tanks are separated from each other by a wall .There is a pipe in the wall which connects  both tanks  which allows flow of water between them . Due to this ,there is change in temperature of both tanks , every minute temperature of Tank with larger temperature among two decreases by one and temperature of Tank  with smaller temperature among two increases by two until equilibrium is reached , But there is a problem .\nThe pipe can't control this flow of water if there is Non-equilibrium (inequality of temperature  on  both sides )  even after $m$ minutes and the pipe will burst after it , your task is to predict whether the pipe will burst or not .\nNote: If equilibrium cannot be reached the process will continue forever.\nThe initial temperature of Cold Tank is $Tc$ , of Hot Tank it is $Th$. \n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single line of input, three  integers $m, Tc,Th$. \n\n-----Output:-----\nFor each testcase, output in a single line answer \"Yes\" if Pipe will burst after m minutes \"No\" if pipe will not burst.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100000$\n- $1 \\leq m,Tc,Th \\leq 10^9$\n- $Tc \\leq Th $\n\n-----Sample Input:-----\n2\n4 5 10\n2 2 5\n\n-----Sample Output:-----\nYes\nNo", "starter_code": "", "test_cases": {"inputs": ["2\n4 5 10\n2 2 5"], "outputs": ["Yes\nNo"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "fa806eee0247e2dcce33c445222e980bd0121da6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00511", "original_id": null, "source": "apps", "domain": "code", "problem": "In 17th century our Chef was a Wizard. He asked his small son \"Anshu\" to bring him the secret of the Magical Mountain. The boy after travelling a lot reached the Mountain.\n\nThe description of the Mountain was as follows:\n- Mountain contains N magical stones. Each of them has a unique number.\n- Mountain was divided into many levels, where at ith level atmost 2^i stones can be found.\n- Between stones there exist a magical path containing lava.\n- A stone can be connected with maximum of three stones.\n- Peak of the mountain contains stone with number 1.\n- If Stone 1 is first connected to stone 2 and then to 3. Assume 2 is to the left of 3.\n\nNow, to get the secret of the mountain, Anshu started climbing from the left. On the way he used his magical wand to protect him from lava. But, while climbing he came to know that he is able to see only the one stone at each level. After reaching the peak he slided down and did the the same process. These stones that he saw shows the secret of the mountain, if they are placed in a non decreasing order on a sunny day. Anshu doesn't remember the stones number that he saw. Help him in recollecting them and getting the secret to his father.\n\nThe mountain looks like this\n\n-----Input-----\n- First line contains T the number of test cases.\n- First line of each test test case contains N.\n- Next N-1 lines contains X and Y the stones which are connected.\n\n-----Output-----\n- Output the required non decreasing sequence.\n\n-----Constraints and Subtasks-----\n- 1 <= T <= 10\n- 1 <= X, Y <= N\nSubtask 1: 20 points\n- 3<=N<=100\nSubtask 2: 30 points\n- 3<=N<=10000\nSubtask 3: 50 points\n- 3<=N<=100000\n\n-----Example-----\nInput:\n1\n5\n1 2\n1 3\n2 4\n2 5\n\nOutput:\n1 2 3 4 5", "starter_code": "", "test_cases": {"inputs": ["1\n5\n1 2\n1 3\n2 4\n2 5"], "outputs": ["1 2 3 4 5"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b3297da5b37db882ad5ee530f121631953a2f46e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00516", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef has a sequence of $N$ integers, $A_1, A_2, ... , A_N$. He likes this sequence if it contains a  subsequence of $M$ integers, $B_1, B_2, ... , B_M$ within it.\nA subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.\nYou will be given a sequence of $N$ integers, $A_1, A_2, ..., A_N$ followed by another sequence of $M$ integers, $B_1, B_2, ..., B_M$. Given these, you have to tell whether Chef likes the sequence of $N$ integers($A_1, A_2, ..., A_N$) or not. \nFormally, output \"Yes\" if\n$\\exists idx_1, idx_2, ..., idx_M | 1 \\le idx_1 < idx_2 < ... < idx_M \\le N$ and $A_{idx_i} = B_i \\forall i, 1 \\le i \\le M$\nOtherwise output \"No\". Note that the quotes are for clarity.\n\n-----Input-----\nThe first line contains a single integer, $T$.\n$T$ test cases follow where each test case contains four lines:\n- The first line of a test case contains a single integer $N$\n- The second line of the test case contains $N$ space separated integers, $A_1, A_2, ..., A_N$\n- The third line of the test case contains a single integer $M$.\n- The fourth line contains $M$ space separated integers, $B_1, B_2, ..., B_M$\nSymbols have usual meanings as described in the statement.\n\n-----Output-----\nFor each test case, output a single line containing the output. Output is \"Yes\" if Chef likes the sequence $A$. Output is \"No\" if Chef dislikes the sequence $A$.\n\n-----Constraints-----\n- $1 \\le T \\le 100$\n- $1 \\le N \\le 10^3$\n- $1 \\le M \\le 10^3$\n- $1 \\le A_i, B_i \\le 10^9$\n\n-----Sample Input-----\n3\n6\n1 2 3 4 5 6\n3\n2 3 4\n6\n22 5 6 33 1 4\n2\n4 15\n4\n1 3 4 2\n2\n1 2\n\n-----Sample Output-----\nYes\nNo\nYes\n\n-----Explanation:-----\nIn sample test case $1$, the sequence $1,2,3,4,5,6$ contains the subsequence $2, 3, 4$. The subsequence is present at indices $1, 2, 3$ of the original sequence.\nHence, $1,2,3,4,5,6$ is a sequence which Chef likes it. Therefore, we output \"Yes\".\nIn sample test case $2$, the subsequence $4, 15$ is not present in sequence $22, 5, 6, 33, 1, 4$. Hence, we output \"No\".\nIn sample test case $3$, the sequence $1, 3, 4, 2$ contains the subsequence $1, 2$. The subsequence is present at indices $0, 3$. Therefore, we output \"Yes\".", "starter_code": "", "test_cases": {"inputs": ["3\n6\n1 2 3 4 5 6\n3\n2 3 4\n6\n22 5 6 33 1 4\n2\n4 15\n4\n1 3 4 2\n2\n1 2"], "outputs": ["Yes\nNo\nYes"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "7c8f71f2167914eaafc5a6a04f206de761d1b808", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00521", "original_id": null, "source": "apps", "domain": "code", "problem": "-----Problem-----\n\nSuppose there is a circle. There are N Juice shops on that circle. Juice shops are numbered 0 to N-1 (both inclusive). You have two pieces of information corresponding to each of the juice shop:\n(1) the amount of Juice that a particular Juice shop can provide and \n(2) the distance from that juice shop to the next juice shop.\n\nInitially, there is a man with a bottle of infinite capacity carrying no juice. He can start the tour at any of the juice shops. Calculate the first point from where the man will be able to complete the circle. Consider that the man will stop at every Juice Shop. The man will move one kilometer for each litre of the juice.\n\n-----Input-----\n- \nThe first line will contain the value of N.\n\t\t\t\t\n- \nThe next N lines will contain a pair of integers each, i.e. the amount of juice that a juice shop can provide(in litres) and the distance between that juice shop and the next juice shop.\n\t\t\t\t\n\n-----Output-----\n\nAn integer which will be the smallest index of the juice shop from which he can start the tour.\n\t\t\n\n-----Constraints-----\n- \n\t\t\t\t\t1 ≤ N ≤ 105\n- \n\t\t\t\t\t1 ≤ amt of juice, distance  ≤ 109\n\n-----Sample Input-----\n3\n\n1 5\n\n10 3\n\n3 4\n\n-----Sample Output-----\n1\n\n-----Explanation-----\n\n\t\t\tHe can start the tour from the SECOND Juice shop.\n\t\t p { text-align:justify }", "starter_code": "", "test_cases": {"inputs": ["3\n1 5\n10 3\n3 4"], "outputs": ["1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "9abf5c9a552682213cfcb0f51ad9aa0dc55e67b5", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00526", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a matrix of integers $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$). Each element of this matrix is either $0$ or $1$.\nA move consists of the following steps:\n- Choose two different rows $r_1$ and $r_2$ or two different columns $c_1$ and $c_2$.\n- Apply the bitwise OR operation with the second row/column on the first row/column. Formally, if you chose two rows, this means you should change $A_{r_1, k}$ to $A_{r_1, k} \\lor A_{r_2, k}$ for each $1 \\le k \\le M$; if you chose two columns, then you should change $A_{k, c_1}$ to $A_{k, c_1} \\lor A_{k, c_2}$ for each $1 \\le k \\le N$.\nFor each element of the matrix, compute the minimum number of moves required to make it equal to $1$ or determine that it is impossible. Note that these answers are independent, i.e. we are starting with the initial matrix for each of them.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $M$.\n- $N$ lines follow. For each $i$ ($1 \\le i \\le N$), the $i$-th of these lines contains $M$ integers $A_{i, 1}, A_{i, 2}, \\dots, A_{i, M}$ NOT separated by spaces.\n\n-----Output-----\nFor each test case, print $N$ lines. For each valid $i$, the $i$-th of these lines should contain $M$ space-separated integers; for each valid $j$, the $j$-th of these integers should be the minimum number of moves required to make $A_{i, j}$ equal to $1$, or $-1$ if it is impossible.\n\n-----Constraints-----\n- $1 \\le T \\le 100$\n- $1 \\le N, M \\le 1,000$\n- $A_{i, j} \\in \\{0, 1\\}$ for each valid $i, j$\n- the sum of $N \\cdot M$ for all test cases does not exceed $1,000,000$\n\n-----Example Input-----\n1\n3 3\n010\n000\n001\n\n-----Example Output-----\n1 0 1\n2 1 1\n1 1 0", "starter_code": "", "test_cases": {"inputs": ["1\n3 3\n010\n000\n001"], "outputs": ["1 0 1\n2 1 1\n1 1 0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "5842855b7c22e95a678b9f4e1653a2dd36d815b6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00531", "original_id": null, "source": "apps", "domain": "code", "problem": "Harish has decided to go to Arya's hotel this morning. We all know he is crazy for masala dosas. And as usual he is always hungry. He decided to order all the masala dosas at once. But then he realised that he did not have enough money to buy all of them. So he decided to share the amount with his friend Ozil. But both of them are fans of even numbers. Both of them says they want to eat even number of dosas. Ozil is ready to put the share if and only if , he is sure that he can get even number of dosas. So given N number of dosas can you please help Harish to decide, if he will be able to get all the dosas at once from the hotel.\n\n-----Input-----\nThe first line of input contains an integer T which denotes the number of test files. Next T lines contains an integer N where N is the total number of dosas.\n\n-----Output-----\nPrint \"YES\" if both can get even number of dosas. If it is not possible print \"NO\".\n\n-----Constraints-----\n- 1 ≤ T ≤ 10^6\n- 1 ≤ N ≤ 10^18\n\n-----Subtasks-----\nSubtask #1 : (20 points)\n- 1 ≤ T ≤ 10\n- 1 ≤ N≤ 100\n\nSubtask 2 : (80 points) \n\n- 1 ≤ T ≤ 10^6\n- 1 ≤ N≤ 10^18\n\n-----Example-----\nInput:\n2 \n16 \n27\nOutput:\nYES\nNO", "starter_code": "", "test_cases": {"inputs": ["2\n16\n27"], "outputs": ["YES\nNO"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "339da98242b7763348f72cff44a2dad552fda127", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00536", "original_id": null, "source": "apps", "domain": "code", "problem": "There is a field with plants — a grid with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$); out of its $NM$ cells, $K$ cells contain plants, while the rest contain weeds. Two cells are adjacent if they have a common side.\nYou want to build fences in the field in such a way that the following conditions hold for each cell that contains a plant:\n- it is possible to move from this cell to each adjacent cell containing a plant without crossing any fences\n- it is impossible to move from this cell to any cell containing weeds or to leave the grid without crossing any fences\nThe fences can only be built between cells or on the boundary of the grid, i.e. on the sides of cells. The total length of the built fences is the number of pairs of side-adjacent cells such that there is a fence built on their common side plus the number of sides of cells on the boundary of the grid which have fences built on them. Find the minimum required total length of fences that need to be built.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains three space-separated integers $N$, $M$ and $K$.\n- $K$ lines follow. Each of these lines contains two space-separated integers $r$ and $c$ denoting that the cell in row $r$ and column $c$ contains a plant.\n\n-----Output-----\nFor each test case, print a single line containing one integer — the minimum required length of fences.\n\n-----Constraints-----\n- $1 \\le T \\le 10$\n- $1 \\le N, M \\le 10^9$\n- $1 \\le K \\le 10^5$\n- $1 \\le r \\le N$\n- $1 \\le c \\le M$\n- the cells containing plants are pairwise distinct\n\n-----Subtasks-----\nSubtask #1 (30 points): $1 \\le N, M \\le 1,000$\nSubtask #2 (70 points): original constraints\n\n-----Example Input-----\n2\n4 4 9\n1 4\n2 1 \n2 2\n2 3\n3 1\n3 3\n4 1\n4 2\n4 3\n4 4 1\n1 1\n\n-----Example Output-----\n20\n4\n\n-----Explanation-----\nExample case 1: The field looks like this ('x' denotes a cell containing a plant, '.' denotes a cell containing weeds):\n...x\nxxx.\nx.x.\nxxx.\n\nAn optimal solution is to build fences around the topmost plant (with length $4$), around the remaining eight plants (with length $12$) and around the hole between them (with length $4$). The total length is $4+12+4 = 20$.", "starter_code": "", "test_cases": {"inputs": ["2\n4 4 9\n1 4\n2 1\n2 2\n2 3\n3 1\n3 3\n4 1\n4 2\n4 3\n4 4 1\n1 1"], "outputs": ["20\n4"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "791bb4b898be197125be4725decc9cea9611b3f9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00541", "original_id": null, "source": "apps", "domain": "code", "problem": "The Government of Siruseri is no different from any other when it comes to being \"capital-centric\" in its policies. Recently the government decided to set up a nationwide fiber-optic network to take Siruseri into the digital age. And as usual, this decision was implemented in a capital centric manner --- from each city in the country, a fiber optic cable was laid to the capital! Thus, traffic between any two cities had to go through the capital.\nSoon, it became apparent that this was not quite a clever idea, since any breakdown at the capital resulted in the disconnection of services between other cities. So, in the second phase, the government plans to connect a few more pairs of cities directly by fiber-optic cables. The government has specified that this is to be done in such a way that the disruption of services at any one city will still leave the rest of the country connected.\nThe government has data on the cost of laying fiber optic cables between every pair of cities. You task is to compute the minimum cost of additional cabling required to ensure the requirement described above is met.\nFor example, if Siruseri has $4$ cities numbered $1,2,3$ and $4$ where $1$ is the capital and further suppose that the cost of laying cables between these cities are as given in the table below:\n\nNote that the government has already connected the capital with every other city. So, if we connect the cities $2$ and $3$ as well as $3$ and $4$, you can check that disruption of service at any one city will still leave the other cities connected. The cost of connecting these two pairs is $4 + 6 = 10$. The same effect could have been achieved by connecting $2$ and $3$ as well as $2$ and $4$, which would have cost $4 + 5 = 9$. You can check that this is the best you can do.\nYour task is to write a program that allows the government to determine the minimum cost it has to incur in laying additional cables to fulfil the requirement.\n\n-----Input:-----\n- The first line of the input contains a single integer $N$ indicating the number of cities in Siruseri. You may assume that the capital city is always numbered $1$. \n- This is followed by $N$ lines of input each containing $N$ integers. \n- The $j^{th}$ integer on line $i$ is the cost of connecting city $i$ with city $j$. The $j^{th}$ integer on line $i$ will be the same as the $i^{th}$ integer on line $j$ (since the links are bidirectional) and the $i^{th}$ entry on line $i$ will always be $0$ (there is no cost in connecting a city with itself).\n\n-----Output:-----\nA single integer indicating the minimum total cost of the links to be added to ensure that disruption of services at one city does not disconnect the rest of the cities.\n\n-----Constraints:-----\n- $1 \\leq N \\leq 2000$.\n- $0 \\leq$ costs given in the input $\\leq 100000$\n\n-----Sample Input-----\n4\n0 7 8 10\n7 0 4 5 \n8 4 0 6\n10 5 6 0\n\n-----Sample Output-----\n9", "starter_code": "", "test_cases": {"inputs": ["4\n0 7 8 10\n7 0 4 5\n8 4 0 6\n10 5 6 0"], "outputs": ["9"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b37760c214953e3c5e5cadb614454b81db816ffc", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00546", "original_id": null, "source": "apps", "domain": "code", "problem": "Saket loves to play with strings. One day , while he was having fun with Cyclic Permutations of available strings to him, he observed that despite being scarce in numbers Vowels were really clingy.Being clingy means for almost every given string, there was a Cyclic Permutation in which atleast two vowels were together.\nSo he decided to check this property for all the available strings to him. As the number of strings can be very large, help Saket determine whether the given string is clingy or not.\n\n-----Input:-----\nThe first line of the input contains a single integer T$T$ denoting the number of test cases. The description of T$T$ test cases follows.\nFirst line of every test case contains an integer N$N$ denoting the length of the string.\nSecond line contains a string S$S$ of length N$N$, consisting only of uppercase english alphabets.\n\n-----Output:-----\nFor each test case, print a single line containing \"Yes\" if any of the cyclic permutations of the string is clingy else print \"No\".\n\n-----Constraints-----\n- 1≤T≤1000$1 \\leq T \\leq 1000$\n- 1≤N≤1000$1 \\leq N \\leq 1000$\n- String S$S$ consists of only upper case english alphabets.\n\n-----Subtasks-----\n- 20 points : 1≤N≤5$1 \\leq N \\leq 5$\n- 80 points : Original$Original$ Constraints$Constraints$\n\n-----Sample Input:-----\n2\n5\nAUXFC\n6\nXBCDEF\n\n-----Sample Output:-----\nYes\n\nNo\n\n-----EXPLANATION:-----\nExample$Example$ case1:$ case 1: $ One of the cyclic permutation is the original string itself, which has \"A\" and \"U\" together.\nExample$Example$ case2:$ case 2: $     None of the cyclic permutation will have 2 vowels together.", "starter_code": "", "test_cases": {"inputs": ["2\n5\nAUXFC\n6\nXBCDEF"], "outputs": ["Yes\nNo"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "65ed0115515a03121bab2bd8855eeb1d097674fd", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00551", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef has just found a recipe book, where every dish consists of exactly four ingredients.\nHe is going to choose some two dishes and prepare them for dinner.\nOf course, he likes diversity and wants to know whether the two dishes are similar.\nTwo dishes are called similar if at least half of their ingredients are the same.\nIn other words, at least two of four ingredients of the first dish should also be present in the second dish.\nThe order of ingredients doesn't matter.\nYour task is to examine T pairs of dishes.\nFor each pair, check if the two dishes are similar and print \"similar\" or \"dissimilar\" accordingly.\n\n-----Input-----\nThe first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.\n\nThe first line of each test case contains four distinct strings, denoting ingredients needed for the first dish.\nEach ingredient is represented by a string of length between 2 and 10 inclusive, consisting of lowercase English letters.\n\nThe second line of each test case describes the second dish in the same format.\n\n-----Output-----\nFor each test case, output a single line containing the answer — \"similar\" if at least half of the ingredients are same, and \"dissimilar\" otherwise (without the quotes).\n\n-----Constraints-----\n- 1 ≤ T ≤ 200\n- The length of each string will be between 2 and 10 inclusive.\n\n-----Example-----\nInput:\n5\neggs sugar flour salt\nsugar eggs milk flour\naa ab ac ad\nac ad ae af\ncookies sugar grass lemon\nlemon meat chili wood\none two three four\none two three four\ngibberish jibberish lalalalala popopopopo\njibberisz gibberisz popopopopu lalalalalu\n\nOutput:\nsimilar\nsimilar\ndissimilar\nsimilar\ndissimilar\n\n-----Explanation-----\nTest case 1. The first dish consists of ingredients: eggs, sugar, flour, salt, while the second dish consists of: sugar, eggs, milk, flour. Three of four ingredients are present in both dishes (eggs, sugar, flour) so the two dishes are similar.\nTest case 2. This example shows that strings in the input don't necessarily represent real food.\nThe answer is again \"similar\", because two ingredients are present in both dishes (\"ac\" and \"ad\").\nTest case 3. The only common ingredient is lemon, so the answer is \"dissimilar\".\nRemember that at least two ingredients should be present in both dishes.", "starter_code": "", "test_cases": {"inputs": ["5\neggs sugar flour salt\nsugar eggs milk flour\naa ab ac ad\nac ad ae af\ncookies sugar grass lemon\nlemon meat chili wood\none two three four\none two three four\ngibberish jibberish lalalalala popopopopo\njibberisz gibberisz popopopopu lalalalalu"], "outputs": ["similar\nsimilar\ndissimilar\nsimilar\ndissimilar"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "91aa23da72f5addf9a41f656fe1b73abd0bd96c4", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00556", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given an array $a$ of length $n$. A subsequence of this array is valid, if it satisfies these two conditions:\n- There shouldn't be any two even numbers within a distance of $K$, both which have been chosen in the subsequence. i.e. there shouldn't be two indices $i, j$ such that $a_i$ and $a_j$ are even, $|i - j| \\leq K$ and $a_i$ and $a_j$ are in the subsequence. \n- Similarly, there shouldn't be any two odd numbers within a distance of $K$, both which have been chosen in the subsequence\nThe sum of a subsequence is the sum of all the numbers in it. Your task is find the maximum sum possible in a valid subsequence of the given array. Print this maximum sum.\n\n-----Input-----\n- The first line of the input contains an integer $T$ denoting the number of test cases. The description of the test cases follows.\n- The first line of each test case contains two space-separated integers $n, k$.\n- The second line of each test case contains $n$ space-separated integers denoting the array $a$.\n\n-----Output-----\nFor each test case, output an integer corresponding to the answer of the problem.\n\n-----Constraints-----\n- $1 \\le T \\le 10^5$\n- $1 \\le n \\leq 10^5$\n- $1 \\le k \\leq  n$\n- $1 \\le a_i \\leq 10^9$\n- Sum of $n$ over all the test cases doesn't exceed $10^6$\n\n-----Example Input-----\n3\n1 1\n3\n2 1\n2 2\n5 2\n1 2 3 4 6\n\n-----Example Output-----\n3\n2\n11\n\n-----Explanation:-----\nTestcase 2: Only one of the two 2s can be chosen. Hence the answer is 2.\nTestcase 3: The subsequence containing the second, third and fifth numbers is a valid subsequence, and its sum is 2+3+6 = 11. You can check that this is the maximum possible, and hence is the answer.", "starter_code": "", "test_cases": {"inputs": ["3\n1 1\n3\n2 1\n2 2\n5 2\n1 2 3 4 6"], "outputs": ["3\n2\n11"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "9c1c7bae01ca432e70d328505f81a236a5f59971", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00561", "original_id": null, "source": "apps", "domain": "code", "problem": "After six days, professor GukiZ decided to give more candies to his students. Like last time, he has $N$ students, numbered $1$ through $N$. Let's denote the number of candies GukiZ gave to the $i$-th student by $p_i$. As GukiZ has a lot of students, he does not remember all the exact numbers of candies he gave to the students. He only remembers the following properties of the sequence $p$:\n- The numbers of candies given to each of the first $K$ students ($p_1, p_2, \\dots, p_K$) are known exactly.\n- All elements of the sequence $p$ are distinct and positive.\n- GukiZ didn't give more than $x$ candies to any student (the maximum value in the sequence $p$ is not greater than $x$).\n- For each student $i$, there is at least one other student $j$ such that $|p_i - p_j| \\le D$.\n- The professor gave out the biggest possible total number of candies, i.e. $S = p_1 + p_2 + p_3 + \\ldots + p_N$ is maximum possible.\nGukiZ would like to know the total number of candies $S$ he had at the beginning. However, times change and after six days, the professor is really tired, so it is possible that there is no sequence $p$ which satisfies the constraints. Can you help GukiZ find the number of candies he gave out, or tell him that he must have made a mistake?\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains four space-separated integers $N$, $K$, $x$, $D$.\n- The second line contains $K$ distinct space-separated integers $p_1, p_2, \\dots, p_K$.\n\n-----Output-----\nFor each test case, print a single line containing one integer — the number of candies GukiZ had, or $-1$ if there is no valid sequence $p$.\n\n-----Constraints-----\n- $1 \\le T \\le 50$\n- $3 \\le N \\le 10^9$\n- $1 \\le K \\le \\mathrm{min}(N, 2 \\cdot 10^4)$ \n- $1 \\le x \\le 2 \\cdot 10^9$\n- $1 \\le D \\le 10^9$\n- $1 \\le p_i \\le x$ for each valid $i$\n- All values $p_i$ from input are distinct\n\n-----Subtasks-----\nSubtask #1 (15 points): $1 \\leq x, N, D \\leq 15$ \nSubtask #2 (35 points): $1 \\leq x, N, D \\leq 10^5$ \nSubtask #3 (50 points): original constraints\n\n-----Example Input-----\n2\n4 3 5 3\n2 1 5\n3 2 8 2\n3 8\n\n-----Example Output-----\n12\n-1\n\n-----Explanation-----\nExample case 1: There are four students. We know that the first student got $p_1 = 2$ candies, the second student got $p_2 = 1$ and the third got $p_3 = 5$ candies; we don't know the number of candies given to the last student. The maximum possible amount of candies given to some student is $x=5$. The best possible option is giving $p_4=4$ candies to the last student. Then, the fourth constraint (with $D=3$) is satisfied for all students. Only the pair of students $(2, 3)$ have numbers of candies that differ by more than $3$, but still, for each student, there are at least two other students with close enough numbers of candies.\nExample case 2: GukiZ made some mistake in distribution and there is no valid sequence $p$. The answer is $-1$.", "starter_code": "", "test_cases": {"inputs": ["2\n4 3 5 3\n2 1 5\n3 2 8 2\n3 8"], "outputs": ["12\n-1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "07211e55327c9ba7d022c6c540924888b9ec314e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00566", "original_id": null, "source": "apps", "domain": "code", "problem": "Naman owns a very famous Ice Cream parlour in Pune. He has a wide range of flavours with different pricing. \n\nEvery flavour costs ₹ X per gram and quantity of each flavour in the parlour is indefinite. Now, Naman has \n\nreceived an order for a party wherein he is asked to prepare each Ice Cream with N number of flavours. \n\nHe needs to prepare each Ice Cream of W grams and at the same time has to keep the cost minimum. \n\nCan you help him out?\n\nNote: If it is not possible to prepare such an Ice Cream, print “Not Possible”.\n\n-----Input:-----\n\nFirst line contains an integer T denoting the number of test cases.\n\nFirst line of every test case contains an integer N denoting the number of flavours.\n\nThe second line of every test case by N space separated integers denoting the cost per gram of each flavour. \n\nSecond line of every test case contains two space separated integers W and Y denoting the weight \n\nof Ice Cream in grams and the number of flavours to be used respectively. \n\n-----Output:-----\n\nFor each test case, print the total cost of the Ice Cream in a single line.\n\n-----Constraints:-----\n1 ≤ T ≤ 100\n1 ≤ N,W,Y ≤ 40000\n\n-----Example:-----Input:\n2\n5 \n4 6 8 1 10\n10 3\n2\n1 2\n1 2Output:\n\n18\n\nNot Possible\n\n-----Explanation:-----\n\nIn the first test case to achieve the minimum cost, the Ice Cream will consist of 8 grams \n\nof flavour costing ₹1, 1 gram of flavour costing ₹4 and 1 gram of flavour costing ₹6.\n\nIn the second test case it is not possible to make an ice-cream weighing 1 gram using 2 flavours.", "starter_code": "", "test_cases": {"inputs": ["2\n5\n4 6 8 1 10\n10 3\n2\n1 2\n1 2"], "outputs": ["18\nNot Possible"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b3b385104ed8b9429aa8dfb97b36ca3037437b05", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00571", "original_id": null, "source": "apps", "domain": "code", "problem": "Rani is teaching Raju maths via a game called N-Cube, which involves three sections involving N.\n\nRani gives Raju a number N, and Raju makes a list of Nth powers of integers in increasing order (1^N, 2^N, 3^N.. so on). This teaches him exponentiation. \nThen Raju performs the following subtraction game N times : Take all pairs of consecutive numbers in the list and take their difference. These differences then form the new list for the next iteration of the game. Eg, if N was 6, the list proceeds as [1, 64, 729, 4096 ... ] to [63, 685, 3367 ...], and so on 5 more times.\nAfter the subtraction game, Raju has to correctly tell Rani the Nth element of the list. This number is the value of the game. \nAfter practice Raju became an expert in the game. To challenge him more, Rani will give two numbers M (where M is a prime) and R instead of just a single number N, and the game must start from M^(R - 1) instead of N. Since the value of the game can now become large, Raju just have to tell the largest integer K such that M^K divides this number. Since even K can be large, output K modulo 1000000007 (109+7).\n\n-----Input-----\n\nFirst line will contain T, number of testcases. Then the testcases follow\nEach testcase contains of a single line of input, two integers M R\n\n-----Output-----\n\nFor each testcase, output in a single line answer given by Raju to Rani modulo 1000000007.\n\n-----Constraints-----\n\n1<=T<=1000\n\n2<=M<=109\n\n30 points : 1<=R<=10000\n\n70 points : 1<=R<=109\n\nM is a prime number\n\n\n-----Example-----\nInput:\n\n1\n\n2 2\n\nOutput:\n\n1", "starter_code": "", "test_cases": {"inputs": ["1\n2 2"], "outputs": ["1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "29d875c98accbc204f0b3554a3aaf1b5479e2385", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00576", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef is a very experienced and well-known cook. He has participated in many cooking competitions in the past — so many that he does not even remember them all.\nOne of these competitions lasted for a certain number of days. The first day of the competition was day $S$ of the week (i.e. Monday, Tuesday etc.) and the last day was day $E$ of the week. Chef remembers that the duration of the competition (the number of days between the first and last day, inclusive) was between $L$ days and $R$ days inclusive. Is it possible to uniquely determine the exact duration of the competition? If so, what is this duration?\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first and only line of each test case contains two space-separated strings $S$ and $E$, followed by a space and two space-separated integers $L$ and $R$.\n\n-----Output-----\nFor each test case, print a single line containing:\n- the string \"impossible\" if there is no duration consistent with all given information\n- the string \"many\" if there is more than one possible duration\n- one integer — the duration of the competition, if its duration is unique\n\n-----Constraints-----\n- $1 \\le T \\le 10,000$\n- $1 \\le L \\le R \\le 100$\n- $S$ is one of the strings \"saturday\", \"sunday\", \"monday\", \"tuesday\", \"wednesday\", \"thursday\" or \"friday\"\n- $E$ is one of the strings \"saturday\", \"sunday\", \"monday\", \"tuesday\", \"wednesday\", \"thursday\" or \"friday\"\n\n-----Subtasks-----\nSubtask #1 (100 points): original constraints\n\n-----Example Input-----\n3\nsaturday sunday 2 4\nmonday wednesday 1 20\nsaturday sunday 3 5\n\n-----Example Output-----\n2\nmany\nimpossible", "starter_code": "", "test_cases": {"inputs": ["3\nsaturday sunday 2 4\nmonday wednesday 1 20\nsaturday sunday 3 5"], "outputs": ["2\nmany\nimpossible"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "fe5d7639c2ccc5cdc45943aa071685a7bbdbcc3d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00581", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef likes to solve difficult tasks. This time, he tried to solve the Big Famous Unsolvable $A+B=C$. One of his friends played a prank on Chef and randomly shuffled the bits in $A$ and $B$ (independently in each number). However, the funny thing is that the sum of the resulting numbers remained $C$ even after shuffling.\nChef is now wondering: in how many ways is it possible to shuffle the bits of $A$ and the bits of $B$ such that their sum after shuffling is equal to $C$? Let's denote the integers obtained by shuffling the bits of $A$ and $B$ by $A_s$ and $B_s$ respectively; two ways $(A_{s1}, B_{s1})$ and $(A_{s2}, B_{s2})$ are considered distinct if $A_{s1} \\neq A_{s2}$ or $B_{s1} \\neq B_{s2}$.\nIt is allowed to add any number (possibly zero) of leading zeroes, i.e. bits $0$, to $A$ and any number of leading zeroes to $B$ before shuffling the bits.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first and only line of each test case contains three space-separated integers $A$, $B$ and $C$. \n\n-----Output-----\nFor each test case, print a single line containing one integer — the number of ways to shuffle the bits.\n\n-----Constraints-----\n- $1 \\le T \\le 1,000$\n- $1 \\le A, B, C \\le 10^9$\n- $A+B = C$\n\n-----Subtasks-----\nSubtask #1 (50 points): $1 \\le A, B, C \\le 10^5$\nSubtask #2 (50 points): original constraints\n\n-----Example Input-----\n2\n1 2 3\n369 428 797\n\n-----Example Output-----\n2\n56\n\n-----Explanation-----\nExample case 1: We can consider $A=01$ and $B=10$ in binary. Then, there are two possible ways: swapping the two bits of $A$ and the two bits of $B$ ($A_s=10$, $B_s=01$ in binary, $2$ and $1$ in decimal representation) or not shuffling any bits.", "starter_code": "", "test_cases": {"inputs": ["2\n1 2 3\n369 428 797"], "outputs": ["2\n56"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "437738dcf6a733b7578548ad77cd1dfd2d087811", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00586", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef is frustrated in this lockown. So to overcome this he plans to travel various mountains.\nHe is very strange so he sets some conditions for $each$ Type 2 query(mentioned below) (i.e. $1$ $i$) : \n- Let Chef has travelled till $ith$ mountain from left to right.\n- He does not like to travel the mountain with the height ,of which he has travelled till now. More formally, \nLet the height of peak on which he is standing is $a_{i}$ then he can only go to the peak of height $a_{j}$ \nwhich is greater than $a_{i}$ and nearest to $ith$ mountain such that there should be no other peak of same height $a_{j}$ till $a_{i}$(height of $ith$ mountain) .\n\n-----Input format:-----\n- \nThe first line contains an integer $T$ denoting the number of test cases.\n- \nThe second line of  consist of a integer $N$ and $Q$ .\n- \nThe third line contains $N$ not necessarily distinct positive integers $a_{0},a_{1}, . . .,a_{n-1}$ denoting the height of \n$N$ mountains.\n- \nThen next $Q$ lines follows where each line consisting of $either$ of $2$ types of queries:\nType 1:  $0$ $A$ $B$ i.e. $a_{A} = B$ (where height of $Ath$ mountain will be updated to $B$) \nType 2:  $1$ $A$ i.e. you have to answer $a_k$ which is greater than $a_{A}$ and nearest to $Ath$ mountain such that there should be no other peak of same height $a_{k}$ till $a_{A}$(height of $Ath$ mountain) .\n\n-----Output format:-----\n- For every query of Type 2 there should be an integer $a_{k}$ on next  line for the updated array , If no such $a_{k}$ exists then $a_{k}$= $-1$ , as query of type 1 will have no output . \n\n-----Constraints:-----\n- $1\\leq T \\leq 10^2$\n- $1 \\leq N,Q \\leq 10^4$\n- $0\\leq a_{i} \\leq 10^6$\n- $0\\leq B \\leq 10^6$\n- $0\\leq A \\leq N-1$\n\n-----Subtasks-----\n- \n1 Point :   \n$1 \\leq T,N,Q \\leq 10^2$ \n$0\\leq B,a_{i} \\leq 10^2$\n- \n99 Points : Orginal   Constraints\n\n-----Example:-----\n\n-----Input:-----\n1\n10 5\n1 3 5 4 5 6 7 8  4 5\n1 7\n1 3\n1 1\n0 2 7\n1 3\n\n-----Output:-----\n-1\n6\n5\n5", "starter_code": "", "test_cases": {"inputs": ["1\n10 5\n1 3 5 4 5 6 7 8  4 5\n1 7\n1 3\n1 1\n0 2 7\n1 3"], "outputs": ["-1\n6\n5\n5"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e86b08ae2ab9dae8b654cc0ed2313a5a0e6bb57d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00591", "original_id": null, "source": "apps", "domain": "code", "problem": "We all know Gru loves Agnes very much. One day Agnes asked Gru to answer some of her queries. She lined up $N$ minions in a straight line from $1$ to $N$. \nYou are given an array $A$ which contains the height of minions. Agnes will ask him several queries. In each query, Gru has to tell whether the bitwise AND of  $A[L \\ldots R]$ is EVEN or ODD. Since Gru is busy planning the biggest heist on Earth, he asks for your help.\n\n-----Input:-----\n- First line of the input contains an integer $T$ denoting the number of test cases.\nFor each test case:-\n- First line contains an integer $N$ denoting the number of elements.\n- Second line contains $N$ spaced integer representing array elements.\n- Third line contains $Q$ representing number of query.\n- Next $Q$ lines contains two integer $L$ and $R$ as defined above.\n\n-----Output:-----\nFor each query, output \"EVEN\" or \"ODD\" without quotes.\n\n-----Constraints-----\n- $1 \\leq T \\leq 10$\n- $1 \\leq N \\leq 10^5$\n- $1 \\leq A_i \\leq 10^5$\n- $1 \\leq Q \\leq 10^5$\n\n-----Sample Input:-----\n1\n5\n1 3 2 4 5\n3\n1 2 \n1 5\n3 4\n\n-----Sample Output:-----\nODD\nEVEN\nEVEN\n\n-----Explanation-----\n- For the first query, the bitwise AND of 1 and 3 is 1, which is Odd. Hence the first output is ODD.\n- For the third query, the bitwise AND of 2 and 4 is 0, which is Even. Hence the third output is EVEN.", "starter_code": "", "test_cases": {"inputs": ["1\n5\n1 3 2 4 5\n3\n1 2\n1 5\n3 4"], "outputs": ["ODD\nEVEN\nEVEN"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b6d1ff3206f65d115427a8690b3b194f4a34b6c8", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00596", "original_id": null, "source": "apps", "domain": "code", "problem": "Corruption is on the rise in the country of Freedonia, Gru's home. Gru wants to end this for good and for that he needs the help of his beloved minions.\nThis corruption network can be represented in the form of a tree having N$N$ nodes and N−1$N-1$ edges. The nodes are numbered from 1$1$ to N$N$, and the tree is rooted at node 1$1$. These nodes represent the corrupt officials and each corrupt official works under some other corrupt official except the Boss who is represented by node 1$1$.\nGru believes in divide and conquer and thinks that this network needs to be divided into as many sub-networks as possible.\nHe commands the minions to kill some of the corrupt officials in order to break the network into maximum sub-networks. But as you know, these corrupt officials are very sharp, and hence these assassinations need to be done very smartly and silently, without leaving any traces.  To achieve this Gru devises a strategy, in which he designs an operation, and that operation can be applied by the minions any number of times (even 0). \nIn one operation the minions can select any one leaf node official [that is an official who does not have any other official beneath him] in the graph and kill him along with all his ancestors$ancestors$ officials till the root$root$ of the tree in which the operation is applied (this is done to wipe all traces of the operation). This deleted all those nodes from the graph, and also, while doing so, all the associated edges/connections$edges/connections$ of the leaf node and its ancestors are also destroyed. Hence after applying this operation on any tree, it breaks into some connected components which are also trees, which are the new sub-networks.\nNow the minions are a bit lazy and will do the task someday, but they need to submit a report to Gru containing the number of the maximum$maximum$ connected$connected$ components$components$ that they could achieve by applying the operation any number of times. To do this, the minions require your help. So help the minions by finding out the maximum$maximum$ no.$no.$ of$of$ connected$connected$ components$components$ that can be achieved.\nNote: After each operation, the topmost node (node with the lowest level. It can be proved that there will always be a unique node with the lowest level in each tree) of each of the remaining trees becomes the root of that particular tree (that is, after the first operation it can be visualized that the graph converts into a forest of rooted trees)\n\n-----Input:-----\n- First line will contain N$N$, number of nodes in the tree. \n- Next N−1$N-1$ lines contains 2 integers U$U$, V$V$ denoting the endpoints of the ith$i^{th}$ edge.\n\n-----Output:-----\n- Print the maximum number of connected components you can obtain after doing the operation any number of times.\n\n-----Constraints-----\n- 1≤N≤106$1 \\leq N \\leq 10^6$\n- 1≤U,V≤N$1 \\leq U,V \\leq N$\n\n-----Sample Input:-----\n7\n1 2\n1 3\n2 4\n2 5\n3 6\n3 7\n\n-----Sample Output:-----\n2\n\n-----EXPLANATION:-----\nWe have 4 leaf nodes in this tree: 4 5 6 7. Suppose we delete node 5, then along with it we also delete node 2 and node 1. so after the deletion we are left with 2 trees, one consisting of only node 4 as the root node of that particular tree, and the other consisting of node 3,6,7 with node 3 as the root node. This can also be achieved by deleting any of the other leaf nodes and it can be proved that we cannot obtain more than 2 connected components in this example.", "starter_code": "", "test_cases": {"inputs": ["7\n1 2\n1 3\n2 4\n2 5\n3 6\n3 7"], "outputs": ["2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "36524105eed1124555c65be5bd8b8e3606a32ee6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00601", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef has a sequence $A_1, A_2, \\ldots, A_N$. This sequence has exactly $2^N$ subsequences. Chef considers a subsequence of $A$ interesting if its size is exactly $K$ and the sum of all its elements is minimum possible, i.e. there is no subsequence with size $K$ which has a smaller sum.\nHelp Chef find the number of interesting subsequences of the sequence $A$.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $K$.\n- The second line contains $N$ space-separated integers $A_1, A_2, \\ldots, A_N$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the number of interesting subsequences.\n\n-----Constraints-----\n- $1 \\le T \\le 10$\n- $1 \\le K \\le N \\le 50$\n- $1 \\le A_i \\le 100$ for each valid $i$\n\n-----Subtasks-----\nSubtask #1 (30 points): $1 \\le N \\le 20$\nSubtask #2 (70 points): original constraints\n\n-----Example Input-----\n1\n4 2\n1 2 3 4\n\n-----Example Output-----\n1\n\n-----Explanation-----\nExample case 1: There are six subsequences with length $2$: $(1, 2)$, $(1, 3)$, $(1, 4)$, $(2, 3)$, $(2, 4)$ and $(3, 4)$. The minimum sum is $3$ and the only subsequence with this sum is $(1, 2)$.", "starter_code": "", "test_cases": {"inputs": ["1\n4 2\n1 2 3 4"], "outputs": ["1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "1cba3411d1ff5408b84f30ccbcd1e336876f95d7", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00606", "original_id": null, "source": "apps", "domain": "code", "problem": "Dhiraj loves Chocolates.He loves chocolates so much that he can eat up to $1000$ chocolates a day. But his mom is fed up by this habit of him and decides to take things in her hand.\nIts diwali Season and Dhiraj has got a lot of boxes of chocolates and Dhiraj's mom is afraid that dhiraj might eat all boxes of chocolates.\nSo she told Dhiraj that he can eat only exactly $k$ number of chocolates and dhiraj has to finish all the chocolates in box selected by him and then move on to next box of chocolate.Now Dhiraj is confused that whether he will be able to eat $k$ number of chocolates or not. Since dhiraj is weak at maths,he asks for your help to tell him whether he can eat $k$ number of chocolates or not. \nSo given number of chocolates  are $k$ which dhiraj has to eat and the boxes of chocolates each containing some number of chocolates, tell whether dhiraj will be able to eat $k$ number of chocolates or not.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- $k$, representing the number of chocolates dhiraj has to eat.\n- the third line contains $N$ representing the no. of boxes of chocolates.\n- fourth line contains list of $a[]$ size $N$ specifying the number of chocolates in each Box.\n\n-----Output:-----\n- For each testcase, output in a single line answer $0$ or $1$.\n- $0$ if dhiraj cant eat $k$ chocolates from given combination and $1$ if he can eat $k$ chocolates from given combination.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$\n- $1 \\leq K \\leq 10^7$\n- $1 \\leq  N \\leq 800$\n- $1 \\leq a[i] \\leq 10^3$\n\n-----Sample Input:-----\n2\n20\n5\n8 7 2 10 5\n11\n4\n6 8 2 10\n\n-----Sample Output:-----\n1\n0", "starter_code": "", "test_cases": {"inputs": ["2\n20\n5\n8 7 2 10 5\n11\n4\n6 8 2 10"], "outputs": ["1\n0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "cf4488bdf55929dc02341924cc1c40ca6e6fbc27", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00611", "original_id": null, "source": "apps", "domain": "code", "problem": "-----Problem Statement-----\nHarry Potter has one biscuit and zero rupee in his pocket. He will perform the following operations exactly $K$ times in total, in the order he likes:\n- Hit his pocket, which magically increases the number of biscuits by one.\n- Exchange $A$ biscuits to $1$ rupee.\n- Exchange $1$ rupee to $B$ biscuits.\nFind the maximum possible number of biscuits in Harry's pocket after $K$ operations.\n\n-----Input-----\nInput is given in the following format:\nK A B\n\n-----Output-----\nPrint the maximum possible number of biscuits in Harry's pocket after $K$operations.\n\n-----Constraints-----\n- $1 \\leq K, A, B \\leq 10^9$\n- $K$, $A$ and  are integers.\n\n-----Sample Input-----\n4 2 6\n\n-----Sample Output-----\n7\n\n-----EXPLANATION-----\nThe number of biscuits in Harry's pocket after $K$ operations is maximized as follows:\n- Hit his pocket. Now he has $2$ biscuits and $0$ rupee.\n- Exchange $2$ biscuits to $1$ rupee in his pocket .Now he has $0$ biscuits and $1$ rupee.\n- Hit his pocket. Now he has $1$ biscuits and $1$ rupee.\n- Exchange $1$ rupee to $6$ biscuits. his pocket. Now he has $7$ biscuits and $0$ rupee.", "starter_code": "", "test_cases": {"inputs": ["4 2 6"], "outputs": ["7"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "fe2bf12b3a124db482ad52908b7198100bc2fb80", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00616", "original_id": null, "source": "apps", "domain": "code", "problem": "The new Formula 1 season is about to begin and Chef has got the chance to work with the Formula 1 technical team.  \nRecently, the pre-season testing ended and the technical team found out that their timing system for qualifying was a little bit buggy. So, they asked Chef to fix it before the season begins.  \nHis task is to write a program to find the starting lineup of the race by taking the timings of the drivers in qualifying.\n(If you don’t know the rules that make the starting grid in Formula 1, consider that the driver with the least time will start at the front). \nNote: \n- Two or more drivers can have the same name.  \n- Every driver will have a distinct time.  \n\n-----Input:-----\n- The first line of the input consists of a single integer $T$ denoting the number of test cases.  \n- First line of each test case consists of a single integer $N$ denoting the number of drivers to set a time.  \n- The following $2*N$ lines consists of the driver’s name $S$ in one line and its timing details  $X$ (in milliseconds) in the next line.  \n\n-----Output:-----\n- For each test case output the starting lineup of the race i.e., name of each driver in the order they will start the race. Print each name in a new line.  \n\n-----Constraints-----\n- 1 <= $T$ <= 10  \n- 1 <= $N$ <= 105 \n- 1 <= $|S|$ <= 20  \n- 1 <= $X$ <= 109 \n\n-----Subtasks-----\nSubtask #1 (20 points): \n- 1 <= $N$ <= 100  \nSubtask #2 (80 points): \n- Original Constraints  \n\n-----Sample Input:-----\n2\n\n3\n\nHamilton\n\n75000\n\nVettel\n\n76000\n\nBottas\n\n75500\n\n2\n\nLeclerc\n\n666666\n\nVerstappen\n\n666777  \n\n-----Sample Output:-----\nHamilton\n\nBottas\n\nVettel\n\nLeclerc\n\nVerstappen  \n\n-----EXPLANATION:-----\nThe drivers with the least time are ahead in the lineup.", "starter_code": "", "test_cases": {"inputs": ["2\n3\nHamilton\n75000\nVettel\n76000\nBottas\n75500\n2\nLeclerc\n666666\nVerstappen\n666777"], "outputs": ["Hamilton\nBottas\nVettel\nLeclerc\nVerstappen"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "5800bc46609469155b6bcea5135281aac7ab9cee", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00621", "original_id": null, "source": "apps", "domain": "code", "problem": "For Diwali, Chef arranges all $K$ laddus in a row in his sweet shop. Whenever a customer comes to buy laddus, chef follows a rule that each customer must buy all laddus on odd position. After the selection of the laddu, a new row is formed, and again out of these only laddus on odd position are selected. This continues until the chef left with the last laddu. Find out the position of that last laddu in the original row.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single line of input, one integer $K$. \n\n-----Output:-----\nFor each testcase, print the position of that laddu who is left, in the original row.\n\n-----Constraints-----\n- $1 \\leq T \\leq 10^5$\n- $1 \\leq K \\leq 10^5$\n\n-----Sample Input:-----\n3\n1\n5\n8\n\n-----Sample Output:-----\n1\n4\n8\n\n-----EXPLANATION:-----\nFor 1) Only one laddu which is last so print 1.\nFor 2) Customer 1: [1, 3, 5]\nNew row = [2, 4]\n\nCustomer 2: [2]\n\nLast laddu = 4", "starter_code": "", "test_cases": {"inputs": ["3\n1\n5\n8"], "outputs": ["1\n4\n8"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "04aecc299cb2a694b60895dec9fe47d0251adce5", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00626", "original_id": null, "source": "apps", "domain": "code", "problem": "The government has invited bids from contractors to run canteens at all railway stations. Contractors will be allowed to bid for the catering contract at more than one station. However, to avoid monopolistic price-fixing, the government has declared that no contractor may bid for a pair of neighbouring stations.\nThe railway network has exactly one route between any pair of stations. Each station is directly connected by a railway line to at most $50$ neighbouring stations.\nTo help contractors plan their bids, the government has provided data on the number of passengers who pass through each station each year. Contractors would like to bid for stations with a higher volume of passenger traffic to increase their turnover.\nFor instance, suppose the railway network is as follows, where the volume of passenger traffic is indicated by the side of each station.\n\nIn this network, the best option for the contractor is to bid for stations $1, 2, 5$ and $6$, for a total passenger volume of $90$.\nYour task is to choose a set of stations that the contractor should bid for so that the total volume of traffic across all the stations in the bid is maximized.\n\n-----Input:-----\nThe first line of the input contains one integer $N$ indicating the number of railways stations in the network. The stations are numbered $1,2,...,N$. This is followed by $N$ lines of input, lines $2, 3,..., N+1$, indicating the volume of traffic at each station. The volume of traffic at station $i, 1 \\leq i \\leq N$, is given by a single integer in line $i+1$. The next $N-1$ lines of input, lines $N+2, N+3, ..., 2N$, describe the railway network. Each of these lines contains two integers, denoting a pair of stations that are neighbours.\n\n-----Output:-----\nThe output should be a single integer, corresponding to the total volume of traffic across the set of stations in the optimal bid made by the contractor.\n\n-----Constraints:-----\n- $1 \\leq N \\leq 100000$. \n- Each railway station has at most $50$ neighbours.\n\n-----Sample Input-----\n6\n10\n20\n25\n40\n30\n30\n4 5\n1 3\n3 4\n2 3\n6 4\n\n-----Sample Output-----\n90", "starter_code": "", "test_cases": {"inputs": ["6\n10\n20\n25\n40\n30\n30\n4 5\n1 3\n3 4\n2 3\n6 4"], "outputs": ["90"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "fe28637e150969b8e29bbe574bce298ac599bebb", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00631", "original_id": null, "source": "apps", "domain": "code", "problem": "The entire network is under the inspection and direct control of the Decepticons. They have learned our language through the World Wide Web and can easily understand the messages which are being sent. Sam is trying to send the information to Autobots to locate “ALL SPARK” which is the only source of energy that can be used to create universe. He is bit cautious in sending the message. He is sending the messages in a form of special pattern of string that contains important message in form of substrings. But Decepticons have learnt to recognize the Data Mining and string comparison patterns. He is sending a big message in form of a string (say M) and let there are N smaller substrings. Decepticons have to find whether each of these N substrings is a sub-string of M. All strings consist of only alphanumeric characters.\n\n-----Input-----\nInput to the program consists of two line. The first line contains the string M (where size of M should be <=40). The next line contain a string S.\n\n-----Output-----\nOutput should consist of a line with a character 'Y'/'N' indicating whether the string S is a sub-string of String M or not.\n\n-----Example-----\nInput:\ntechtrishna online event\nonlin\nOutput:\nY", "starter_code": "", "test_cases": {"inputs": ["techtrishna online event\nonlin"], "outputs": ["Y"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "1bc88dc31595684394864c3118dee9e71ed947a5", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00636", "original_id": null, "source": "apps", "domain": "code", "problem": "Vanja and Miksi really like games. After playing one game for a long time, they decided to invent another game!\nIn this game, they have a sequence $A_1, A_2, \\dots, A_N$ and two numbers $Z_1$ and $Z_2$. The rules of the game are as follows:\n- The players take turns alternately, starting with Vanja.\n- There is an integer $S$; at the beginning, $S = 0$.\n- In each turn, the current player must choose an arbitrary element of $A$ and either add that number to $S$ or subtract it from $S$. Each element can be selected multiple times.\n- Afterwards, if $S = Z_1$ or $S = Z_2$, the current player (the player who made $S$ equal to $Z_1$ or $Z_2$) is the winner of the game.\n- If the game lasts for $10^{10}$ turns, Vanja and Miksi decide to declare it a tie.\nCan you help the boys determine the winner of the game? Please note that the game can end in a tie (if nobody can make $S = Z_1$ or $S = Z_2$ in the first $10^{10}$ moves).\nBoth players play optimally, i.e. if there is a move which guarantees the current player's victory regardless of the other player's moves, the current player will make such a move. If the current player cannot win and there is a move which guarantees that the game will end in a tie, the current player will make such a move.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains three space-separated integers $N$, $Z_1$ and $Z_2$.\n- The second line contains $N$ space-separated integers $A_1, A_2, \\dots, A_N$.\n\n-----Output-----\n- For each test case, print a single line containing one integer — the final result of the game:\n- $1$ if Vanja (the first player) has a winning strategy\n- $2$ if Miksi (the second player) has a winning strategy\n- $0$ if the game ends in a tie\n\n-----Constraints-----\n- $1 \\le T \\le 50$\n- $1 \\le N \\le 50$\n- $|Z_1|, |Z_2| \\le 10^9$\n- $|A_i| \\le 10^9$ for each valid $i$\n\n-----Subtasks-----\nSubtask #1 (25 points): $N = 2$\nSubtask #2 (75 points): original constraints\n\n-----Example Input-----\n3\n2 6 4\n-4 10\n1 1 -1\n2\n2 0 7\n3 4\n\n-----Example Output-----\n1\n0\n2\n\n-----Explanation-----\nExample case 1: The first player can choose the value $A_1 = -4$, subtract it from $S = 0$ and obtain $S = - (-4) = 4 = Z_2$. The winner is the first player.  \nExample case 2: It can be proven that neither player is able to reach $S = Z_1$ or $S = Z_2$. The result is a tie.", "starter_code": "", "test_cases": {"inputs": ["3\n2 6 4\n-4 10\n1 1 -1\n2\n2 0 7\n3 4"], "outputs": ["1\n0\n2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d5b4f60024ec6d6cde26f9ea7c4a2b9814f20d7f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00641", "original_id": null, "source": "apps", "domain": "code", "problem": "Tracy loves Donuts. She purchased a lots of Donuts for her birthday party. She learnt to calculate the area of the circle a few days back and she is fascinated to know the area of the donuts as well !! Help her finding the area of the Donuts…..\n\n-----Input:-----\n- First line will contain, number of testcases. Then the testcases follow. \n- Each testcase contains of a single line of input, where in you have to provide the RADIUS of the Donuts. \n\n-----Output:-----\nFor each testcase, output in a single line answer is the AREA of the Donut.\n\n-----Constraints-----\n1 <= Radius <= 20.\n\n-----Sample Input:-----\n2\n5 \n12\n\n-----Sample Output:-----\n78.5\n\n452.16", "starter_code": "", "test_cases": {"inputs": ["2\n5\n12"], "outputs": ["78.5\n452.16"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "9b46010e6465fb88aeb42d80cf668b577a2b9a50", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00646", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef is playing a game with his childhood friend. He gave his friend a list of N numbers named $a_1, a_2 ....  a_N$ (Note: All numbers are unique). Adjust the numbers in the following order:\n$(i)$ swap every alternate number with it's succeeding number (If N is odd, do not swap the last number i.e. $a_N$ ).\n$(ii)$ add %3 of every number to itself.\n$(iii)$ swap the ith number and the (N-i-1) th number.\nAfter this, Chef will give a number to his friend and he has to give the nearest greater and smaller number to it.\nIf there is no greater or lesser number, put -1.\nHelp his friend to find the two numbers.\n\n-----Input:-----\n- First-line will contain $T$, the number of test cases. Then the test cases follow. \n- Each test case contains a single line of input, an integers $N$. \n- Next line contains $N$ integers separated by a space. \n- Next line contains a number to be found, $M$. \n\n-----Output:-----\nFor each test case, output in a single line answer given the immediate smaller and greater number separated by a space.\n\n-----Constraints-----\n- $1 \\leq T \\leq 1000$\n- $3 \\leq N \\leq 10^5$\n- $1 \\leq N_i \\leq 10^9$\n- $1 \\leq M \\leq 10^9$\n\n-----Sample Input:-----\n1\n10\n5 15 1 66 55 32 40 22 34 11\n38\n\n-----Sample Output:-----\n35 41\n\n-----Explaination:-----\nStep 1: 15 5 66 1 32 55 22 40 11 34\nStep 2: 15 7 66 2 34 56 23 41 13 35\nStep 3: 35  13 41 23 56 34 2 66 7 15\n35 is the number lesser than 38 and 41 is the number greater than 38 in the given set of numbers.", "starter_code": "", "test_cases": {"inputs": ["1\n10\n5 15 1 66 55 32 40 22 34 11\n38"], "outputs": ["35 41"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f1349078ebf5b865807b5219c834f6cd2d94199f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00651", "original_id": null, "source": "apps", "domain": "code", "problem": "Zonal Computing Olympiad 2012, 26 Nov 2011\n\nIt's dinner time in Castle Camelot, and the fearsome Knights of the Round Table are clamouring for dessert. You, the chef, are in a soup.  There are N knights, including King Arthur, each with a different preference for dessert, but you cannot afford to make desserts for all of them.\n\nYou are given the cost of manufacturing each Knight's preferred dessert–since it is a round table, the list starts with the cost of King Arthur's dessert, and goes counter-clockwise.\n\nYou decide to pick the cheapest desserts to make, such that for every pair of adjacent Knights, at least one gets his dessert. This will ensure that the Knights do not protest.<p>A strange feature of the Knights is that they will not complain about not getting dessert unless they get support from both their neighbours.  So, you decide to pick the cheapest desserts to make, such that for every pair of adjacent Knights, at least one gets his dessert.</p>\n\nWhat is the minimum cost of tonight's dinner, given this condition?\n\nFor instance, suppose there are 5 Knights and their desserts cost 1, 2, 1, 2 and 2.  In this case, the minimum cost is 4, which you can achieve by feeding the first, third and fourth (or fifth) Knights.  \n\n-----Input format-----\nThere are 2 lines of input.  The first line contains a single integer N, the number of seats at the table. The next line contains N space separated integers, each being the cost of the dessert of a Knight, listed in counterclockwise order around the table, starting with King Arthur.\n\n-----Output format-----\nThe output should be a single line containing a single integer, the minimum possible cost for you, the chef.\n\n-----Testdata-----\nEach Knight's dessert costs strictly more than 0 and strictly less than 1000.  You may assume that 1 ≤ N ≤ 106.  In 30% of the test cases, 1 ≤ N ≤ 103.\n\n- Subtask 1 (30 marks)\n- Subtask 2 (70 marks)\n\n-----Sample Input-----\n5\n1 2 1 2 2\n\n-----Sample Output-----\n4", "starter_code": "", "test_cases": {"inputs": ["5\n1 2 1 2 2"], "outputs": ["4"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "6a56f122b1dbd442d68982b0cad2b7b0efe6088f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00656", "original_id": null, "source": "apps", "domain": "code", "problem": "Sereja have array A' that contain N integers. Now Sereja want to permute elements of the array, he want to use some permutation p, such that A[i] = A'[p[i]], where A - new array. \n\nLets function f(A,i) = S - A[i] - A[i +1] - ... - A[j], where j is the maximum possible index, such that A[i] + A[i + 1] + ... + A[j] <= S, if A[i] > S, f(A, i) = S.\n\nHelp Sereja to find such permutation p, such that (f(A, 1) + f(A, 2) + ... f(A, k))/k will be as low as possible. \n\n-----Input-----\n\nFirst line of input contain integer T - number of testcases. Next lines contain T testcases. First line of each testcase contain three integers N, k, S. Next line contain N integers - array A'.\n\n-----Output-----\n\nFor each testcase output N numbers in one line - permutation p. \n\n-----Constraints-----\n- 1 ≤ T ≤ 10\n- 1 ≤ N ≤ 2000\n- 1 ≤ k ≤ N\n- 1 ≤ A'[i] ≤ 10^4\n- 1 ≤ S ≤ 10^9\n\n-----Example-----\nInput:\n2\n3 2 4\n3 4 1\n4 4 1\n1 1 1 1\n\nOutput:\n2 1 3\n4 3 2 1\n\n\n-----Scoring-----\n\nSuppose Sum will be sum of yours (f(A, 1) + f(A, 2) + ... f(A, k))/k per each testcase.  \nLets B will be the smallest such sum. Your score will be equal to B/Sum. Lower scores will earn more points.\n\nWe have 20 official test files. You must correctly solve all test files to receive OK. During the contest, your overall score is the sum of the scores on the first 4 test files. After the contest, all solutions will be rescored by the sum of the scores on the rest 16 test files. Note, that public part of the tests may not contain some border cases.", "starter_code": "", "test_cases": {"inputs": ["2\n3 2 4\n3 4 1\n4 4 1\n1 1 1 1\n\n"], "outputs": ["2 1 3\n4 3 2 1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "140277f6bde8a3c14123c44a9199111320cc50d0", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00661", "original_id": null, "source": "apps", "domain": "code", "problem": "The annual snake festival is upon us, and all the snakes of the kingdom have gathered to participate in the procession. Chef has been tasked with reporting on the procession, and for this he decides to first keep track of all the snakes. When he sees a snake first, it'll be its Head, and hence he will mark a 'H'. The snakes are long, and when he sees the snake finally slither away, he'll mark a 'T' to denote its tail. In the time in between, when the snake is moving past him, or the time between one snake and the next snake, he marks with '.'s.\nBecause the snakes come in a procession, and one by one, a valid report would be something like \"..H..T...HTH....T.\", or \"...\", or \"HT\", whereas \"T...H..H.T\", \"H..T..H\", \"H..H..T..T\" would be invalid reports (See explanations at the bottom).\nFormally, a snake is represented by a 'H' followed by some (possibly zero) '.'s, and then a 'T'. A valid report is one such that it begins with a (possibly zero length) string of '.'s, and then some (possibly zero) snakes between which there can be some '.'s, and then finally ends with some (possibly zero) '.'s.\n\nChef had binged on the festival food and had been very drowsy. So his report might be invalid. You need to help him find out if his report is valid or not.\n\n-----Input-----\n- The first line contains a single integer, R, which denotes the number of reports to be checked. The description of each report follows after this.\n- The first line of each report contains a single integer, L, the length of that report.\n- The second line of each report contains a string of length L. The string contains only the characters '.', 'H', and 'T'.\n\n-----Output-----\n- For each report, output the string \"Valid\" or \"Invalid\" in a new line, depending on whether it was a valid report or not.\n\n-----Constraints-----\n- 1 ≤ R ≤ 500\n- 1 ≤ length of each report ≤ 500\n\n-----Example-----\nInput:\n6\n18\n..H..T...HTH....T.\n3\n...\n10\nH..H..T..T\n2\nHT\n11\n.T...H..H.T\n7\nH..T..H\n\nOutput:\nValid\nValid\nInvalid\nValid\nInvalid\nInvalid\n\n-----Explanation-----\n\"H..H..T..T\" is invalid because the second snake starts before the first snake ends, which is not allowed.\n\".T...H..H.T\" is invalid because it has a 'T' before a 'H'. A tail can come only after its head.\n\"H..T..H\" is invalid because the last 'H' does not have a corresponding 'T'.", "starter_code": "", "test_cases": {"inputs": ["6\n18\n..H..T...HTH....T.\n3\n...\n10\nH..H..T..T\n2\nHT\n11\n.T...H..H.T\n7\nH..T..H"], "outputs": ["Valid\nValid\nInvalid\nValid\nInvalid\nInvalid"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "33412c13a63ef0b283c00a29fb1d7bc374f2c023", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00666", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef was bored staying at home in the lockdown. He wanted to go out for a change. Chef and Chefu are fond of eating Cakes,so they decided to go the Cake shop where cakes of all possible price are available .\nThey decided to purchase cakes of equal price and each of them will pay for their cakes. Chef only has coins of denomination $N$ whereas Chefu has that of denomination $M$.\nSo they want your help to find out the minimum amount to be spent in order to purchase the cakes.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single line of input, two integers $N, M$. \n\n-----Output:-----\nFor each testcase, output in a single line answer the minimum amount to be spent in order to purchase the cake.\n\n-----Constraints-----\n- $1 \\leq T \\leq 1000$\n- $2 \\leq N,M \\leq 10^7$\n\n-----Sample Input:-----\n1\n2 3\n\n-----Sample Output:-----\n6", "starter_code": "", "test_cases": {"inputs": ["1\n2 3"], "outputs": ["6"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "9ccb00525f8881621889bc55ec13caf8eace2eaf", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00671", "original_id": null, "source": "apps", "domain": "code", "problem": "Like all minions Dave also like to eat bananas. So as to his obsession, he is eating banana, but this time in different way. There are N bananas in dish. Dave wants to eat all of them. He starts eating at speed 1 banana/second. He can increase or decrease speed of eating by one only. The condition is that he must end eating at speed 1 banana/second. So, your task is to find minimum time required to finish all bananas in a dish.\n\n-----Input-----\nFirst line contain number of test cases T. Next T lines contain one integer N. Where N is number of bananas in a dish.\n\n-----Output-----\nFor each test case print minimum time require to eat all N bananas.\n\n-----Constraints-----\n- 1 ≤ T ≤ 100\n- 1 ≤ N ≤ 105\n\n-----Example-----\nInput:\n2\n2\n4\n\nOutput:\n2\n3\n\n\n-----Explanation-----\nExample case 1.Dave will start to eat with rate of 1 banana/second. Then only one banana will remain. He will eat that banana in 1 second. Thus, Total time is 2 seconds.\nExample case 2.Dave starts with rate of 1 banana/second, and then increase it to 2 bananas/second and again decrease it to 1 banana/second. So total time is 3 seconds.", "starter_code": "", "test_cases": {"inputs": ["2\n2\n4"], "outputs": ["2\n3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "687c5355afa4a96a913de0d197ea7730cd42c4b9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00676", "original_id": null, "source": "apps", "domain": "code", "problem": "Consider the following $4 \\times 4$ pattern:\n1  2  4  7\n3  5  8 11\n6  9 12 14\n10 13 15 16\n\nYou are given an integer $N$. Print the $N \\times N$ pattern of the same kind (containing integers $1$ through $N^2$).\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first and only line of each test case contains a single integer $N$.\n\n-----Output-----\nFor each test case, print $N$ lines; each of them should contain $N$ space-separated integers.\n\n-----Constraints-----\n- $1 \\le T \\le 10$\n- $1 \\le N \\le 100$\n\n-----Subtasks-----\nSubtask #1 (100 points): Original constraints\n\n-----Example Input-----\n1\n4\n\n-----Example Output-----\n1 2 4 7\n3 5 8 11\n6 9 12 14\n10 13 15 16\n\n-----Explanation-----", "starter_code": "", "test_cases": {"inputs": ["1\n4"], "outputs": ["1 2 4 7\n3 5 8 11\n6 9 12 14\n10 13 15 16"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "abe40330eb08827197851993f7bda28fb86d7cd0", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00681", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef's daily routine is very simple. He starts his day with cooking food, then he eats the food and finally proceeds for sleeping thus ending his day. Chef carries a robot as his personal assistant whose job is to log the activities of Chef at various instants during the day. Today it recorded activities that Chef was doing at N different instants. These instances are recorded in chronological order (in increasing order of time). This log is provided to you in form of a string s of length N, consisting of characters 'C', 'E' and 'S'. If s[i] = 'C', then it means that at the i-th instant Chef was cooking, 'E' denoting he was eating and 'S' means he was sleeping.\nYou have to tell whether the record log made by the robot could possibly be correct or not. \n\n-----Input-----\nThe first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.\nThe only line of each test case contains string s.\n\n-----Output-----\nFor each test case, output a single line containing \"yes\" or \"no\" (without quotes) accordingly.\n\n-----Constraints-----\n- 1 ≤ T ≤ 20\n- 1 ≤ N ≤ 105\n\n-----Subtasks-----\n- Subtask #1 (40 points) : 1 ≤ N ≤ 100\n- Subtask #2 (60 points) : original constraints\n\n-----Example-----\nInput:\n5\nCES\nCS\nCCC\nSC\nECCC\n\nOutput:\nyes\nyes\nyes\nno\nno\n\n-----Explanation-----\nExample case 1. \"CES\" can correspond to a possible record of activities of Chef. He starts the day with cooking, then eating and then sleeping.\nExample case 2. \"CS\" can also correspond to a possible record of activities of Chef. He starts the day with cooking, then eating and then sleeping. Robot recorded his cooking and sleeping in order. He might not have recorded his eating activity.\nExample case 4. \"SC\" can not correspond to Chef's activities. Here it means that Chef slept first, then he cooked the food, which is impossible for Chef to do on some particular day.", "starter_code": "", "test_cases": {"inputs": ["5\nCES\nCS\nCCC\nSC\nECCC"], "outputs": ["yes\nyes\nyes\nno\nno"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "082281caa2d994e06629cba9acf7e2866b587e8e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00686", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given $N$ integers in an array: $A[1], A[2], \\ldots, A[N]$. You also have another integer $L$.\nConsider a sequence of indices ($i_1, i_2, \\ldots, i_k$). Note that a particular index can occur multiple times in the sequence, and there is no order in which these indices have to occur. ($i_1, i_2, \\ldots, i_k$) is a sequence of size $k$. It is said to be an $Interesting$ sequence, if $A[i_1] \\ge A[i_2] \\ge \\ldots \\ge A[i_k]$.\nThe $Cost$ of an Interesting sequence ($i_1, i_2, \\ldots, i_k$), is defined to be the minimum absolute difference between any two adjacent indices. In other words, the Cost is $min \\{ |i_2 - i_1|, |i_3 - i_2|, \\ldots, |i_k - i_{k-1}| \\}$.\nYour job is to consider the Costs of all the Interesting sequences of size $L$ associated with the given array, and output the maximum Cost. Note that you can show that there is always at least one Interesting sequence for the given constraints.\n\n-----Input-----\n- The first line contains a single integer, $T$, which is the number of testcases. The description of each testcase follows.\n- The first line of each testcase contains two space separated integers: $N$ and $L$.\n- The second line of each testcase contains $N$ space separated integers: $A[1], A[2], \\ldots, A[N]$.\n\n-----Output-----\n- For each testcase, output the answer in a new line.\n\n-----Constraints-----\n- $1 \\leq T \\leq 3$\n- $1 \\leq A[i] \\leq 10^9$\n- $2 \\leq L \\leq 10^9$\n\n-----Subtasks-----\n- Subtask 1: 7 points\n- It is guaranteed that $A[1] > A[2] > \\ldots > A[N]$\n- Note that the above condition implies that all elements are distinct.\n- $1 \\leq N \\leq 500$\n- Subtask 2: 7 points\n- It is guaranteed that $A[1] \\ge A[2] \\ge \\ldots \\ge A[N]$\n- $1 \\leq N \\leq 500$\n- Subtask 3: 14 points\n- It is guaranteed that all elements are distinct.\n- $1 \\leq N \\leq 500$\n- Subtask 4: 14 points\n- $1 \\leq N \\leq 500$\n- Subtask 5: 25 points\n- It is guaranteed that all elements are distinct.\n- $1 \\leq N \\leq 3000$\n- Subtask 6: 33 points\n- $1 \\leq N \\leq 3000$\n\n-----Sample Input-----\n1\n6 3\n2 4 1 12 3 5\n\n-----Sample Output-----\n3\n\n-----Explanation-----\nWe are looking for Interesting sequences of length 3. Some of them are:\n- (4, 2, 3): This is Interesting because $A[4] \\ge A[2] \\ge A[3]$. Its cost is $min \\{ |2-4|, |3-2|\\} = 1$.\n- (5, 1, 1): Cost is 0.\n- (2, 2, 2): Cost is 0.\n- (6, 1, 3): Cost is 2.\n- (6, 2, 5): Cost is 3.\nThere are other Interesting Sequences of length 3 as well. But if you list them all out, you'll see that the maximum Cost is 3. Hence the answer is 3.", "starter_code": "", "test_cases": {"inputs": ["1\n6 3\n2 4 1 12 3 5"], "outputs": ["3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8abbe69ebd315c63e778dd1b315811d59257de28", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00691", "original_id": null, "source": "apps", "domain": "code", "problem": "Fizza is a cute girl and she wants to be more beautiful.\nSo she approached a magician to increase her beauty magically. But the magician's \nglasses accidently got locked inside the locker and he forgot the password. Without\nglasses he can't help her. The password is hidden in N integers i.e. $a[1], a[2], ..... a[N]$ \nwritten on his magical stick.The password is the maximum number of moves Fizza can perform, for any position $i$ such that 1 < = $i$ < = $N$ and integer $X$ is present at $i$-th\nposition. In one move she can perform one of the following operations ->\n$(1)$  If ( $i$ + 1 < = $N$ ) she can go to position ($i$ + 1 ) if integer at ( $i$ + 1 )-th \nposition is equal to $X$.\n$(2)$ if ( $i$ + 2 < = $N$ ) she can go to position ($i$ + 2 ) if integer at ($i$ + 2)-th \nposition is equal to $X$.\nFizza is a bit worried about her beauty so she can't focus on the problem but she asked for \nyour help to find the password.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase consists of  two lines of input.\n- Input $N$.\n- Input $N$ integers . \n\n-----Output:-----\nFor each testcase, output in a single line Maximum number of moves.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$\n- $1 \\leq N \\leq 10^5$\n- $1 \\leq a[i] \\leq 2*10^5$\n\n-----Sample Input:-----\n3\n8\n6 3 6 4 5 4 3 6\n9\n5 5 4 5 2 1 3 4 2\n6\n1 2 3 4 5 6\n\n-----Sample Output:-----\n1\n2\n0\n\n-----EXPLANATION:-----\nIn the first case, integers at position 1 and 3 are the same and at alternate positions.\nIn the second case, integers at position 1, 2, 4 follow the conditions.", "starter_code": "", "test_cases": {"inputs": ["3\n8\n6 3 6 4 5 4 3 6\n9\n5 5 4 5 2 1 3 4 2\n6\n1 2 3 4 5 6"], "outputs": ["1\n2\n0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "c3e02a0f2380c1736fa112d2baad916e84a4b092", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00696", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a convex polygon $P$ with vertices $P_0, P_1, \\ldots, P_{n-1}$, each having integer coordinates. On each edge $P_{i} P_{(i+1) \\% n}$ of the polygon, choose a point $R_i$ uniformly at random. What is the expected area of the convex hull of these $n$ chosen points $R_0, R_1, \\ldots R_{n-1}$ ?\n\n-----Note-----\n- Consider the area of the convex hull as zero if it contains less than 3 vertices.\n- All the points $R_i$ are chosen independently of each other.\n- Your answer is considered correct if and only if its absolute or relative error doesn't exceed $10^{-6}$.\n\n-----Input-----\n- The first line contains $n$, the number of vertices in the convex polygon.\n- The next $n$ lines contain the coordinates of the vertices of the polygon in anti-clockwise order. \n\n-----Output-----\nFor each testcase, print the expected area of the convex hull of the $n$ randomly chosen points.\n\n-----Constraints-----\n- $3 \\leq n \\leq 10^5$\n- The absolute values of all the coordinates $\\leq 10^7$.\n- All the points in the input are distinct.\n- The described polygon $P$ is convex and the vertices of the polygon are given in anti-clockwise order. Also, no three vertices of the polygon are collinear.\n\n-----Example Input-----\n3\n0 0\n1 0\n0 1\n\n-----Example Output-----\n0.1250000000", "starter_code": "", "test_cases": {"inputs": ["3\n0 0\n1 0\n0 1"], "outputs": ["0.1250000000"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "bb576f3c6a4d48ca33efe8c4ee24ea42ded25791", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00701", "original_id": null, "source": "apps", "domain": "code", "problem": "There are N hills in a row numbered 1 through N from left to right. Each hill has a height; for each valid i, the height of the i-th hill is Hi. Chef is initially on the leftmost hill (hill number 1). He can make an arbitrary number of jumps (including zero) as long as the following conditions are satisfied:\n\n- Chef can only jump from each hill to the next hill, i.e. from the i-th hill, he can jump to the i+1-th hill (if it exists).\n- It's always possible to jump to a hill with the same height as the current hill.\n- It's possible to jump to a taller hill if it's higher than the current hill by no more than U.\n- It's possible to jump to a lower hill if it's lower than the current hill by no more than D.\n- Chef can use a parachute and jump to a lower hill regardless of its height (as long as it's lower than the current hill). This jump can only be performed at most once.\n\nChef would like to move as far right as possible. Determine the index of the rightmost hill Chef can reach.\n\n-----Input-----\n- The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.\n- The first line of each test case contains three space-separated integers N, U and D.\n- The second line contains N space-separated integers H1, H2, ..., HN.\n\n-----Output-----\nFor each test case, print a single line containing one integer — the index of the rightmost reachable hill.\n\n-----Constraints-----\n- 1 ≤ T ≤ 100\n- 1 ≤ N ≤ 100\n- 1 ≤ U, D ≤ 1,000,000\n- 1 ≤ Hi ≤ 1,000,000 for each valid i\n\n-----Subtasks-----\nSubtask #1 (100 points): original constraints\n\n-----Example-----\nInput:\n\n3\n5 3 2\n2 5 2 6 3\n5 2 3\n4 4 4 4 4\n5 2 7\n1 4 3 2 1\n\nOutput:\n\n3\n5\n1\n\n-----Explanation-----\nExample case 1: Chef can jump to second hill because it's higher by no more than U=3 than first hill, to jump to third hill Chef has to use parachute \nbecause it's lower than second hill by 3 which is more than D=2, Chef can't jump to fourth hill because it's higher than third hill by 4 which is more than U=3\nExample case 2: All hills are of the same height, so chef can reach the last hill with no problems.\nExample case 3: Chef can't jump to second hill because it's too high for him", "starter_code": "", "test_cases": {"inputs": ["3\n5 3 2\n2 5 2 6 3\n5 2 3\n4 4 4 4 4\n5 2 7\n1 4 3 2 1"], "outputs": ["3\n5\n1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "33108e37b95d8e3cab1709abdf342d9974ebb382", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00706", "original_id": null, "source": "apps", "domain": "code", "problem": "-----\nHALLOWEEN EVE\n-----\n\nIn some other world, today is Halloween Eve.There are N trees planted in Mr. Smith’s\ngarden. The height of the i-th tree (1≤i≤N) is h i meters.\nHe decides to choose K trees from these trees and decorate them with electric lights.\nTo make the scenery more beautiful, the heights of the decorated trees should be as\nclose to each other as possible.\n\n\t\n\nMore specifically, let the height of the tallest decorated tree be hmax meters, and the\nheight of the shortest decorated tree be hmin meters.\nThe smaller the value hmax−hmin is, the better. What is the minimum possible value of\nhmax−hmin?\n\n\t\t\n\t\t\n\n-----Constraints-----\n\n\t    2≤K< N ≤105 \n\n1≤hi≤109\n\nhi is an integer\n\t\n\n-----Input Format-----\n\nInput is given from Standard Input in the following format:\n\nN K \n\nh1 \n\nh2 \n\n: \n\nhN\n\n-----Output-----\n\nPrint the minimum possible value of hmax−hmin.\n\n\t\t\n\t\t\n\n-----Example Text Case-----\nInput:\n\n5 3\n10\n15\n11\n14\n12\n\nOutput:\n\n2\n\nExplanation\n\nIf we decorate the first, third and fifth trees, hmax=12,hmin=10 so hmax−hmin=2. This is\noptimal.\n\t\t\n\t\t", "starter_code": "", "test_cases": {"inputs": ["5 3\n10\n15\n11\n14\n12"], "outputs": ["2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "afa5d5d5b16806baea14e2be7f82936f24798313", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00711", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef recently graduated Computer Science in university, so he was looking for a job. He applied for several job offers, but he eventually settled for a software engineering job at ShareChat. Chef was very enthusiastic about his new job and the first mission assigned to him was to implement a message encoding feature to ensure the chat is private and secure.\nChef has a message, which is a string $S$ with length $N$ containing only lowercase English letters. It should be encoded in two steps as follows: \n- Swap the first and second character of the string $S$, then swap the 3rd and 4th character, then the 5th and 6th character and so on. If the length of $S$ is odd, the last character should not be swapped with any other.\n- Replace each occurrence of the letter 'a' in the message obtained after the first step by the letter 'z', each occurrence of 'b' by 'y', each occurrence of 'c' by 'x', etc, and each occurrence of 'z' in the message obtained after the first step by 'a'.\nThe string produced in the second step is the encoded message. Help Chef and find this message.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains a single integer $N$.\n- The second line contains the message string $S$.\n\n-----Output-----\nFor each test case, print a single line containing one string — the encoded message.\n\n-----Constraints-----\n- $1 \\le T \\le 1,000$\n- $1 \\le N \\le 100$\n- $|S| = N$\n- $S$ contains only lowercase English letters\n\n-----Example Input-----\n2\n9\nsharechat\n4\nchef\n\n-----Example Output-----\nshizxvzsg\nsxuv\n\n-----Explanation-----\nExample case 1: The original message is \"sharechat\". In the first step, we swap four pairs of letters (note that the last letter is not swapped), so it becomes \"hsraceaht\". In the second step, we replace the first letter ('h') by 's', the second letter ('s') by 'h', and so on, so the resulting encoded message is \"shizxvzsg\".", "starter_code": "", "test_cases": {"inputs": ["2\n9\nsharechat\n4\nchef"], "outputs": ["shizxvzsg\nsxuv"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "0fb1507f417d8ea12c413db795178cb4852a3de2", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00716", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array $A$ of size $N$ , count number of pairs of index $i,j$ such that $A_i$ is even, $A_j$ is odd and $i < j$\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases.   \n- The first line of each test case contains integer $N$.    \n- The second line of each test case contains $N$ space separated integers $A_i$. \n\n-----Output-----\nFor each test case, print a single line containing an integer denoting number of pairs.\n\n-----Constraints-----\n- $1 \\le T \\le 100$\n- $2 \\le N \\le 10^5$ \n- $1 \\le A_i \\le 10^9$\n- Sum of $N$ over all test cases doesn't exceed $10^6 $ \n\n-----Subtasks-----\nSubtask #1 (30 points):\n- $2 \\le N \\le 100$ \nSubtask #2 (70 points): original constraints\n\n-----Example Input-----\n2\n4\n1 2 1 3\n5\n5 4 1 2 3\n\n-----Example Output-----\n2\n3\n\n-----Explanation-----\nExample case 1:$(A_2,A_3)$ and $(A_2,A_4)$ . \nExample case 2:$(A_2,A_3)$ , $(A_2,A_5)$ and $(A_4,A_5)$  .", "starter_code": "", "test_cases": {"inputs": ["2\n4\n1 2 1 3\n5\n5 4 1 2 3"], "outputs": ["2\n3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "18c40090a0f53ce88e57d7d19f8a163ee3741545", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00721", "original_id": null, "source": "apps", "domain": "code", "problem": "The Chef once decided to prepare some nice dishes on his birthday. There are N items kept on his shelf linearly from position 1 to N. Taste of the i-th item is denoted by a integer Ai.\n\nHe wants to make Q dishes. A dish will be made using some ingredients in the continuous range AL, AL + 1, , , AR (1-base indexing). Quality of the dish will be determined by the ingredient with minimum taste.\n\nChef wants help of his assistant Rupsa to find out sum and product of qualities of the dishes. As product of the qualities of the dishes could be very large, print it modulo 109 + 7. Also, you are given an integer K and you are assured that for each dish, the size of continuous range of the ingredients (i.e. R - L + 1) will always lie between K and 2 * K, both inclusive.\n\nMethod of generation of Array A \n\nYou are given non-negative integer parameters a, b, c, d, e, f, r, s, t, m, A[1]\n\nfor x = 2 to N:\n\tif(t^x mod s  <= r)        // Here t^x signifies \"t to the power of x\"\n\t\tA[x] = (a*A[x-1]^2 + b*A[x-1] + c) mod m\n\telse\n\t\tA[x] = (d*A[x-1]^2 + e*A[x-1] + f) mod m\n\nMethod of generation of range of ingredients for Q dishes \n\nYou are given non-negative integer parameters L1, La, Lc, Lm, D1, Da, Dc, Dm\n\nfor i = 1 to Q:\n\tL1 = (La * L1 + Lc) mod Lm;\n\tD1 = (Da * D1 + Dc) mod Dm; \n\tL = L1 + 1;\n\tR = min(L + K - 1 + D1, N);\n\n-----Input-----\n- The first line contains three integers N, K and Q.\n- The second line contains the integers a, b, c, d, e, f, r, s, t, m, and A[1].\n- Then third line contains the integers L1, La, Lc, Lm, D1, Da, Dc, and Dm\n\n-----Output-----\nOutput two space separated integers:\n\n- The sum of qualities of the dishes.\n- The product of qualities of the dishes modulo 109+7.\n\n-----Constraints-----\n- 1 ≤ N, Q ≤ 107\n- 1 ≤ K ≤ N\n- 0 ≤ a, b, c, d, e, f, r, s, t, m, A[1] ≤ 109+7\n- 1 ≤ Lm ≤ N - K + 1\n- 1 ≤ Dm ≤ K + 1\n- 1 ≤ La, Lc ≤ Lm\n- 1 ≤ Da, Dc ≤ Dm\n- 1 ≤ L1 ≤ N\n- 1 ≤ D1 ≤ K\n\n-----Sub tasks-----\n- Subtask #1: 1 ≤ N, Q ≤ 1000 (10 points)\n- Subtask #2: 1 ≤ Q ≤ 104 (20 points)\n- Subtask #3: original constraints (70 points)\n\n-----Example-----\nInput:\n4 2 1\n1 1 1 1 1 1 1 1 1 100 1 \n1 1 1 3 1 1 1 2\n\nOutput:\n13 13\n\n-----Explanation-----\n- The array A comes out to be {1, 3, 13, 83} and the first dish has L = 3 and R = 4. The minimum in this range is 13, thus the sum and product both are 13 and hence the answer.\n\n-----Note-----\nMultiplier for C# and Java have been reduced to 1.5 instead of 2.", "starter_code": "", "test_cases": {"inputs": ["4 2 1\n1 1 1 1 1 1 1 1 1 100 1\n1 1 1 3 1 1 1 2"], "outputs": ["13 13"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d4d13db7d54cefe647915e75de491b976586afaf", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00726", "original_id": null, "source": "apps", "domain": "code", "problem": "The game of billiards involves two players knocking 3 balls around\non a green baize table. Well, there is more to it, but for our\npurposes this is sufficient.\nThe game consists of several rounds and in each round both players\nobtain a score, based on how well they played. Once all the rounds\nhave been played, the total score of each player is determined by\nadding up the scores in all the rounds and the player with the higher\ntotal score is declared the winner.\nThe Siruseri Sports Club organises an annual billiards game where\nthe top two players of Siruseri play against each other. The Manager\nof Siruseri Sports Club decided to add his own twist to the game by\nchanging the rules for determining the winner. In his version, at the\nend of each round, the cumulative score for each player is calculated, and the leader and her current lead are found. Once\nall the rounds are over the player who had the maximum lead at the\nend of any round in the game is declared the winner.\n\nConsider the following score sheet for a game with 5 rounds:\nRoundPlayer 1Player 2114082289134390110411210658890\n\nThe total scores of both players, the leader and the lead after\neach round for this game is given below:RoundPlayer 1Player 2LeaderLead114082Player 1582229216Player 1133319326Player 274431432Player 215519522Player 23\nNote that the above table contains the cumulative scores.\nThe winner of this game is Player 1 as he had the maximum lead (58\nat the end of round 1) during the game.\nYour task is to help the Manager find the winner and the winning\nlead. You may assume that the scores will be such that there will\nalways be a single winner.  That is, there are no ties.\nInput\nThe first line of the input will contain a single integer N (N\n≤ 10000) indicating the number of rounds in the game.  Lines\n2,3,...,N+1 describe the scores of the two players in the N rounds.\nLine i+1 contains two integer Si and Ti, the scores of the Player 1\nand 2 respectively, in round i.  You may assume that 1 ≤ Si ≤\n1000 and 1 ≤ Ti ≤ 1000.  \nOutput\nYour output must consist of a single line containing two integers\nW and L, where W is 1 or 2 and indicates the winner and L is the\nmaximum lead attained by the winner.\nExample\nInput:\n5\n140 82\n89 134\n90 110\n112 106\n88 90\n\nOutput:\n1 58", "starter_code": "", "test_cases": {"inputs": ["5\n140 82\n89 134\n90 110\n112 106\n88 90"], "outputs": ["1 58"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "087fd40847a290917bf76011aa7766cceb98d911", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00731", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef works in a similar way to a travelling salesman ― he always travels to new cities in order to sell his delicious dishes.\nToday, Chef is planning to visit $N$ cities (numbered $1$ through $N$). There is a direct way to travel between each pair of cities. Each city has a specific temperature; let's denote the temperature in the $i$-th city by $C_i$. Chef has a fixed temperature tolerance $D$ with the following meaning: for each pair of cities $a$ and $b$, he may travel from city $a$ directly to city $b$ only if $|C_a-C_b| \\le D$, otherwise he would catch a heavy flu because of the sudden change in temperature.\nChef starts from city $1$. Is he able to visit all $N$ cities in such a way that each city is visited exactly once?\nNotes:\n- Chef is not able to travel through a city without visiting it.\n- City $1$ is visited at the beginning.\n- It is not necessary to be able to travel directly to city $1$ from the last city Chef visits.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $D$.\n- The second line contains $N$ space-separated integers $C_1, C_2, \\ldots, C_N$.\n\n-----Output-----\nFor each test case, print a single line containing the string \"YES\" (without quotes) if Chef can visit all cities or \"NO\" (without quotes) if he cannot.\n\n-----Constraints-----\n- $1 \\le T \\le 1,000$\n- $2 \\le N \\le 10^5$\n- $0 \\le D \\le 10^9$\n- $0 \\le C_i \\le 10^9$ for each valid $i$\n- the sum of $N$ over all test cases does not exceed $10^6$\n\n-----Subtasks-----\nSubtask #1 (20 points):\n- $N \\le 1,000$\n- the sum of $N$ over all test cases does not exceed $10,000$\nSubtask #2 (80 points): original constraints\n\n-----Example Input-----\n2\n5 3\n3 2 1 4 5\n5 4\n10 1 3 2 9\n\n-----Example Output-----\nYES\nNO", "starter_code": "", "test_cases": {"inputs": ["2\n5 3\n3 2 1 4 5\n5 4\n10 1 3 2 9"], "outputs": ["YES\nNO"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2176aa9531367dc855c59a1d682b8ed54071ab52", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00736", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef is playing a game on a sequence of $N$ positive integers, say $A_1, A_2, ... A_N$ The game is played as follows.\n- If all the numbers are equal, the game ends.\n- Otherwise\n- Select two numbers which are unequal\n- Subtract the smaller number from the larger number\n- Replace the larger number with the result from above\nChef has already figured out that the game always terminates. He also knows, for a given sequence of integers, the game will always terminate on the same value, no matter how the game is played. Chef wants you to simulate the game for him and tell him if the game terminates on $1$.\nIn fact, there may be many such games. Given a sequence of integers Chef wants to know the number of sub-sequences of the given sequence, for which, playing the above game on the subsuquence will terminate on $1$. A sub-sequence can be obtained from the original sequence by deleting $0$ or more integers from the original sequence. See the explanation section for clarity.\n\n-----Input-----\n- The first line of the input contains an integer $T$, the number of test cases. Then follow the description of $T$ test cases. \n- The first line of each test case contains a single integer $N$, the length of the sequence. \n- The second line contains $N$ positive integers, each separated by a single space.\n\n-----Output-----\nFor each test case, output a single integer - the number of sub-sequences of the original sequence, such that, playing the game on the sub-sequence results in ending the game with all the values equal to $1$.\n\n-----Constraints-----\n- $1 \\le T \\le 100$ \n- $1 \\le N \\le 60$ \n- $1 \\le A_i \\le 10^4$ \n- All $A_i$ will be distinct.\n\n-----Sample Input-----\n3\n4\n2 3 5 7\n4\n3 4 8 16\n3\n6 10 15\n\n-----Sample Output-----\n11\n7\n1\n\n-----Explanation-----\nTest Case 1: The following $11$ sub-sequences are counted.\n- $\\{ 2, 3 \\}$\n- $\\{ 2, 5 \\}$\n- $\\{ 2, 7 \\}$\n- $\\{ 3, 5 \\}$\n- $\\{ 3, 7 \\}$\n- $\\{ 5, 7 \\}$\n- $\\{ 2, 3, 5 \\}$\n- $\\{ 2, 3, 7 \\}$\n- $\\{ 2, 5, 7 \\}$\n- $\\{ 3, 5, 7 \\}$\n- $\\{ 2, 3, 5, 7 \\}$\nTest Case 2: The following $7$ sub-sequences are counted.\n- $\\{ 3, 4 \\}$\n- $\\{ 3, 8 \\}$\n- $\\{ 3, 16 \\}$\n- $\\{ 3, 4, 8 \\}$\n- $\\{ 3, 4, 16 \\}$\n- $\\{ 3, 8, 16 \\}$\n- $\\{ 3, 4, 8, 16 \\}$\nTest Case 3: There are $8$ subsequences of $\\{ 6, 10, 15 \\}$\n- $\\{\\}$ => The game cannot be played on this sub-sequence\n- $\\{ 6 \\}$ => The game cannot be played on this sub-sequence\n- $\\{ 10 \\}$ => The game cannot be played on this sub-sequence\n- $\\{ 15 \\}$ => The game cannot be played on this sub-sequence\n- $\\{ 6, 10 \\}$ => The game cannot end at $\\{ 1, 1 \\}$\n- $\\{ 6, 15 \\}$ => The game cannot end at $\\{ 1, 1 \\}$\n- $\\{ 10, 15 \\}$ => The game cannot end at $\\{ 1, 1 \\}$\n- $\\{ 6, 10, 15 \\}$ => The game ends at $\\{ 1, 1, 1 \\}$. Hence this is the only sub-sequence that is counted in the result.", "starter_code": "", "test_cases": {"inputs": ["3\n4\n2 3 5 7\n4\n3 4 8 16\n3\n6 10 15"], "outputs": ["11\n7\n1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "3e8d937e1639e6cec415892955a276a314c8dd91", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00741", "original_id": null, "source": "apps", "domain": "code", "problem": "A number K$K$ is said to be magical if it can be represented as a power of 2 only.That is K$K$=2x$2^{x}$ for some natural number x$x$. \nGiven a string of digits S$S$ of length N$N$, Let P be a valid arrangement of S.\nBy valid arrangement we mean that it should not have any leading zeroes.\nFind the sum of all such distinct Pi's, which, when treated as a number is magical.\nTwo arrangements are said to be distinct, if there is atleast one index where they differ. \nAs the sum can be very large, print the sum modulo 109+7$10^{9}+7$.\n\n-----Input:-----\n-The first line of the input contains a single integer T$T$ denoting the number of test cases. \n-Only line of each test case contains a string S$S$ of length N$N$, consisting only of digits between 0 to 9.\n\n-----Output:-----\nFor each test case, print a single integer denoting the sum of all such magical Pi′s$Pi's$ modulo 109+7$10^{9}+7$.\nIf no such Pi$Pi$ exists print \"-1\".\n\n-----Constraints-----\n- 1≤T≤1000$1 \\leq T \\leq 1000$\n- 2≤N≤1000$2 \\leq N \\leq 1000$\n- String only consists of digits between 0 to 9, both inclusive.\n\n-----Subtasks-----\n- 10 points : 1≤N≤5$1 \\leq N \\leq 5$\n- 40 points : 1≤N≤100$1 \\leq N \\leq 100$\n- 50 points : Original Constraints\n\n-----Sample Input:-----\n2\n35566\n\n31\n\n-----Sample Output:-----\n65536\n\n-1\n\n-----EXPLANATION:-----\nOnly arrangement is 65536.\nNo arrangement of 31 gives us a power of two.", "starter_code": "", "test_cases": {"inputs": ["2\n35566\n31"], "outputs": ["65536\n-1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "489c1f91eea51007a718aa18e67764b4bb903115", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00746", "original_id": null, "source": "apps", "domain": "code", "problem": "Vanja and Miksi have already finished everything for this year at their university, so they decided to spend their free time playing a game with a binary sequence $A_1, A_2, \\dots, A_N$ (i.e. a sequence containing only integers $0$ and $1$).\nAt the beginning of the game, Vanja and Miksi write down the expression $* A_1 * A_2 * A_3 * \\ldots * A_N$ (note below that each $*$ is a placeholder and does not denote multiplication).\nThe players take turns alternately, starting with Vanja. The game lasts $N$ turns. In each turn, the current player must replace the first (leftmost) remaining $*$ by the sign $+$ or $-$ (or, equivalently, by the operation of addition or subtraction).\nAfter the last turn, the boys calculate the resulting value $V$ of the expression. If $|V| \\ge K$, the winner is Vanja; otherwise, the winner is Miksi.\nPlease predict the winner of the game if both players play optimally. \n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $K$.\n- The second line contains $N$ space-separated integers $A_1, A_2, \\dots, A_N$.\n\n-----Output-----\nFor each test case, print a single line containing one integer — $1$ if Vanja (the first player) is the winner or $2$ if Miksi (the second player) is the winner.\n\n-----Constraints-----\n- $1 \\le T \\le 50$\n- $1 \\le N \\le 3 \\cdot 10^4$\n- $0 \\le K \\le 3 \\cdot 10^4$\n- $0 \\le A_i \\le 1$ for each valid $i$\n\n-----Example Input-----\n2\n2 1\n1 0\n3 5\n0 1 0\n\n-----Example Output-----\n1\n2\n\n-----Explanation-----\nExample case 1: $K = 1$, so if Vanja replaces the first $*$ by $+$, the value of the final expression will be $V = 1$; then, $K \\le |V|$, so the winner is Vanja.\nExample case 2: $K = 5$, but the absolute value of the final expression cannot be greater than $1$. The winner is Miksi.", "starter_code": "", "test_cases": {"inputs": ["2\n2 1\n1 0\n3 5\n0 1 0"], "outputs": ["1\n2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "993a05e9a57e30c08c15c95fc0e291ee4522768d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00751", "original_id": null, "source": "apps", "domain": "code", "problem": "This is probably the simplest problem ever. You just need to count the number of ordered triples of different numbers (X1, X2, X3), where Xi could be any positive integer from 1 to Ni, inclusive (i = 1, 2, 3).\nNo, wait. I forgot to mention that numbers N1, N2, N3 could be up to 1018. Well, in any case it is still quite simple :)\nBy the way, because of this the answer could be quite large. Hence you should output it modulo 109 + 7. That is you need to find the remainder of the division of the number of required triples by 109 + 7.\n\n-----Input-----\nThe first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows. The only line of each test case contains three space-separated integers N1, N2, N3.\n\n-----Output-----\nFor each test case, output a single line containing the number of required triples modulo 109 + 7.\n\n-----Constraints-----\n- 1 ≤ T ≤ 1000\n- 1 ≤ Ni ≤ 1018\n\n-----Example-----\nInput:\n5\n3 3 3\n2 4 2\n1 2 3\n25 12 2012\n1 1 2013\n\nOutput:\n6\n4\n1\n578880\n0\n\n-----Explanation-----\nExample case 1. We have the following triples composed of different numbers up to 3:\n(1, 2, 3)\n(1, 3, 2)\n(2, 1, 3)\n(2, 3, 1)\n(3, 1, 2)\n(3, 2, 1)\nExample case 2. Here the triples are:\n(1, 3, 2)\n(1, 4, 2)\n(2, 3, 1)\n(2, 4, 1)\nExample case 3. Here the only triple is (1, 2, 3).\nExample case 4. Merry Christmas! \nExample case 5. ... and Happy New Year! By the way here the answer is zero since the only choice for X1 and for is X2 is 1, so any such triple will have equal numbers.", "starter_code": "", "test_cases": {"inputs": ["5\n3 3 3\n2 4 2\n1 2 3\n25 12 2012\n1 1 2013"], "outputs": ["6\n4\n1\n578880\n0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "c42fc71a08d018a9ea468b08acb60ab9c13229d9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00756", "original_id": null, "source": "apps", "domain": "code", "problem": "Mathison and Chef are playing a new teleportation game. This game is played on a $R \\times C$ board where each cell $(i, j)$ contains some value $V_{i, j}$. The purpose of this game is to collect a number of values by teleporting from one cell to another. A teleportation can be performed using a tel-pair.\nA player is given $N$ tel-pairs. Each tel-pair can be used at most once and a player can use them in any order they like. Suppose a player is at cell $(a, b)$ and the tel-pair is $(dx, dy)$. Then, the player can reach in one teleportation any cell $(c, d)$ from $(a, b)$ such that $|a − c| = dx$ and $|b − d| = dy$.\nIt is Mathison’s turn next in the game to make a sequence of moves. He would like to know what is the highest value of a path of length at most $N+1$ that starts in $(Sx, Sy)$ and uses some (possibly none) of the tel-pairs given. The length of a path is equal to the number of cells in the path. The value of a path is equal to the sum of $V_{i, j}$ over all cells in the path.\n\n-----Input-----\n- The first line contains a single integer, $T$, the number of tests.\n- Each test starts with three integers, $R$, $C$, and $N$, representing the number of rows, columns, and tel-pairs.\n- The next line contains two integers, $Sx$, and $Sy$, representing the coordinates of the starting cell.\n- The next two lines will contain the description of the tel-pairs, each containing $N$ space separated integers. The first will contain the $x$-component of each tel-pair, the second one will contain the y-component of each tel-pair.\n- Finally, there will be $R$ lines, each containing $C$ space-separated integers, the description of the board.\n\n-----Output-----\nThe output file will contain $T$ lines. Each line will contain the answer (i.e. the highest value of a path) to the corresponding test.\n\n-----Constraints and notes-----\n- $1 \\leq T \\leq 100$\n- $1 \\leq R, C \\leq 1000$\n- $1 \\leq N \\leq 9$\n- $0 \\leq Sx < R$\n- $0 \\leq Sy < C$\n- $0 \\leq dx \\leq R$\n- $0 \\leq dy \\leq C$\n- $1 \\leq V_{i, j} \\leq 10^6$\n- You are allowed to visit a cell multiple times in a path, and the value for the cell must be added each time you visit it. \n\n-----Subtaks-----\nSubtask #1 (15 points):\n- $1 \\leq T \\leq 100$\n- $1 \\leq R, C \\leq 10$\n- $1 \\leq N \\leq 4$\nSubtask #2 (25 points):\n- $1 \\leq T \\leq 25$\n- $1 \\leq R, C \\leq 100$\n- $1 \\leq N \\leq 8$\nSubtask #3 (30 points):\n- $1 \\leq T \\leq 5$\n- $1 \\leq R, C \\leq 1000$\n- $1 \\leq N \\leq 8$\nSubtask #4 (30 points):\n- $1 \\leq T \\leq 5$\n- $1 \\leq R, C \\leq 1000$\n- $1 \\leq N \\leq 9$\n\n-----Example Input-----\n3\n5 5 2\n2 2\n1 2\n2 1\n10 11 62 14 15\n57 23 34 75 21\n17 12 14 11 53\n84 61 24 85 22\n43 89 14 15 43\n3 3 2\n0 0\n1 1\n1 1\n9 8 7\n5 6 4\n1 3 2\n2 2 1\n1 1\n2\n2\n5 6\n8 3\n\n-----Example Output-----\n188\n24\n3\n\n-----Explanation-----\nTest Case 1:\nMathison starts at $(2, 2)$.\nMathison has two tel-pairs $(2, 1)$ and $(1, 2)$.\nThe following path (i.e. bolded numbers) generates the maximum value: $(2, 2)$ → $(4, 1)$ → $(3, 3)$\nTest Case 2:\nMathison starts at $(0, 0)$.\nMathison has two tel-pairs $(1, 1)$ and $(1, 1)$.\nThe following path (i.e. bolded numbers) generates the maximum value: $(0, 0)$ → $(1, 1)$ → $(0, 0)$\nTest Case 3:\nMathison starts at $(1, 1)$.\nMathison has one tel-pair, $(2, 2)$.\nHe can't use the tel-pair so the answer is $3$ (the value of the starting cell).", "starter_code": "", "test_cases": {"inputs": ["3\n5 5 2\n2 2\n1 2\n2 1\n10 11 62 14 15\n57 23 34 75 21\n17 12 14 11 53\n84 61 24 85 22\n43 89 14 15 43\n3 3 2\n0 0\n1 1\n1 1\n9 8 7\n5 6 4\n1 3 2\n2 2 1\n1 1\n2\n2\n5 6\n8 3"], "outputs": ["188\n24\n3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "1a1a7a7ba3c6d2ed68050821f0eb4028c68b398a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00761", "original_id": null, "source": "apps", "domain": "code", "problem": "A string with length $L$ is called rich if $L \\ge 3$ and there is a character which occurs in this string strictly more than $L/2$ times.\nYou are given a string $S$ and you should answer $Q$ queries on this string. In each query, you are given a substring $S_L, S_{L+1}, \\ldots, S_R$. Consider all substrings of this substring. You have to determine whether at least one of them is rich.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $Q$.\n- The second line contains a single string $S$ with length $N$.\n- Each of the next $Q$ lines contains two space-separated integers $L$ and $R$ describing a query.\n\n-----Output-----\nFor each query, print a single line containing the string \"YES\" if the given substring contains a rich substring or \"NO\" if it does not contain any rich substring.\n\n-----Constraints-----\n- $1 \\le T \\le 10$\n- $1 \\le N, Q \\le 10^5$\n- $1 \\le L \\le R \\le N$\n- $S$ contains only lowercase English letters\n\n-----Example Input-----\n1\n10 2\nhelloworld\n1 3\n1 10\n\n-----Example Output-----\nNO\nYES", "starter_code": "", "test_cases": {"inputs": ["1\n10 2\nhelloworld\n1 3\n1 10"], "outputs": ["NO\nYES"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "cb584c62650890aac70dae12d6c7fc2b086b6993", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00766", "original_id": null, "source": "apps", "domain": "code", "problem": "Bears love candies and games involving eating them. Limak and Bob play the following game. Limak eats 1 candy, then Bob eats 2 candies, then Limak eats 3 candies, then Bob eats 4 candies, and so on. Once someone can't eat what he is supposed to eat, he loses.\nLimak can eat at most A candies in total (otherwise he would become sick), while Bob can eat at most B candies in total.\nWho will win the game?\nPrint \"Limak\" or \"Bob\" accordingly.\n\n-----Input-----\nThe first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.\nThe only line of each test case contains two integers A and B denoting the maximum possible number of candies Limak can eat and the maximum possible number of candies Bob can eat respectively.\n\n-----Output-----\nFor each test case, output a single line containing one string — the name of the winner (\"Limak\" or \"Bob\" without the quotes).\n\n-----Constraints-----\n- 1 ≤ T ≤ 1000\n- 1 ≤ A, B ≤ 1000\n\n-----Example-----\nInput:\n10\n3 2\n4 2\n1 1\n1 2\n1 3\n9 3\n9 11\n9 12\n9 1000\n8 11\n\nOutput:\nBob\nLimak\nLimak\nBob\nBob\nLimak\nLimak\nBob\nBob\nBob\n\n-----Explanation-----\nTest case 1. We have A = 3 and B = 2. Limak eats 1 candy first, and then Bob eats 2 candies. Then Limak is supposed to eat 3 candies but that would mean 1 + 3 = 4 candies in total. It's impossible because he can eat at most A candies, so he loses. Bob wins, and so we print \"Bob\".\nTest case 2. Now we have A = 4 and B = 2. Limak eats 1 candy first, and then Bob eats 2 candies, then Limak eats 3 candies (he has 1 + 3 = 4 candies in total, which is allowed because it doesn't exceed A). Now Bob should eat 4 candies but he can't eat even a single one (he already ate 2 candies). Bob loses and Limak is the winner.\nTest case 8. We have A = 9 and B = 12. The game looks as follows:\n- Limak eats 1 candy.\n- Bob eats 2 candies.\n- Limak eats 3 candies (4 in total).\n- Bob eats 4 candies (6 in total).\n- Limak eats 5 candies (9 in total).\n- Bob eats 6 candies (12 in total).\n- Limak is supposed to eat 7 candies but he can't — that would exceed A. Bob wins.", "starter_code": "", "test_cases": {"inputs": ["10\n3 2\n4 2\n1 1\n1 2\n1 3\n9 3\n9 11\n9 12\n9 1000\n8 11"], "outputs": ["Bob\nLimak\nLimak\nBob\nBob\nLimak\nLimak\nBob\nBob\nBob"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "c6da813fe9f574424d6a40d84bf0e3825f2d9df9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00771", "original_id": null, "source": "apps", "domain": "code", "problem": "Write a program to check whether a triangle is valid or not, when the three angles of the triangle are the inputs. A triangle is valid if the sum of all the three angles is equal to 180 degrees.\n\n-----Input-----\n\nThe first line contains an integer T, the total number of testcases. Then T lines follow, each line contains three angles  A, B and C, of the triangle separated by space. \n\n-----Output-----\nFor each test case, display 'YES' if the triangle is valid, and 'NO', if it is not, in a new line.\n\n-----Constraints-----\n- 1 ≤ T ≤ 1000\n- 1 ≤ A,B,C ≤ 180\n\n-----Example-----\nInput\n\n3 \n40 40 100\n45 45 90\n180 1 1\nOutput\n\nYES\nYES\nNO", "starter_code": "", "test_cases": {"inputs": ["3 \n40 40 100\n45 45 90\n180 1 1\n"], "outputs": ["YES\nYES\nNO"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "44d3267f950962a8015285be877ca6912a33ada0", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00776", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef is playing with an expression which consists of integer operands and the following binary\nBitwise operators -  AND, OR and XOR. He is trying to figure out that what could be the Maximum possible answer of the expression, given that he can perform the operation in any order i.e not necessarily follow the rule of Precedence of operators while evaluating the expression.\nAfter some time of consistent work Chef starts feeling exhausted and wants you to automate this process for him. Can you help him out?\nThe expression has Bitwise operators in symbol format:\n- &  stands for AND \n- |   stands for OR\n- ^   stands for XOR\nNOTE : It is guaranteed that the expression will always be valid, also each OPERATOR will always be preceded and succeeded by an OPERAND.\n\n-----Input:-----\n- The first line of input contains a single integer $T$ denoting the number of test cases.\n- The only line of input for each test case is a $string$ which is the Chef's expression to evaluate.\n\n-----Output:-----\nFor each test case print a single integer i.e the maximum possible value of Chef's expression.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$.\n- The number of OPERATORS in the expression will be atleast 1 and atmost 10.\n- Each OPERAND may range from 0 to $10^9$.\n\n-----Subtasks-----\n- 10 points : The number of OPERATORS in the expression will be atmost 5.\n- 20 points : The number of OPERATORS in the expression will be atmost 8.\n- 70 points : Original constraints.\n\n-----Sample Input:-----\n2\n3^40|10^2\n\n92^95|56&2&3\n\n-----Sample Output:-----\n43\n\n95\n\n-----EXPLANATION:-----CASE 2 :\n- If we first compute (56 & 2), the expression becomes 92^95|0&3, since (56 & 2) yields $0$.\n- Now on computing (95 | 0), the expression becomes 92^95&3.\n- Further on computing (95 & 3), the expression becomes 92^3.\n- Finally (92 ^ 3) yields 95, which is the maximum value of the expression.", "starter_code": "", "test_cases": {"inputs": ["2\n3^40|10^2\n92^95|56&2&3"], "outputs": ["43\n95"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8cbe393e7de4138442e860fec5c4e5c93d31d6ac", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00781", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef has a strip of length $N$ units and he wants to tile it using $4$ kind of tiles\n\n-A Red tile of $2$ unit length\n\n-A Red tile of $1$ unit length\n\n-A Blue tile of $2$ unit length\n\n-A Blue tile of $1$ unit length   \nChef is having an infinite supply of each of these tiles. He wants to find out the number of ways in which he can tile the strip. Help him find this number.\nSince this number can be large, output your answer modulo 1000000007 ($10^9 + 7$).\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single line of input, an integer $N$. \n\n-----Output:-----\nFor each testcase, output in a single line your answer modulo 1000000007.\n\n-----Constraints-----\n- $1 \\leq T \\leq 1000$\n- $2 \\leq N \\leq 10^{18}$\n\n-----Sample Input:-----\n1\n2\n\n-----Sample Output:-----\n6\n\n-----EXPLANATION:-----\n\nIt can be seen that for a strip of length $2$, there are $6$ possible configurations.     \n$NOTE : $ 2 tiles of 1 unit length are different from 1 tile of 2 unit length.", "starter_code": "", "test_cases": {"inputs": ["1\n2"], "outputs": ["6"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8b9f388e1e013a34c242d5160a7307c6b9700edf", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00786", "original_id": null, "source": "apps", "domain": "code", "problem": "Problem description.\nWinston and Royce love sharing memes with each other. They express the amount of seconds they laughed ar a meme as the number of ‘XD’ subsequences in their messages. Being optimization freaks, they wanted to find the string with minimum possible length and having exactly the given number of ‘XD’ subsequences.\n\n-----Input-----\n- The first line of the input contains an integer T denoting the number of test cases.\n- Next T lines contains a single integer N, the no of seconds laughed.\n\n-----Output-----\n- \nFor each input, print the corresponding string having minimum length. If there are multiple possible answers, print any.\n\n-----Constraints-----\n- 1 ≤ T ≤ 1000\n- 1 ≤ N ≤ 109\n- 1 ≤ Sum of length of output over all testcases ≤ 5*105\n\n-----Example-----\nInput:\n1\n9\n\nOutput:\nXXXDDD\n\n-----Explanation-----\nSome of the possible strings are - XXDDDXD,XXXDDD,XDXXXDD,XDXDXDD etc. Of these, XXXDDD is the smallest.", "starter_code": "", "test_cases": {"inputs": ["1\n9"], "outputs": ["XXXDDD"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8e5ac2b98bf3c537b7cbadb574815eb5ea33f864", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00791", "original_id": null, "source": "apps", "domain": "code", "problem": "Kostya likes the number 4 much. Of course! This number has such a lot of properties, like:\n\n- Four is the smallest composite number;\n- It is also the smallest Smith number;\n- The smallest non-cyclic group has four elements;\n- Four is the maximal degree of the equation that can be solved in radicals;\n- There is four-color theorem that states that any map can be colored in no more than four colors in such a way that no two adjacent regions are colored in the same color;\n- Lagrange's four-square theorem states that every positive integer can be written as the sum of at most four square numbers;\n- Four is the maximum number of dimensions of a real division algebra;\n- In bases 6 and 12, 4 is a 1-automorphic number;\n- And there are a lot more cool stuff about this number!\n\nImpressed by the power of this number, Kostya has begun to look for occurrences of four anywhere. He has a list of T integers, for each of them he wants to calculate the number of occurrences of the digit 4 in the decimal representation. He is too busy now, so please help him.\n\n-----Input-----\nThe first line of input consists of a single integer T, denoting the number of integers in Kostya's list.\nThen, there are T lines, each of them contain a single integer from the list.\n\n-----Output-----\nOutput T lines. Each of these lines should contain the number of occurences of the digit 4 in the respective integer from Kostya's list.\n\n-----Constraints-----\n- 1 ≤ T ≤ 105\n- (Subtask 1): 0 ≤ Numbers from the list  ≤ 9 - 33 points.\n- (Subtask 2): 0 ≤ Numbers from the list  ≤ 109 - 67 points.\n\n-----Example-----\nInput:\n5\n447474\n228\n6664\n40\n81\n\nOutput:\n4\n0\n1\n1\n0", "starter_code": "", "test_cases": {"inputs": ["5\n447474\n228\n6664\n40\n81"], "outputs": ["4\n0\n1\n1\n0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "86f25e7d1da15829279f25cbc4736cb2e914f101", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00796", "original_id": null, "source": "apps", "domain": "code", "problem": "-----Problem-----\n\n\t\t\tOnce THANMAY met PK who is from a different planet visiting earth. THANMAY was very fascinate to learn PK's language. The language contains only lowercase English letters and is based on a simple logic that only certain characters can follow a particular character.\n\n\n\t\t\tNow he is interested in calculating the number of possible words of length L and ending at a particular character C. Help THANMAY to calculate this value. \n\n-----Input-----\n\n\t\t\tThe input begins with 26 lines, each containing 26 space-separated integers. The integers can be either 0 or 1. The jth integer at ith line depicts whether jth English alphabet can follow ith English alphabet or not.\n\n\n\t\t\t Next line contains an integer T. T is the number of queries.\n\n\t\t\t Next T lines contains a character C and an integer L.\n\n-----Output-----\n\n\t\t\tFor each query output the count of words of length L ending with the character C. Answer to each query must be followed by newline character.\n\n\n\t\t\tThe answer may be very large so print it modulo 1000000007.\n\n-----Constraints-----\n- \n\t\t\t\t\t1 ≤ T ≤ 100\n- \nC is lowercase English alphabet.\n\n- \n\t\t\t\t\t2 ≤ L ≤ 10000000\n\t\t\n\n-----Sample Input-----\n0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n\n1 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\n\n0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n0 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\n\n2\n\nc 3\n\nb 2\n\n-----Sample Output-----\n1\n\n2\n\n-----Explanation-----\n\n\t\t\tFor query 1, Words of length 3 are: aba, acb, bab, bac, cba. The only word ending with 'c' is bac.\n\t\t p { text-align:justify }", "starter_code": "", "test_cases": {"inputs": ["0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 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\n0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n2\nc 3\nb 2"], "outputs": ["1\n2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "dc1511b42b81074f13a79f2b8d74e0c5f2529571", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00801", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef likes toys. His favourite toy is an array of length N. This array contains only integers. He plays with this array every day. His favourite game with this array is Segment Multiplication. In this game, the second player tells the left and right side of a segment and some modulo. The first player should find the multiplication of all the integers in this segment of the array modulo the given modulus. Chef is playing this game. Of course, he is the first player and wants to win all the games. To win any game he should write the correct answer for each segment. Although Chef is very clever, he has no time to play games. Hence he asks you to help him. Write the program that solves this problem.\n\n-----Input-----\nThe first line of the input contains an integer N denoting the number of elements in the given array. Next line contains N integers Ai separated with spaces. The third line contains the number of games T. Each of the next T lines contain 3 integers Li, Ri and Mi, the left side of the segment, the right side of segment and the modulo.\n\n-----Output-----\nFor each game, output a single line containing the answer for the respective segment.\n\n-----Constrdaints-----\n- 1 ≤ N ≤ 100,000\n- 1 ≤ Ai ≤ 100\n- 1 ≤ T ≤ 100,000\n- 1 ≤ Li ≤ Ri ≤ N\n- 1 ≤ Mi ≤ 109\n\n-----Example-----\nInput:\n5\n1 2 3 4 5\n4\n1 2 3\n2 3 4\n1 1 1\n1 5 1000000000\n\nOutput:\n2\n2\n0\n120", "starter_code": "", "test_cases": {"inputs": ["5\n1 2 3 4 5\n4\n1 2 3\n2 3 4\n1 1 1\n1 5 1000000000"], "outputs": ["2\n2\n0\n120"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "489ae4ee6f9f3b5a4f2d6d170ebce03c2fba9ccc", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00806", "original_id": null, "source": "apps", "domain": "code", "problem": "This question is similar to the $\"Operation$ $on$ $a$ $Tuple\"$ problem in this month's Long Challenge but with a slight variation.\n\nConsider the following operations on a triple of integers. In one operation, you should:\n\n- Choose a positive integer $d>0$ and an arithmetic operation - in this case, it will only be addition.\n\n- Choose a subset of elements of the triple.\n\n- Apply arithmetic operation to each of the chosen elements.\n\nFor example, if we have a triple $(3,5,7)$, we may choose to add $3$ to the first and third element, and we get $(6,5,10)$ using one operation.\n\nYou are given an initial triple $(p,q,r)$ and a target triple $(a,b,c)$. Find the maximum number of operations needed to transform $(p,q,r)$ into $(a,b,c)$ or say the conversion is impossible .\nInput:\n- The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.\n- The first line of each test case contains three space-separated integers p, q and r.\n- The second line contains three space-separated integers a, b and c.Output:\nFor each test case, print a single line containing one integer ― the maximum required number of operations(if the conversion is possible), or else print \"-1\"\n\nConstraints:\n- $1 \\leq T \\leq 1,000$\n- $2 \\leq |p|,|q|,|r|,|a|,|b|,|c| \\leq 10^9$Sample Input:\n\t1\n\n\t2 2 1\n\n\t3 3 2\n\nSample Output:\n\t3\n\t", "starter_code": "", "test_cases": {"inputs": ["1\n2 2 1\n3 3 2"], "outputs": ["3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d01b652f74dc30eaf726ddfd43ce7e58146b0371", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00811", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef Ada is preparing $N$ dishes (numbered $1$ through $N$). For each valid $i$, it takes $C_i$ minutes to prepare the $i$-th dish. The dishes can be prepared in any order.\nAda has a kitchen with two identical burners. For each valid $i$, to prepare the $i$-th dish, she puts it on one of the burners and after $C_i$ minutes, removes it from this burner; the dish may not be removed from the burner before those $C_i$ minutes pass, because otherwise it cools down and gets spoiled. Any two dishes may be prepared simultaneously, however, no two dishes may be on the same burner at the same time. Ada may remove a dish from a burner and put another dish on the same burner at the same time.\nWhat is the minimum time needed to prepare all dishes, i.e. reach the state where all dishes are prepared?\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains a single integer $N$.\n- The second line contains $N$ space-separated integers $C_1, C_2, \\ldots, C_N$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the minimum number of minutes needed to prepare all dishes.\n\n-----Constraints-----\n- $1 \\le T \\le 1,000$\n- $1 \\le N \\le 4$\n- $1 \\le C_i \\le 5$ for each valid $i$\n\n-----Subtasks-----\nSubtask #1 (1 points): $C_1 = C_2 = \\ldots = C_N$\nSubtask #2 (99 points): original constraints\n\n-----Example Input-----\n3\n3\n2 2 2\n3\n1 2 3\n4\n2 3 4 5\n\n-----Example Output-----\n4\n3\n7\n\n-----Explanation-----\nExample case 1: Place the first two dishes on the burners, wait for two minutes, remove both dishes and prepare the last one on one burner.\nExample case 2: Place the first and third dish on the burners. When the first dish is prepared, remove it and put the second dish on the same burner.\nExample case 3: Place the third and fourth dish on the burners. When the third dish is prepared, remove it and put the second dish on the same burner. Similarly, replace the fourth dish (when it is prepared) by the first dish on the other burner.", "starter_code": "", "test_cases": {"inputs": ["3\n3\n2 2 2\n3\n1 2 3\n4\n2 3 4 5"], "outputs": ["4\n3\n7"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f9da85b76f530aff42aab1fc7139ce7e950b08bd", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00816", "original_id": null, "source": "apps", "domain": "code", "problem": "Chefu is Chef's little brother, he is 12 years old and he is new to competitive programming.\nChefu is practicing very hard to become a very skilled competitive programmer and win gold medal in IOI.\nNow Chefu is participating in a contest and the problem that he is trying to solve states:\nGiven an array A of N integers, find any i, j such that i <  j \nand Ai + Aj is maximum possible \nunfortunately, there's no much time left before the end of the contest, so Chefu doesn't have time to think of correct solution, so instead, he wrote a solution that selects a random pair (i,  j) (i <  j) and output Ai + Aj. each pair is equiprobable to be selected.\nNow Chefu wants your help to calculate the probability that his solution will pass a particular input.\n\n-----Input-----\nFirst line contains an integer T denoting the number of test-cases.\nFirst line of each test-case contains a single integer N\nSecond line of each test-case contains N space-separated integers A1 A2 ... AN\n\n-----Output-----\nFor each test-case output a single line containing a single number denoting the probability that Chefu's solution to output a correct answer. your answer will be accepted if the absolute difference between it and correct answer is less than 1e-6\n\n-----Constraints-----\n- 1 ≤ T ≤ 100\n- 2 ≤ N ≤ 100\n- 1 ≤ Ai ≤ 1,000\n\n-----Example-----\nInput:\n3\n4\n3 3 3 3\n6\n1 1 1 2 2 2\n4\n1 2 2 3\n\nOutput:\n1.00000000\n0.20000000\n0.33333333", "starter_code": "", "test_cases": {"inputs": ["3\n4\n3 3 3 3\n6\n1 1 1 2 2 2\n4\n1 2 2 3"], "outputs": ["1.00000000\n0.20000000\n0.33333333"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b5233eaf5f4ce67e7130d127c7b332c7de7e2ac1", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00821", "original_id": null, "source": "apps", "domain": "code", "problem": "Due to the COVID pandemic, maintaining social distancing is of utmost importance. In this problem, you'd calculate how many days would it take to reach an apocalypse from an initial case if nobody maintains social distancing.\nThe Earth is flat (for this question) and it's dimensions are $R$ x $C$\nThe whole Earth is already divided into blocks and the virus can spread in all directions except diagonally. The virus from each newly infected person will spread in all directions in the next day, thus growing exponentially.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Next line contains $R$ and $C$ respectively separated by a space.\n- Next line contains $x$ and $y$ respectively separated by a space, denoting the indices of the initial case in the world.\n\n-----Output:-----\nFor each testcase, output in a single line an integer denoting the number of days after which everyone will be infected.\n\n-----Constraints-----\n- $1 \\leq T \\leq 10^4$\n- $2 \\leq R,C \\leq 10^7$\n- $0 \\leq x,y \\leq 10^7$\n\n-----Subtasks-----\n- 10 points : $1 \\leq T \\leq 5$ and $2 \\leq R,C \\leq 10$\n- 20 points : $2 \\leq R,C \\leq 10^5$\n- 70 points : Original constraints\n\n-----Sample Input:-----\n2\n4 5\n2 1\n3 4\n1 1\n\n-----Sample Output:-----\n5\n3\n\n-----EXPLANATION:-----\n2nd test case:\nAssuming, it's a small world of $3$ x $4$\n0 is not infected. 1 is infected.\nWorld indexing is like a 2D array:\n(0,0) (0,1) (0,2) (0,3)\n(1,0) (1,1) (1,2) (1,3)\n(2,0) (2,1) (2,2) (2,3)\nIf this is the case on Day 0:\n0 0 0 0\n0 1 0 0\n0 0 0 0\nThis will be the case on Day 1:\n0 1 0 0\n1 1 1 0\n0 1 0 0\nThis will be the case on Day 2:\n1 1 1 0\n1 1 1 1\n1 1 1 0\nThe End on Day 3:\n1 1 1 1\n1 1 1 1\n1 1 1 1\nThus, answer will be 3", "starter_code": "", "test_cases": {"inputs": ["2\n4 5\n2 1\n3 4\n1 1"], "outputs": ["5\n3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "51150ae5eee3c57734d11b54eef8daa5e457683e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00826", "original_id": null, "source": "apps", "domain": "code", "problem": "You are the principal of the Cake school in chefland and today is your birthday. You want to treat each of the children with a small cupcake which is made by you. But there is a problem, You don't know how many students are present today.\nThe students have gathered of the morning assembly in $R$ rows and $C$ columns. Now you have to calculate how many cakes you have to make such that each child gets a cupcake. \n\n-----Input:-----\n- First-line will contain $T$, the number of test cases. Then the test cases follow. \n- Each test case contains a single line of input, two integers $R$ and $C$. \n\n-----Output:-----\nFor each test case, output number of cupcakes you have to make.\n\n-----Constraints-----\n- $1 \\leq T \\leq 1000$\n- $2 \\leq R,C \\leq 10^6$\n\n-----Sample Input:-----\n1\n5 10\n\n-----Sample Output:-----\n50", "starter_code": "", "test_cases": {"inputs": ["1\n5 10"], "outputs": ["50"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2dd256248c445b76b589ce23a904635020fb5912", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00831", "original_id": null, "source": "apps", "domain": "code", "problem": "Finally, a COVID vaccine is out on the market and the Chefland government has asked you to form a plan to distribute it to the public as soon as possible. There are a total of $N$ people with ages $a_1, a_2, \\ldots, a_N$.\nThere is only one hospital where vaccination is done and it is only possible to vaccinate up to $D$ people per day. Anyone whose age is $\\ge 80$ or $\\le 9$ is considered to be at risk. On each day, you may not vaccinate both a person who is at risk and a person who is not at risk. Find the smallest number of days needed to vaccinate everyone.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $D$.\n- The second line contains $N$ space-separated integers $a_1, a_2, \\ldots, a_N$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the smallest required number of days.\n\n-----Constraints-----\n- $1 \\le T \\le 10$\n- $1 \\le N \\le 10^4$\n- $1 \\le D \\le 10^5$\n- $1 \\le a_i \\le 100$ for each valid $i$\n\n-----Subtasks-----\nSubtask #1 (100 points): original constraints\n\n-----Example Input-----\n2\n10 1\n10 20 30 40 50 60 90 80 100 1\n5 2\n9 80 27 72 79\n\n-----Example Output-----\n10\n3\n\n-----Explanation-----\nExample case 1: We do not need to worry about how the people are grouped, since only one person can be vaccinated in a single day. We require as many days as there are people.\nExample case 2: There are two people at risk and three people who are not at risk. One optimal strategy is to vaccinate the two people at risk on day $1$ and the remaining three on the next $2$ days.", "starter_code": "", "test_cases": {"inputs": ["2\n10 1\n10 20 30 40 50 60 90 80 100 1\n5 2\n9 80 27 72 79"], "outputs": ["10\n3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2d1d4b4d7b7a29820a2717d805f1692872cadad0", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00836", "original_id": null, "source": "apps", "domain": "code", "problem": "Vishal Wants to buy 2 gifts for his best friend whose name is Annabelle(her age is 20), So they both went for shopping in a store. But Annabelle gave, Vishal a condition that she will accept this gifts only when the total price of the gifts is the same as her age times 100.\nThe store contains, a list of items whose prices are also displayed, Now Vishal is asking for your help to buy gifts, as he wants to impress Annabelle this time.\nNote: Vishal cannot buy the same item more than once.\n\n-----Input:-----\n- The first line of the input contains a single integer $T$. $T$ denoting the number of test cases. The description of $T$ test cases is as follows.\n- The next line of the input contains a single integer $N$. $N$ denotes the total number of items in store.\n- The next line of the input contains $N$ space-separated integers $A1, A2, A3...An$ where $ith$ number denotes the price of $ith$ element.\n\n-----Output:-----\n- For each test-case print \"Accepted\"(without quotes) if the gifts are accepted by Annabelle, else print \"Rejected\"(without quotes)\n\n-----Constraints:-----\n- $1 \\leq T \\leq 10^3$\n- $1 \\leq N \\leq 10^5$\n- $1 \\leq A1, A2, A3...An \\leq 10^7$\n\n-----Sample Input:-----\n1\n5\n10 2 1000 50 1000\n\n-----Sample Output:-----\nAccepted\n\n-----Explanation:-----\n- As the given list of items have 2 items whose price sum up to the age times 100 of Annabelle i.e. 1000+1000 = (20 *100)", "starter_code": "", "test_cases": {"inputs": ["1\n5\n10 2 1000 50 1000"], "outputs": ["Accepted"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "412431b8c876b828443629045c71226cc2d10a62", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00841", "original_id": null, "source": "apps", "domain": "code", "problem": "Yash likes playing with numbers. He has a challenge for you. Yash gives\nyou a number that he made by multiplying two numbers. He claims that the\npossible sum of the two numbers he multiplied is as minimum as possible. He\nchallenges you to find that minimum sum.\n\nFormally, for a given value of N, you are required to find the minimum sum of two distinct numbers x and y such that x, y > 0 and xy = N.  \n\n-----Input:-----\nThe first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.\n\nEach testcase contains single integer N.\n\n-----Output:-----\nFor each testcase, output minimum x + y such that x*y = N and x,y >0.\n\n-----Constraints :-----\n$1 \\leq T \\leq 100$\n$1 < N \\leq 10^{12}$\n\n-----Sample Input:-----\n1\n\n852140\n\n-----Sample Output:-----\n1929", "starter_code": "", "test_cases": {"inputs": ["1\n852140"], "outputs": ["1929"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "7578c8c5595d256848ddeedfd0b6c5741dac372a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00846", "original_id": null, "source": "apps", "domain": "code", "problem": "In the 2-D world of Flatland, the Circles were having their sports day and wanted to end it with a nice formation. So, they called upon Mr. Sphere from Spaceland for help. Mr Sphere decides to arrange the Circles in square formations. He starts with $N$ Circles and forms the largest possible square using these Circles. He then takes the remaining Circles and repeats the procedure. A square of side $S$ requires $S^2$ Circles to create.\nFind the number of squares he will be able to form at the end of the process.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow.\n- Each testcase contains of a single integer $N$.\n\n-----Output:-----\nFor each testcase, output a single integer denoting the number of squares.\n\n-----Constraints-----\n- $1 \\leq T \\leq 1000$\n- $1 \\leq N \\leq 1000$\n\n-----Sample Input:-----\n2\n\n85\n\n114          \n\n-----Sample Output:-----\n2\n\n4\n\n-----EXPLANATION:-----\nTest case 1 : Mr Sphere forms a square of side 9 using 81 Circles and then forms a square of side 2 using the remaining 4.", "starter_code": "", "test_cases": {"inputs": ["2\n85\n114"], "outputs": ["2\n4"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "036761ae89761196071e6f67dc542f8ef8786461", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00851", "original_id": null, "source": "apps", "domain": "code", "problem": "Mandarin chinese\n, Russian and Vietnamese as well.\nChef is organising a contest with $P$ problems (numbered $1$ through $P$). Each problem has $S$ subtasks (numbered $1$ through $S$).\nThe difficulty of a problem can be calculated as follows:\n- Let's denote the score of the $k$-th subtask of this problem by $SC_k$ and the number of contestants who solved it by $NS_k$.\n- Consider the subtasks sorted in the order of increasing score.\n- Calculate the number $n$ of valid indices $k$ such that $NS_k > NS_{k + 1}$.\n- For problem $i$, the difficulty is a pair of integers $(n, i)$.\nYou should sort the problems in the increasing order of difficulty levels. Since difficulty level is a pair, problem $a$ is more difficult than problem $b$ if the number $n$ is greater for problem $a$ than for problem $b$, or if $a > b$ and $n$ is the same for problems $a$ and $b$.\n\n-----Input-----\n- The first line of the input contains two space-separated integers $P$ and $S$ denoting the number of problems and the number of subtasks in each problem.\n- $2P$ lines follow. For each valid $i$, the $2i-1$-th of these lines contains $S$ space-separated integers $SC_1, SC_2, \\dots, SC_S$ denoting the scores of the $i$-th problem's subtasks, and the $2i$-th of these lines contains $S$ space-separated integers $NS_1, NS_2, \\dots, NS_S$ denoting the number of contestants who solved the $i$-th problem's subtasks.\n\n-----Output-----\nPrint $P$ lines containing one integer each — the indices of the problems in the increasing order of difficulty.\n\n-----Constraints-----\n- $1 \\le P \\le 100,000$\n- $2 \\le S \\le 30$\n- $1 \\le SC_i \\le 100$ for each valid $i$\n- $1 \\le NS_i \\le 1,000$ for each valid $i$\n- in each problem, the scores of all subtasks are unique\n\n-----Subtasks-----\nSubtask #1 (25 points): $S = 2$\nSubtask #2 (75 points): original constraints\n\n-----Example Input-----\n3 3\n16 24 60\n498 861 589\n14 24 62\n72 557 819\n16 15 69\n435 779 232\n\n-----Example Output-----\n2\n1\n3", "starter_code": "", "test_cases": {"inputs": ["3 3\n16 24 60\n498 861 589\n14 24 62\n72 557 819\n16 15 69\n435 779 232"], "outputs": ["2\n1\n3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "9c488698026ba43810d6798df2ae69c80d24f3ca", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00856", "original_id": null, "source": "apps", "domain": "code", "problem": "Guddu was participating in a programming contest. He only had one problem left when his mother called him for dinner. Guddu is well aware how angry his mother could get if he was late for dinner and he did not want to sleep on an empty stomach, so he had to leave that last problem to you. Can you solve it on his behalf?\nFor a given sequence of positive integers $A_1, A_2, \\ldots, A_N$, you are supposed to find the number of triples $(i, j, k)$ such that $1 \\le i < j \\le k \\le N$ and\nAi⊕Ai+1⊕…⊕Aj−1=Aj⊕Aj+1⊕…⊕Ak,Ai⊕Ai+1⊕…⊕Aj−1=Aj⊕Aj+1⊕…⊕Ak,A_i \\oplus A_{i+1} \\oplus \\ldots \\oplus A_{j-1} = A_j \\oplus A_{j+1} \\oplus \\ldots \\oplus A_k \\,,\nwhere $\\oplus$ denotes bitwise XOR.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains a single integer $N$.\n- The second line contains $N$ space-separated integers $A_1, A_2, \\ldots, A_N$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the number of triples.\n\n-----Constraints-----\n- $1 \\le T \\le 10$\n- $2 \\le N \\le 10^5$\n- $1 \\le A_i \\le 10^6$ for each valid $i$\n\n-----Subtasks-----\nSubtask #1 (20 points):\n- $1 \\le T \\le 5$\n- $1 \\le N \\le 100$\nSubtask #2 (30 points):\n- $1 \\le T \\le 5$\n- $1 \\le N \\le 1,000$\nSubtask #3 (50 points): original constraints\n\n-----Example Input-----\n1\n3\n5 2 7\n\n-----Example Output-----\n2\n\n-----Explanation-----\nExample case 1: The triples are $(1, 3, 3)$, since $5 \\oplus 2 = 7$, and $(1, 2, 3)$, since $5 = 2 \\oplus 7$.", "starter_code": "", "test_cases": {"inputs": ["1\n3\n5 2 7"], "outputs": ["2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8e59c75ec1ea6aaac21a7895fd877638155e438e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00861", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a positive integer $N$. Consider the sequence $S = (1, 2, \\ldots, N)$. You should choose two elements of this sequence and swap them.\nA swap is nice if there is an integer $M$ ($1 \\le M < N$) such that the sum of the first $M$ elements of the resulting sequence is equal to the sum of its last $N-M$ elements. Find the number of nice swaps.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first and only line of each test case contains a single integer $N$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the number of nice swaps.\n\n-----Constraints-----\n- $1 \\le T \\le 10^6$\n- $1 \\le N \\le 10^9$\n\n-----Subtasks-----\nSubtask #1 (10 points):\n- $T \\le 10$\n- $N \\le 10^3$\nSubtask #2 (30 points):\n- $T \\le 10$\n- $N \\le 10^6$\nSubtask #3 (60 points): original constraints\n\n-----Example Input-----\n5\n1\n2\n3\n4\n7\n\n-----Example Output-----\n0\n0\n2\n2\n3", "starter_code": "", "test_cases": {"inputs": ["5\n1\n2\n3\n4\n7"], "outputs": ["0\n0\n2\n2\n3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d460e398901aad28db9f3086960492aeba1e20c7", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00866", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef's friend Alex runs a movie theatre. Due to the increasing number of platforms for watching movies online, his business is not running well. As a friend, Alex asked Chef to help him maximise his profits. Since Chef is a busy person, he needs your help to support his friend Alex.  \nAlex's theatre has four showtimes: 12 PM, 3 PM, 6 PM and 9 PM. He has four movies which he would like to play ― let's call them A, B, C and D. Each of these movies must be played exactly once and all four must be played at different showtimes. For each showtime, the price of a ticket must be one of the following: Rs 25, Rs 50, Rs 75 or Rs 100. The prices of tickets for different showtimes must also be different.\nThrough his app, Alex receives various requests from his customers. Each request has the form \"I want to watch this movie at this showtime\". Let's assume that the number of people who come to watch a movie at a given showtime is the same as the number of requests for that movie at that showtime.\nIt is not necessary to accommodate everyone's requests ― Alex just wants to earn the maximum amount of money. There is no restriction on the capacity of the theatre. However, for each movie that is not watched by anyone, Alex would suffer a loss of Rs 100 (deducted from the profit).\nYou are given $N$ requests Alex received during one day. Find the maximum amount of money he can earn on that day by choosing when to play which movies and with which prices. \n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains a single integer $N$.\n- $N$ lines follow. Each of these lines contains a character $m$, followed by a space and an integer $t$, describing a request to see the movie $m$ at the showtime $t$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the maximum profit Alex can earn (possibly negative).\nFinally, print a line containing one integer ― the total profit over all test cases, i.e. over $T$ days.\n\n-----Constraints-----\n- $1 \\le T \\le 150$\n- $0 \\le N \\le 100$\n- $m$ is 'A', 'B', 'C' or 'D'\n- $t$ is $12$, $3$, $6$ or $9$\n\n-----Subtasks-----\nSubtask #1 (30 points): it is possible to fulfill all requests\nSubtask #2 (70 points): original constraints\n\n-----Example Input-----\n5\n12\nA 3\nB 12\nC 6\nA 9\nB 12\nC 12\nD 3\nB 9\nD 3\nB 12\nB 9\nC 6\n7\nA 9\nA 9\nB 6\nC 3\nD 12\nA 9\nB 6\n2\nA 9\nB 6\n1\nD 12\n0 \n\n-----Example Output-----\n575\n525\n-25 \n-200 \n-400\n475\n\n-----Explanation-----\nExample case 1: The following table shows the number of people that want to watch the movies at the given showtimes:  12  3  6  9   A   0  1  0 1  B   3  0  0  2   C   1  0  2  0   D   0  2  0  0 \nThe maximum number of requests was sent for movie B at 12 PM. Therefore, we play this movie at this time and the tickets cost Rs 100. Next, we play movie D at 3 PM with ticket price Rs 75 and movie C at 6 PM with ticket price Rs 50. Finally, we have a slot for 9 PM and the only movie we can play at that time now is movie A, with ticket price Rs 25. The total profit is $3 \\cdot 100 + 2 \\cdot 75 + 2 \\cdot 50 + 1 \\cdot 25 = 300 + 150 + 100 + 25 = 575$. Since each movie was watched by at least one person, there is no additional loss.\nExample case 2: Just like above, we show the requests in a table:  12  3  6  9   A   0  0  0 3  B   0  0  2  0   C   0  1  0  0   D   1  0  0  0 \nThe optimal solution is to play movie A at 9 PM, movie B at 6 PM, movie C at 3 PM and movie D at 12 PM, with decreasing ticket prices in this order. The profit is $3 \\cdot 100 + 2 \\cdot 75 + 1 \\cdot 50 + 1 \\cdot 25 = 300+150+50+25 = 525$.\nExample case 3: Again, we show the requests in a table:  12  3  6  9   A   0  0  0 1  B   0  0  1  0   C   0  0  0  0   D   0  0  0  0 \nThe optimal solution is to play movie A at 9 PM with ticket price Rs 100, movie B at 6 PM with ticket price Rs 75 and the remaining two movies in any order at 12 PM and 3 PM ― either way, there will be nobody watching them. We earn $1 \\cdot 100 + 1 \\cdot 75 = 175$, but we have to deduct Rs 200, so the resulting profit is $175 - 200 = -25$.\nExample case 4: The optimal solution is to play movie D at 12 PM; the other three movies go unattended. We have to deduct Rs 300, so the profit is $1 \\cdot 100 - 300 = -200$.\nExample case 5: Since there are no requests for any movie at any time, all movies go unattended and Alex just suffers a loss of Rs 400.\nThe total profit for all 5 days is $575+525-25-200-400 = 475$.", "starter_code": "", "test_cases": {"inputs": ["5\n12\nA 3\nB 12\nC 6\nA 9\nB 12\nC 12\nD 3\nB 9\nD 3\nB 12\nB 9\nC 6\n7\nA 9\nA 9\nB 6\nC 3\nD 12\nA 9\nB 6\n2\nA 9\nB 6\n1\nD 12\n0"], "outputs": ["575\n525\n-25\n-200\n-400\n475"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "5c2b62699edab03e933c740f211dab327eccde35", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00871", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a sequence of integers $A_1, A_2, \\ldots, A_N$. This sequence is circular ― for each valid $i$, the element $A_{i+1}$ follows after $A_i$, and the element $A_1$ follows after $A_N$.\nYou may insert any positive integers at any positions you choose in this sequence; let's denote the resulting sequence by $B$. This sequence is also circular. For each pair of its elements $B_s$ and $B_f$, let's denote the (non-circular) sequence created by starting at $B_s$ and moving from each element to the one that follows after it, until we reach $B_f$, by $B(s, f)$. This sequence includes the elements $B_s$ and $B_f$.\nFor each $K$ from $2$ to $N$ inclusive, find the smallest possible number of elements that need to be inserted into $A$ to form a sequence $B$ for which there is no subsequence $B(p, q)$ such that:\n- The size of $B(p, q)$ is at least $K$.\n- There is no pair of consecutive elements in $B(p, q)$ such that their GCD is equal to $1$.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains a single integer $N$.\n- The second line contains $N$ space-separated integers $A_1, A_2, \\ldots, A_N$.\n\n-----Output-----\nFor each test case, print a single line containing $N-1$ space-separated integers. For each $i$ ($1 \\le i \\le N-1$), the $i$-th of these integers should be the smallest number of inserted elements in a valid sequence $B$ for $K = i+1$.\n\n-----Constraints-----\n- $1 \\le T \\le 2,000$\n- $2 \\le N \\le 10^5$\n- $1 \\le A_i \\le 10^9$ for each valid $i$\n- the sum of $N$ over all test cases does not exceed $2 \\cdot 10^6$\n\n-----Example Input-----\n1\n5\n3 6 4 5 9\n\n-----Example Output-----\n3 1 1 0", "starter_code": "", "test_cases": {"inputs": ["1\n5\n3 6 4 5 9"], "outputs": ["3 1 1 0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "c0e758b2219bb84396cd50156fe6dd2861e4be4e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00876", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef recently took a course in linear algebra and learned about linear combinations of vectors. Therefore, in order to test his intelligence, Raj gave him a \"fuzzy\" problem to solve.\nA sequence of integers $B_1, B_2, \\ldots, B_M$ generates an integer $K$ if it is possible to find a sequence of integers $C_1, C_2, \\ldots, C_M$ such that $C_1 \\cdot B_1 + C_2 \\cdot B_2 + \\ldots + C_M \\cdot B_M = K$.\nIn this problem, Chef has a sequence $A_1, A_2, \\ldots, A_N$ and he should answer $Q$ queries. In each query, he is given an integer $K$; the answer to this query is the number of pairs $(l, r)$ such that $1 \\le l \\le r \\le N$ and the subsequence $(A_l, A_{l+1}, \\ldots, A_r)$ generates $K$.\nChef has no idea how to solve this problem ― can you help him find the answers to all queries?\n\n-----Input-----\n- The first line of the input contains a single integer $N$.\n- The second line contains $N$ space-separated integers $A_1, A_2, \\ldots, A_N$.\n- The third line contains a single integer $Q$.\n- The following $Q$ lines describe queries. Each of these lines contains a single integer $K$.\n\n-----Output-----\nFor each query, print a single line containing one integer ― the number of contiguous subsequences that generate $K$.\n\n-----Constraints-----\n- $1 \\le N, Q \\le 10^5$\n- $1 \\le A_i \\le 10^9$ for each valid $i$\n- $1 \\le K \\le 10^6$\n\n-----Subtasks-----\nSubtask #1 (10 points): $1 \\le N \\le 1,000$\nSubtask #2 (90 points): original constraints\n\n-----Example Input-----\n2\n2 4\n3\n1\n2\n8\n\n-----Example Output-----\n0\n2\n3\n\n-----Explanation-----\nThe sequence $(2, 4)$ has three contiguous subsequences: $(2)$, $(4)$ and $(2, 4)$. \n- In the first query, $1$ cannot be generated by any subsequence.\n- In the second query, $2$ is generated by subsequences $(2)$ and $(2, 4)$. For example, for the subsequence $(2, 4)$, we can choose $C_1 = 1$ and $C_2 = 0$.\n- In the third query, $8$ is generated by all three subsequences.", "starter_code": "", "test_cases": {"inputs": ["2\n2 4\n3\n1\n2\n8"], "outputs": ["0\n2\n3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b73dede7f1ebbd3f8b719956d5d84cc1cad57cef", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00881", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given two strings $S$ and $R$. Each of these strings has length $N$. We want to make $S$ equal to $R$ by performing the following operation some number of times (possibly zero):\n- Choose two integers $a$ and $b$ such that $1 \\le a \\le b \\le N$.\n- For each $i$ such that $a \\le i \\le b$, replace the $i$-th character of $S$ by the $i$-th character of $R$.\nSuppose that we make $S$ equal to $R$ by performing this operation $k$ times, in such a way that the total number of replaced characters (i.e. the sum of all $k$ values of $b-a+1$) is $l$. Then, the cost of this process is defined as $k \\cdot l$.\nFind the minimum cost with which we can make $S$ equal to $R$.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains a single string $S$.\n- The second line contains a single string $R$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the minimum cost.\n\n-----Constraints-----\n- $1 \\le T \\le 4,000$\n- $1 \\le N \\le 10^6$\n- $|S| = |R| = N$\n- $S$ and $R$ contain only lowercase English letters\n- the sum of $N$ over all test cases does not exceed $2 \\cdot 10^6$\n\n-----Example Input-----\n1\nadefb\nbdefa\n\n-----Example Output-----\n4\n\n-----Explanation-----\nExample case 1: $S$ can be made equal to $R$ in two moves. First, we replace $S_1$ by $R_1$ and then replace $S_5$ by $R_5$. We have $k = l = 2$, so the cost is $2 \\cdot 2 = 4$. If we wanted to perform only one operation, the cost would be $5$.", "starter_code": "", "test_cases": {"inputs": ["1\nadefb\nbdefa"], "outputs": ["4"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "09b04b9134a9dc36a254c8af026aa3ea2c602901", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00886", "original_id": null, "source": "apps", "domain": "code", "problem": "The chef is having one string of English lower case alphabets only. The chef wants to remove all \"abc\" special pairs where a,b,c are occurring consecutively. After removing the pair, create a new string and again remove \"abc\" special pair from a newly formed string. Repeate the process until no such pair remains in a string.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single line of input, $String$. \n\n-----Output:-----\nFor each testcase, output in a single line answer, new String with no \"abc\" special pair.\n\n-----Constraints:-----\n$T \\leq 2 $\n$1 \\leq String length \\leq 1000 $\n\n-----Sample Input:-----\n2\naabcc\nbababccc\n\n-----Sample Output:-----\nac\nbc\n\n-----EXPLANATION:-----\nFor 1) after removing \"abc\" at middle we get a new string as ac.\nFor 2) string = bababccc\nnewString1 = babcc  // After removing middle \"abc\"\nnewString2 = bc   //After removing \"abc\"", "starter_code": "", "test_cases": {"inputs": ["2\naabcc\nbababccc"], "outputs": ["ac\nbc"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "a77f5fc6c149f482b533441322c1b8e0fc1d93f8", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00891", "original_id": null, "source": "apps", "domain": "code", "problem": "Today Chef wants to evaluate the dishes of his $N$ students. He asks each one to cook a dish and present it to him.\nChef loves his secret ingredient, and only likes dishes with at least $X$ grams of it.\nGiven $N$, $X$ and the amount of secret ingredient used by each student $A_i$, find out whether Chef will like at least one dish. \n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- The first line of each testcase contains two integers $N$ \n(number of students) and $X$ (minimum amount of secret ingredient that a dish must contain for Chef to like it).\n- The next line contains $N$ space separated integers, $A_i$ denoting the amount of secret ingredient used by the students in their dishes.\n\n-----Output:-----\nFor each testcase, print a single string \"YES\" if Chef likes at least one dish. Otherwise, print \"NO\". (Without quotes).\n\n-----Constraints:-----\n- $1 \\leq T \\leq 100$\n- $1 \\leq N \\leq 1000$\n- $1 \\leq X \\leq 1000000$\n- $1 \\leq A_i \\leq 1000000$\n\n-----Sample Input:-----\n3\n5 100\n11 22 33 44 55\n5 50\n10 20 30 40 50\n5 45\n12 24 36 48 60\n\n-----Sample Output:-----\nNO\nYES\nYES", "starter_code": "", "test_cases": {"inputs": ["3\n5 100\n11 22 33 44 55\n5 50\n10 20 30 40 50\n5 45\n12 24 36 48 60"], "outputs": ["NO\nYES\nYES"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "0b2d76cf72465339722c58ad2cb652ff82dd8f5c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00896", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef played an interesting game yesterday. This game is played with two variables $X$ and $Y$; initially, $X = Y = 0$. Chef may make an arbitrary number of moves (including zero). In each move, he must perform the following process:\n- Choose any positive integer $P$ such that $P \\cdot P > Y$.\n- Change $X$ to $P$.\n- Add $P \\cdot P$ to $Y$.\nUnfortunately, Chef has a bad memory and he has forgotten the moves he made. He only remembers the value of $X$ after the game finished; let's denote it by $X_f$. Can you tell him the maximum possible number of moves he could have made in the game?\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first and only line of each test case contains a single integer $X_f$.\n\n-----Output-----\nFor each test case, print a single line containing one integer — the maximum number of moves Chef could have made.\n\n-----Constraints-----\n- $1 \\le T \\le 10^5$\n- $1 \\le X_f \\le 10^9$\n\n-----Example Input-----\n3\n3\n8\n9\n\n-----Example Output-----\n3\n5\n6\n\n-----Explanation-----\nExample case 2: One possible sequence of values of $X$ is $0 \\rightarrow 1 \\rightarrow 2 \\rightarrow 3 \\rightarrow 5 \\rightarrow 8$.", "starter_code": "", "test_cases": {"inputs": ["3\n3\n8\n9"], "outputs": ["3\n5\n6"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2aace34c204fc6620f55c665072609ebd0f0d1ab", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00901", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef has $N$ axis-parallel rectangles in a 2D Cartesian coordinate system. These rectangles may intersect, but it is guaranteed that all their $4N$ vertices are pairwise distinct.\nUnfortunately, Chef lost one vertex, and up until now, none of his fixes have worked (although putting an image of a point on a milk carton might not have been the greatest idea after all…). Therefore, he gave you the task of finding it! You are given the remaining $4N-1$ points and you should find the missing one.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains a single integer $N$.\n- Then, $4N-1$ lines follow. Each of these lines contains two space-separated integers $x$ and $y$ denoting a vertex $(x, y)$ of some rectangle.\n\n-----Output-----\nFor each test case, print a single line containing two space-separated integers $X$ and $Y$ ― the coordinates of the missing point. It can be proved that the missing point can be determined uniquely.\n\n-----Constraints-----\n- $T \\le 100$\n- $1 \\le N \\le 2 \\cdot 10^5$\n- $|x|, |y| \\le 10^9$\n- the sum of $N$ over all test cases does not exceed $2 \\cdot 10^5$\n\n-----Subtasks-----\nSubtask #1 (20 points):\n- $T = 5$\n- $N \\le 20$\nSubtask #2 (30 points): $|x|, |y| \\le 10^5$\nSubtask #3 (50 points): original constraints\n\n-----Example Input-----\n1\n2\n1 1\n1 2\n4 6\n2 1\n9 6\n9 3\n4 3\n\n-----Example Output-----\n2 2\n\n-----Explanation-----\nThe original set of points are:\n\nUpon adding the missing point $(2, 2)$, $N = 2$ rectangles can be formed:", "starter_code": "", "test_cases": {"inputs": ["1\n2\n1 1\n1 2\n4 6\n2 1\n9 6\n9 3\n4 3"], "outputs": ["2 2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b432e4643f6587c430c6b356212cfa297efcb2a5", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00906", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a number n. Find the last two digits of 5 ^ n ( 5 to the power of n ).\nRemember that overflow can occur.\n\n-----Input:-----\n- N  — the power in which you need to raise number 5.\n\n-----Output:-----\nLast two digits of 5^n.\n\n-----Constraints-----\n- $2 \\leq N \\leq 2.1018$\n\n-----Sample Input:-----\n2\n\n-----Sample Output:-----\n25", "starter_code": "", "test_cases": {"inputs": ["2"], "outputs": ["25"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "90314a4f31662849b21267be0aae685f70b16a73", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00911", "original_id": null, "source": "apps", "domain": "code", "problem": "Walter White and Jesse Pinkman (a drug addict) both love to play with chemicals. One day they were playing with some chemicals to make an energy drink. Unknowingly they made a highly powerful drink. To test the drink on others also they called some of their friends and gave a drop of it to everyone. Now they all were feeling highly energetic and thought of an unique game to play with each other.\nAfter pondering for a while, Jesse came up with an extraordinary idea of competing in a race around a circular globe with N checkpoints each of one unit. Walter and all their other friends agreed with it.They divided themselves in $2$ teams with $N$ teammates in each team.This race has two commencing points $A$ and $B$ strictly facing each other. Walter and his team commences from $A$ point and other team starts from $B$. Both the teams start running at the same time clockwise around the globe. Speed of every player is constant throughout the race. If a player has a speed $X$ then it means that he covers a distance of $X$ units in one second.The race ends when some member of one team overtakes all members of opposite team at any point of time. Now you have to tell if any team will win the race or not.They all are stubborn and can run forever just to win the race. Help them to know if it is possible in anyway that the race will come to an end. \nFor Clarity, you can visualize the path as a circular paths where $A$ and $B$ are opposite ends of diameter. It can be proven that the actual circumference of circle do not affect the answer.\nIt is also possible that someone don't run at all.Keep in mind that the fastest one wins the race so does the code.\n\n-----Input:------\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows. \n- The first line of each test case contains a single integer $N$ number of teammates in both team.\n- The second line contains $N$ space-separated integers $A_1, A_2 \\ldots A_N$ denoting speed of A's Team\n- The third line contains $N$ space-separated integers  $B_1, B_2 \\ldots B_N$ denoting speed of B's Team\n\n-----Output:------\nFor each test case, print a single line denoting YES if the race ends at any point of time else NO\n\n-----Constraints-----\n- $1 \\leq T \\leq 10$\n- $1 \\leq N \\leq 10^5$\n- $0 \\leq A_i \\leq 2^{15}$\n- $0 \\leq B_i \\leq 2^{15}$\n\n-----Subtasks-----\nSubtask #1 (30 points): \n- $1 \\le N \\le 20$\n- $0 \\le  A_i  \\le 11$\n- $0 \\le  B_i  \\le 11$\nSubtask #2 (70 points): \n- Original constraints\n\n-----Sample input:-----\n1\n5\n1 2 3 4 5\n2 7 8 9 9\n\n-----Sample output-----\nYES\n\n-----Sample Explanation:------\nTeam B can overtake all members of Team A.", "starter_code": "", "test_cases": {"inputs": ["1\n5\n1 2 3 4 5\n2 7 8 9 9\n"], "outputs": ["YES"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b12ea652b043c8e0fdd523a229c34e0e8223d91f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00916", "original_id": null, "source": "apps", "domain": "code", "problem": "People in Karunanagar are infected with Coronavirus. To understand the spread of disease and help contain it as early as possible, Chef wants to analyze the situation in the town. Therefore, he does the following:\n- Chef represents the population of Karunanagar as a binary string of length $N$ standing in a line numbered from $1$ to $N$ from left to right, where an infected person is represented as $1$ and an uninfected person as $0$.\n- Every day, an infected person in this binary string can infect an adjacent (the immediate left and right) uninfected person.\n- Therefore, if before Day 1, the population is $00100$, then at the end of Day 1, it becomes $01110$ and at the end of Day 2, it becomes $11111$.\nBut people of Karunanagar are smart and they know that if they 'socially isolate' themselves as early as possible, they reduce the chances of the virus spreading. Therefore on $i$-th day, person numbered $P_i$ isolates himself from person numbered $P_i - 1$, thus cannot affect each other. This continues in the town for $D$ days.\nGiven the population binary string before Day 1, Chef wants to calculate the total number of infected people in Karunanagar at the end of the day $D$. Since Chef has gone to wash his hands now, can you help do the calculation for him?\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the test cases follow. \n- The first line of each test case contains a single integer $N$ denoting the length of the binary string.\n- The next line contains a binary string of length $N$ denoting the population before the first day, with $1$ for an infected person and $0$ for uninfected.\n- The next line contains a single integer $D$ - the number of days people isolate themselves.\n- The next line contains $P$ - a list of $D$ distinct space-separated integers where each $P_{i}$ denotes that at the start of $i^{th}$ day, person $P_{i}$ isolated him/herself from the person numbered $P_i-1$.\n\n-----Output:-----\nFor each test case, print a single integer denoting the total number of people who are infected after the end of $D^{th}$ day.\n\n-----Constraints-----\n- $1 \\leq T \\leq 200$\n- $2 \\leq N \\leq 10^{4}$\n- $1 \\leq D < N$\n- $2 \\leq P_{i} \\leq N$ for $1 \\le i \\le D$\n\n-----Subtasks-----\nSubtask #1(30 points): $1 \\leq T \\leq 100$, $2 \\leq N \\leq 2000$\nSubtask #2(70 points): Original Constraints\n\n-----Sample Input:-----\n2\n9\n000010000\n3\n2 5 8\n5\n00001\n1\n5\n\n-----Sample Output:-----\n6\n1\n\n-----EXPLANATION:-----\nFor the purpose of this explanation, a social distance can be denoted with a '$|$'.\nFor the first testcase:\n- \nBefore Day $1$, the population is: $0|00010000$\n- \nBefore Day $2$, the population is: $0|001|11000$\n- \nBefore Day $3$, the population is: $0|011|111|00$\n- \nTherefore, after Day $3$, the population will be: $0|111|111|00$\nSo, there are $6$ infected persons.\nFor the second testcase:\nBefore Day $1$, the population is: $0000|1$\nTherefore, there is one infected person.", "starter_code": "", "test_cases": {"inputs": ["2\n9\n000010000\n3\n2 5 8\n5\n00001\n1\n5"], "outputs": ["6\n1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "17485c605f78697815d30075c938b06300440285", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00921", "original_id": null, "source": "apps", "domain": "code", "problem": "Lavanya and Nikhil have K months of holidays ahead of them, and they want to go on exactly K road trips, one a month. They have a map of the various cities in the world with the roads that connect them. There are N cities, numbered from 1 to N. We say that you can reach city B from city A if there is a sequence of roads that starts from city A and ends at city B. Note that the roads are bidirectional. Hence, if you can reach city B from city A, you can also reach city A from city B. \nLavanya first decides which city to start from. In the first month, they will start from that city, and they will visit every city that they can reach by road from that particular city, even if it means that they have to pass through cities that they have already visited previously. Then, at the beginning of the second month, Nikhil picks a city that they haven't visited till then. In the second month, they first fly to that city and visit all the cities that they can reach from that city by road. Then, in the third month, Lavanya identifies a city, and they fly there and visit all cities reachable from there by road. Then in the fourth month it is Nikhil's turn to choose an unvisited city to start a road trip, and they alternate like this. Note that the city that they fly to (that is, the city from where they start each month's road trip) is also considered as being visited.\nEach city has some museums, and when they visit a city for the first time, Lavanya makes them visit each of the museums there. Lavanya loves going to museums, but Nikhil hates them. Lavanya always makes her decisions so that they visit the maximum number of museums possible that month, while Nikhil picks cities so that the number of museums visited that month is minimized.\nGiven a map of the roads, the number of museums in each city, and the number K, find the total number of museums that they will end up visiting at the end of K months. Print -1 if they will have visited all the cities before the beginning of the Kth month, and hence they will be left bored at home for some of the K months.\n\n-----Input-----\n- The first line contains a single integer, T, which is the number of testcases. The description of each testcase follows.\n- The first line of each testcase contains three integers: N, M and K, which represents the number of cities, number of roads and the number of months.\n- The ith of the next M lines contains two integers, ui and vi. This denotes that there is a direct road between city ui and city vi.\n- The next line contains N integers, the ith of which represents the number of museums in city i.\n\n-----Output-----\nFor each test case, if they can go on K road trips, output a single line containing a single integer which should be the total number of museums they visit in the K months. Output -1 if they can't go on K road trips.\n\n-----Constraints-----\n- 1 ≤ T ≤ 3\n- 1 ≤ N ≤ 106\n- 0 ≤ M ≤ 106\n- 1 ≤ K ≤ 106\n- 1 ≤ ui, vi ≤ N\n- There is no road which goes from one city to itself. ie. ui ≠ vi.\n- There is at most one direct road between a pair of cities.\n- 0 ≤ Number of museums in each city ≤ 1000\n- Sum of N over all testcases in a file will be ≤ 1.5 * 106\n\n-----Subtasks-----\n- Subtask 1 (11 points): M = 0\n- Subtask 2 (21 points): Each city has at most two roads of which it is an end point. That is, for every i, there are at most two roads (u, v) in the input, such that u = i or v = i.\n- Subtask 3 (68 points): Original constraints.\n\n-----Example-----\nInput:\n3\n10 10 3\n1 3\n3 5\n5 1\n1 6\n6 2\n5 6\n2 5\n7 10\n4 7\n10 9\n20 0 15 20 25 30 30 150 35 20\n10 10 2\n1 3\n3 5\n5 1\n1 6\n6 2\n5 6\n2 5\n7 10\n4 7\n10 9\n20 0 15 20 25 30 30 150 35 20\n10 10 5\n1 3\n3 5\n5 1\n1 6\n6 2\n5 6\n2 5\n7 10\n4 7\n10 9\n20 0 15 20 25 30 30 150 35 20\n\nOutput:\n345\n240\n-1\n\n-----Explanation-----\nNotice that in all the three testcases, everything is the same, except for the value of K. The following figure represents the road map in these testcases. Each node denotes a city, with a label of the form \"n (m)\", where n is the city number, between 1 and N, and m is the number of museums in this city.  For example, the node with label \"5 (25)\" represents city 5, which has 25 museums.\n\nTestcase 1: Lavanya will first choose to fly to city 8. In the first month, they visit only that city, but they visit 150 museums.\nThen in the second month, Nikhil could choose to fly to city 3, and they visit the cities 1, 2, 3, 5 and 6, and visit 20 + 0 + 15 + 25 + 30 = 90 museums that month. Note that Nikhil could have instead chosen to fly to city 1 or 2 or 5 or 6, and they would all result in the same scenario.\nThen, Lavanya could choose city 7, and in the third month they will visit the cities 7, 4, 10 and 9. Note that Lavanya could have chosen to fly to city 4 or 10 or 9, and they would all result in the same scenario.\nIn total, they have visited 345 museums in the three months (which is in fact all the museums), and that is the answer.\nTestcase 2: It is same as the previous testcase, but now they have only 2 months. So they visit only 150 + 90 = 240 museums in total.\nTestcase 3: It is same as the previous testcase, but now they have 5 months of holidays. But sadly, they finish visiting all the cities within the first three months itself, and hence the answer is -1.", "starter_code": "", "test_cases": {"inputs": ["3\n10 10 3\n1 3\n3 5\n5 1\n1 6\n6 2\n5 6\n2 5\n7 10\n4 7\n10 9\n20 0 15 20 25 30 30 150 35 20\n10 10 2\n1 3\n3 5\n5 1\n1 6\n6 2\n5 6\n2 5\n7 10\n4 7\n10 9\n20 0 15 20 25 30 30 150 35 20\n10 10 5\n1 3\n3 5\n5 1\n1 6\n6 2\n5 6\n2 5\n7 10\n4 7\n10 9\n20 0 15 20 25 30 30 150 35 20"], "outputs": ["345\n240\n-1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "248d85c4323f8086706914ee472a24004ae97c5c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00926", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef likes problems related to learning new languages. He only knows first N letters of English alphabet. Also he explores all M-letter words formed by the characters he knows. Define cost for a given M-letter word S, cost(S) = P1, S1+P2, S2+...+PM, SM, where Pi, j is i, jth entry of matrix P. Sort all the words by descending cost, if costs are equal, sort them lexicographically. You need to find K-th M-letter word in Chef's order.\n\n-----Input-----\nFirst line contains three positive integer numbers N, M and K.\nNext M lines contains N integers per line, denoting the matrix P.\n\n-----Output-----\nOutput in a single line K-th M-letter in Chef's order.\n\n-----Constraints-----\n- 1 ≤ N ≤ 16 \n- 1 ≤ M ≤ 10 \n- 1 ≤ K ≤ NM\n- 0 ≤ Pi, j ≤ 109\n\n-----Subtasks-----\n- Subtask #1: (20 points) 1 ≤ K ≤ 10000\n- Subtask #2: (20 points) 1 ≤ M ≤ 5\n- Subtask #3: (60 points) Original constraints\n\n-----Example-----\nInput:2 5 17\n7 9\n13 18\n10 12\n4 18\n3 9\n\nOutput:aaaba", "starter_code": "", "test_cases": {"inputs": ["2 5 17\n7 9\n13 18\n10 12\n4 18\n3 9"], "outputs": ["aaaba"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "43cbeadb487a5221f83899581803fc85262a4e2d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00931", "original_id": null, "source": "apps", "domain": "code", "problem": "A plot of land can be described by $M x N$ dots such that horizontal and vertical distance between any two dots is 10m.\nMr. Wolf would like to build a house in the land such that all four sides of the house are equal. Help Mr. Wolf to find the total number of unique positions where houses can be built. Two positions are different if and only if their sets of four dots are different.\n\n-----Input:-----\nThe first line of the input gives the number of test cases, $T$. $T$ lines follow. Each line has two integers $M$ and $N$: the number of dots in each row and column of the plot, respectively.\n\n-----Output:-----\nFor each test case, output one single integer containing the total number of different positions where the house can be built.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$\n- $2 \\leq M \\leq 10^9$\n- $2 \\leq N \\leq 10^9$\n\n-----Sample Input:-----\n4\n\n2 4\n\n3 4\n\n4 4\n\n1000 500  \n\n-----Sample Output:-----\n3\n\n10\n\n20\n\n624937395  \n\n-----EXPLANATION:-----\nMap 1\n\nMap 2\n\nMap 3", "starter_code": "", "test_cases": {"inputs": ["4\n2 4\n3 4\n4 4\n1000 500"], "outputs": ["3\n10\n20\n624937395"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b8c588b09f49c35a8e31c504b2085900af09c7c9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00936", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef likes prime numbers. However, there is one thing he loves even more. Of course, it's semi-primes! A semi-prime number is an integer which can be expressed as a product of two distinct primes. For example, $15 = 3 \\cdot 5$ is a semi-prime number, but $1$, $9 = 3 \\cdot 3$ and $5$ are not.\nChef is wondering how to check if an integer can be expressed as a sum of two (not necessarily distinct) semi-primes. Help Chef with this tough task!\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first and only line of each test case contains a single integer $N$.\n\n-----Output-----\nFor each test case, print a single line containing the string \"YES\" if it is possible to express $N$ as a sum of two semi-primes or \"NO\" otherwise.\n\n-----Constraints-----\n- $1 \\le T \\le 200$\n- $1 \\le N \\le 200$\n\n-----Example Input-----\n3\n30\n45\n62\n\n-----Example Output-----\nYES\nYES\nNO\n\n-----Explanation-----\nExample case 1: $N=30$ can be expressed as $15 + 15 = (3 \\cdot 5) + (3 \\cdot 5)$.\nExample case 2: $45$ can be expressed as $35 + 10 = (5 \\cdot 7) + (2 \\cdot 5)$.\nExample case 3: $62$ cannot be expressed as a sum of two semi-primes.", "starter_code": "", "test_cases": {"inputs": ["3\n30\n45\n62\n"], "outputs": ["YES\nYES\nNO"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "4aadd174f61ce70c7250e0026a43ed63388fffd9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00941", "original_id": null, "source": "apps", "domain": "code", "problem": "So the Chef has become health conscious and is now lifting weights at the gym. But its his first time so the trainer gives him a simple job to do. \n\nHe has been given a weight lifting rod and N heavy weights, each weighing 20, 21, .... , 2n-1. He has to stick each of the \"N\" weights on the rod, one after another, in such a way that the right side is never heavier than the left side. At each step he chooses one of the weights that has not yet been fixed on the rod, and fix it on either the left side of the rod or the right, until all of the weights have been placed.\n\nNow help the chef and find out, in how many ways the chef can accomplish this?\n\n-----Input-----\nFirst line of input contains an integer T, the number of test cases. Then T test cases follow. Each line of test case contains one integer, N denoting the number of weights\n\n-----Output-----\nThe output contains T lines, each containing an integer denoting all possible combinations\n\n-----Example-----\nInput:\n3\n2\n5\n18\n\nOutput:\n3\n945\n221643095476699771875", "starter_code": "", "test_cases": {"inputs": ["3\n2\n5\n18"], "outputs": ["3\n945\n221643095476699771875"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "85ed53230699f7e863d5d9343b79e83f48e04d74", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00946", "original_id": null, "source": "apps", "domain": "code", "problem": "In the year 4242, the language Haskell has evolved so much that it has become an AI. It can solve very challenging problems, in very little time. Humanity is worried that Haskell will take over the world. All hopes remain tied to the Competitive Programming community as they are the expert in shaving milliseconds off code runtime. Haskell creators have found one particular task that if solved faster than Haskell itself, can be used to hack into Haskell's codebase and thus defeat it. The exact details of the task are as follows,\n\n\n\" Calculate the sum, S(N, K) = , for Q queries. Here Fi is ith Fibonacci number defined as: Fi = i if i = 0 or 1 and Fi = Fi-1 + Fi-2 if i >= 2. \"\n\n\nYou being a member of the Competitive Programming community are encouraged to make a submission to this task.\n\n-----Input-----\n\nThe first line contains a single integer Q, the number of queries.\n\nEach of the next Q lines contain two integers each, Ni and Ki.\n\n-----Output-----\n\nOutput Q lines with one integer each. The ith line should contain the value S(Ni, Ki).\n\n-----Constraints-----\n- 1 <= Q <= 5*104\n- 1 <= N <= 1018\n- 1 <= K <= 1018\n\n-----Example-----\nInput:\n1\n1 1\nOutput:\n1", "starter_code": "", "test_cases": {"inputs": ["1\n1 1"], "outputs": ["1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "bede5a1b0d84a0c411ee646e031d9d41d9c5aef4", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00951", "original_id": null, "source": "apps", "domain": "code", "problem": "Sunita has lots of tasks pending and she has no time to complete.  She needs your help and wants you complete the task.\nYou are given a list of integers and two values $N$ and $K$ $-$ the size of array of integers and the numbers of partitions to be made respectively.\nYou have to partition the list of integers without changing the order of elements ,into exactly $K$ parts. \nCalculate Greatest Common Divisor of all $K$ partition and sum up the gcd values for each partition.\nMaximize the sum obtained. \nCan you help Sunita ? \n\n-----Input:-----\n- First line will contain $T$, number of test cases. Then the test cases follow. \n- Each test case contains of a single line of input, two integers $N, K$. \n- Next line contains $N$ integers $-$ the list of integers.\n\n-----Output:-----\nFor each test case, output in a single line integer $-$ the maximal result.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$\n- $1 \\leq N, K \\leq 250$\n- $1 \\leq K \\leq N$\n- $1 \\leq A[i] \\leq 1e5$\n\n-----Sample Input:-----\n1\n4 2\n5 6 3 2\n\n-----Sample Output:-----\n6\n\n-----EXPLANATION:-----\n[5] [6 3 2] is the best partition [5 + GCD(6,3,2)] = 6", "starter_code": "", "test_cases": {"inputs": ["1\n4 2\n5 6 3 2"], "outputs": ["6"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "cb238ceb28749a082b7de71df7f92095e78d6a87", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00956", "original_id": null, "source": "apps", "domain": "code", "problem": "Due to the COVID pandemic, there has been an increase in the number of cases if a hospital. The management has decided to clear a large square area for the patients and arrange for beds. But the beds can't be too near to each other.\nThe area is of dimension $N$ x $N$\nThe whole area is already divided into blocks. $1$ means there's a bed in the block, $0$ denotes there isn't. Note, beds placed on consecutive diagonal blocks are safe.\nThis is a SAFE example:\n1 0\n0 1\nThis is an UNSAFE example:\n0 1 1\n0 0 0\n1 0 0\nTo avoid spreading the virus even further, you have to make sure no two adjacent blocks have beds in them. This is done to maintain distance between beds.\nReturn an output of \"SAFE\" if you find the workers have arranged the beds with due consideration to the distance needed. Return \"UNSAFE\" otherwise.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Next line contains $N$.\n- Next $N$ lines will contain $N$ number of space-separated integers $Ai$ which make denote the beds in the area.\n\n-----Output:-----\nFor each test case, output in a single line whether the total arrangement is \"SAFE\" or \"UNSAFE\". Even if there's a single unsafe bed in the whole area, report the whole area as \"UNSAFE\".\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$\n- $0 \\leq Ai \\leq 1$\n- $2 \\leq N \\leq 100$\n\n-----Subtasks-----\n- 30 points : $1 \\leq N \\leq 7$\n- 70 points : Original constraints\n\n-----Sample Input:-----\n2\n4\n1 0 1 0\n0 0 0 1\n0 1 0 0\n1 0 0 1\n4\n1 0 1 0\n0 0 0 0\n1 0 1 1\n0 1 0 0\n\n-----Sample Output:-----\nSAFE\nUNSAFE\n\n-----EXPLANATION:-----\nBeds placed on blocks diagonally are not a problem.", "starter_code": "", "test_cases": {"inputs": ["2\n4\n1 0 1 0\n0 0 0 1\n0 1 0 0\n1 0 0 1\n4\n1 0 1 0\n0 0 0 0\n1 0 1 1\n0 1 0 0"], "outputs": ["SAFE\nUNSAFE"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "98e838a874a12bc6858e79a4f0c142c8d36e0a49", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00961", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a weighted undirected graph consisting of n$n$ nodes and m$m$ edges. The nodes are numbered from 1$1$ to n$n$. The graph does not contain any multiple edges or self loops.\nA walk W$W$ on the graph is a sequence of vertices (with repetitions of vertices and edges allowed) such that every adjacent pair of vertices in the sequence is an edge of the graph. We define the cost of a walk W$W$, Cost(W)$Cost(W)$, as the maximum over the weights of the edges along the walk. \nYou will be given q$q$ queries. In each query, you will be given an integer X$X$.\n\nYou have to count the number of different walks W$W$ of length 4$4$ such that Cost(W)$Cost(W)$ = X$X$.\n\nTwo walks are considered different if they do not represent the same edge sequence.\n\n-----Input:-----\n- First line contains 2 integers : the number of nodes n$n$ and number of edges m$m$.\n- Next m$m$ lines each describe u$u$, v$v$ and w$w$, describing an edge between u$u$ and v$v$ with weight w$w$.\n- Next line contains q$q$, the number of queries.\n- Next q$q$ lines each describe an integer X$X$ - the cost of the walk in the query.\n\n-----Output:-----\nFor each query, output in a single line the number of different possible walks.\n\n-----Constraints-----\n- 1≤n≤100$1 \\leq n \\leq 100$\n- 1≤m≤n(n−1)2$1 \\leq m \\leq \\frac{n (n-1)}{2}$\n- 1≤u,v≤n$1 \\leq u, v \\leq n$\n- 1≤w≤100$1 \\leq w \\leq 100$\n- 1≤q≤100$1 \\leq q \\leq 100$\n- 1≤X≤100$1 \\leq X \\leq 100$\n\n-----Sample Input:-----\n3 3\n1 2 1\n2 3 2\n3 1 3\n3\n1\n2\n3\n\n-----Sample Output:-----\n2\n10\n36\n\n-----EXPLANATION:-----\nFor X=2$X = 2$, all possible 10$10$ walks are listed below :\n- 1 -> 2 -> 1 -> 2 -> 3\n- 1 -> 2 -> 3 -> 2 -> 1\n- 1 -> 2 -> 3 -> 2 -> 3\n- 2 -> 1 -> 2 -> 3 -> 2\n- 2 -> 3 -> 2 -> 1 -> 2\n- 2 -> 3 -> 2 -> 3 -> 2\n- 3 -> 2 -> 1 -> 2 -> 1\n- 3 -> 2 -> 1 -> 2 -> 3\n- 3 -> 2 -> 3 -> 2 -> 1\n- 3 -> 2 -> 3 -> 2 -> 3", "starter_code": "", "test_cases": {"inputs": ["3 3\n1 2 1\n2 3 2\n3 1 3\n3\n1\n2\n3"], "outputs": ["2\n10\n36"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "ea9b607880256b69f9af7e32c4f214530a328196", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00966", "original_id": null, "source": "apps", "domain": "code", "problem": "The chef is trying to solve some series problems, Chef wants your help to code it. Chef has one number N. Help the chef to find N'th number in the series.\n0, 1, 5, 14, 30, 55 …..\n\n-----Input:-----\n- First-line will contain $T$, the number of test cases. Then the test cases follow. \n- Each test case contains a single line of input, one integer $N$. \n\n-----Output:-----\nFor each test case, output as the pattern.\n\n-----Constraints-----\n- $1 \\leq T \\leq 10^4$\n- $1 \\leq N \\leq 10^4$\n\n-----Sample Input:-----\n3\n1\n7\n8\n\n-----Sample Output:-----\n0\n91\n140", "starter_code": "", "test_cases": {"inputs": ["3\n1\n7\n8"], "outputs": ["0\n91\n140"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "5a5e0670c2dcee539d15f8ba5c929b94cc71a042", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00971", "original_id": null, "source": "apps", "domain": "code", "problem": "There are $N$ cars (numbered $1$ through $N$) on a circular track with length $N$. For each $i$ ($2 \\le i \\le N$), the $i$-th of them is at a distance $i-1$ clockwise from car $1$, i.e. car $1$ needs to travel a distance $i-1$ clockwise to reach car $i$. Also, for each valid $i$, the $i$-th car has $f_i$ litres of gasoline in it initially.\nYou are driving car $1$ in the clockwise direction. To move one unit of distance in this direction, you need to spend $1$ litre of gasoline. When you pass another car (even if you'd run out of gasoline exactly at that point), you steal all its gasoline. Once you do not have any gasoline left, you stop.\nWhat is the total clockwise distance travelled by your car? \n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains a single integer $N$.\n- The second line contains $N$ space-separated integers $f_1, f_2, \\ldots, f_N$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the total clockwise distance travelled.\n\n-----Constraints-----\n- $1 \\le T \\le 100$\n- $1 \\le N \\le 100$\n- $0 \\le f_i \\le 100$ for each valid $i$\n\n-----Subtasks-----\nSubtask #1 (100 points): original constraints\n\n-----Example Input-----\n3\n5\n3 0 0 0 0\n5\n1 1 1 1 1\n5\n5 4 3 2 1\n\n-----Example Output-----\n3\n5\n15", "starter_code": "", "test_cases": {"inputs": ["3\n5\n3 0 0 0 0\n5\n1 1 1 1 1\n5\n5 4 3 2 1"], "outputs": ["3\n5\n15"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "506e705b20157b6ede626d7c635271d5b27660f7", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00976", "original_id": null, "source": "apps", "domain": "code", "problem": "A printer – who still uses moveable type – is preparing to print a set of pages for a book. These pages are to be numbered, as usual. The printer needs to know how many instances of each decimal digit will be required to set up the page numbers in the section of the book to be printed.\n\nFor example, if pages 10, 11, 12, 13, 14 and 15 are to be printed, computing the number of digits is relatively simple: just look at the page numbers that will appear, and count the number of times each digit appears. The digit 0 appears only once, the digit 1 appears 7 times, the digits 2, 3, 4 and 5 each appear once, and 6, 7, 8 and 9 don’t appear at all.\n\nYour task in this problem is to provide the printer with the appropriate counts of the digits. You will be given the numbers of the two pages that identify the section of the book to be printed. You may safely assume that all pages in that section are to be numbered, that no leading zeroes will be printed, that page numbers are positive, and that no page will have more than three digits in its page number.\n\n-----Input-----\n\nThere will be multiple cases to consider. The input for each case has two integers, A and B, each of which is guaranteed to be positive. These identify the pages to be printed. That is, each integer P between A and B, including A and B, is to be printed. A single zero will follow the input for the last case.\n\n-----Output-----\n\nFor each input case, display the case number (1, 2, …) and the number of occurrences of each decimal digit 0 through 9 in the specified range of page numbers. Display your results in the format shown in the examples below.\n\n-----Example-----\nInput:\n\n10 15\n912 912\n900 999\n0\n\nOutput:\n\nCase 1: 0:1 1:7 2:1 3:1 4:1 5:1 6:0 7:0 8:0 9:0\nCase 2: 0:0 1:1 2:1 3:0 4:0 5:0 6:0 7:0 8:0 9:1\nCase 3: 0:20 1:20 2:20 3:20 4:20 5:20 6:20 7:20 8:20 9:120", "starter_code": "", "test_cases": {"inputs": ["10 15\n912 912\n900 999\n0\n\n"], "outputs": ["Case 1: 0:1 1:7 2:1 3:1 4:1 5:1 6:0 7:0 8:0 9:0\nCase 2: 0:0 1:1 2:1 3:0 4:0 5:0 6:0 7:0 8:0 9:1\nCase 3: 0:20 1:20 2:20 3:20 4:20 5:20 6:20 7:20 8:20 9:120"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "50c3a5dc27a687570dc7b877d995d55ca0872d64", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00981", "original_id": null, "source": "apps", "domain": "code", "problem": "One day, Chef prepared D brand new dishes. He named the i-th dish by a string Si. After the cooking, he decided to categorize each of these D dishes as special or not.\n\nA dish Si is called special if it's name (i.e. the string Si) can be represented in the form of a double string by removing at most one (possibly zero) character from it's name from any position. \n\nA string is called a double string if it can be represented as a concatenation of two identical, non-empty strings. \ne.g. \"abab\" is a double string as it can be represented as \"ab\" + \"ab\" where + operation denotes concatenation. \nSimilarly, \"aa\", \"abcabc\" are double strings whereas \"a\", \"abba\", \"abc\" are not.\n\n-----Input-----\n- First line of the input contains an integer D denoting the number of dishes prepared by Chef on that day.\n- Each of the next D lines will contain description of a dish. \n\t\n- The i-th line contains the name of i-th dish Si.\n\t\n\n-----Output-----\nFor each of the D dishes, print a single line containing \"YES\" or \"NO\" (without quotes) denoting whether the dish can be called as a special or not.\n\n-----Constraints-----\n- 1 ≤ D ≤ 106\n- 1 ≤ |Si| ≤ 106.\n- Each character of string Si will be lower case English alphabet (i.e. from 'a' to 'z').\n\n-----Subtasks-----\nSubtask #1 : (20 points)\n- Sum of |Si| in an input file doesn't exceed 2 * 103\n\nSubtask 2 : (80 points) \n- Sum of |Si| in an input file doesn't exceed 2 * 106\n\n-----Example-----\nInput:\n3\naba\nabac\nabcd\n\nOutput:\nYES\nNO\nNO\n\n\n-----Explanation-----\nExample case 1.\nWe can remove the character at position 1 (0-based index) to get \"aa\" which is a double string. Hence, it is a special dish.\n\nExample case 2.\nIt is not possible to remove the character at any of the position to get the double string. Hence, it is not a special dish.", "starter_code": "", "test_cases": {"inputs": ["3\naba\nabac\nabcd"], "outputs": ["YES\nNO\nNO"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "398d7207385a0c6a6f780a1eac320611ae07284b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00986", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef is very organised in whatever he does and likes to maintain statistics of his work. Chef has expertise in web development and hence is a regular contributor on a forum. Chef sometimes makes multiple contributions in a single day.. Each day chef makes at least 1 contribution he is assigned a shade of green. The greater the number of contribution in a single day the darker shade of green he gets assigned and vice versa. Your job is to find out the number of days chef is assigned a same shade of green and print the number of times chef is assigned a unique shade of green.\n\n-----INPUT-----\nThe first line of input contains an integer T denoting the number of test cases. T test cases follow.\n\nThe first line of each test case contains an integer N denoting the number of days chef has contributed towards the forum.\n\nThe next line contains N spaced integers the number of contributions chef has made if he has made any.\n\n-----OUTPUT-----\n\nThe output will contain numbers on separate lines that show the number of individual green shades chef has earned in ascending order of intensity of the shades of green.\n\n-----CONSTRAINTS-----\n1 <= T <= 25\n\n5 <= N <= 50\n\n1 <= Ai <= 50\n\n-----EXAMPLE-----Input:\n\n1\n\n7\n\n20 6 5 3 3 1 1\nOutput:\n\n1: 2\n\n3: 2\n\n5: 1\n\n6: 1\n\n20: 1", "starter_code": "", "test_cases": {"inputs": ["1\n7\n20 6 5 3 3 1 1"], "outputs": ["1: 2\n3: 2\n5: 1\n6: 1\n20: 1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d4b3430aeef1fa652217d056d1cb84ead4c35e57", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00991", "original_id": null, "source": "apps", "domain": "code", "problem": "A squarer is a simple and convenient device. You give it some positive integer X and it calculates its square.\nLeha is implementing a module of this device which is responsible for squaring the numbers consisting of multiple repetitions of one digit. But it turned out that it's not as simple as he thought.\nPlease help him now!\n\n-----Input-----\nThe first line contains one integer T denoting the number of testcases. The descriptions of T test cases follow.\nEach of the following T lines contain 2 space-separated integers - N and D, respectively. It means that the number X in the corresponding testcase consists of the digit D repeated N times (in decimal representation).\n\n-----Output-----\nAs the answer can be very large, we ask you to output its hash which is computed in the following way:\nLet's consider the integer answer Y as a 0-indexed array starting from its leftmost digit. The hash function is calculated as:\np0*Y[0] + p1*Y[1] + ... + pM-1*Y[M-1] modulo 109 + 7 \nwhere M is the length of the array representation of Y and p equals 23.\n\n-----Constraints-----\n- 1 ≤ T ≤ 20\n- 1 ≤ D ≤ 9\n- Subtask 1 (16 points): 1 ≤ N ≤ 9\n- Subtask 2 (25 points): 1 ≤ N ≤ 100\n- Subtask 3 (27 points): 1 ≤ N ≤ 2 × 104\n- Subtask 4 (32 points): 1 ≤ N ≤ 106\n\n-----Example-----\nInput:3\n1 4\n3 6\n3 5\n\nOutput:139\n40079781\n32745632\n\n-----Explanation-----\nIn the first test case, X = 4 and Y = 16. Its hash equals 1*1 + 23*6 = 139.", "starter_code": "", "test_cases": {"inputs": ["3\n1 4\n3 6\n3 5"], "outputs": ["139\n40079781\n32745632"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "291d6bc4c275b8ade32d8ac77c860b357afa683a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-00996", "original_id": null, "source": "apps", "domain": "code", "problem": "You were strolling outside the restaurant at the end of the universe. On a metaspiral path you stumble upon a weird device which takes a three-digit number as input and processes it. The Hitchhiker's guide to the galaxy explains that it processes the input in the following manner: \n- Multiplies it with 13, followed by 11 and then 7          \n- Outputs all the distinct three-digit numbers possible from the digits of the new number (each digit can only be used once)          \nYour friend Zaphod is in a playful mood, and does the following with the device-           \n- Given a three-digit positive number $K$, he feeds it to the device for processing.          \n- He then takes the numbers it gives as output, and send each of them through the device and again collect all the numbers sent out.          \n- Repeats the above step $N$ times.          \nTo test your wit, he challenges you to find the number of distinct 3-digit numbers which the device outputs over the $N$ steps. Can you?\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow.\n- Each testcase contains of a single line of input, two integers $K, N$.\n\n-----Output:-----\nFor each testcase, output a single integer denoting the number of distinct 3-digit numbers which the device outputs over the $N$ steps.\n\n-----Constraints-----\n- $1 \\leq T \\leq 1000$ \n- $5 \\leq N \\leq 10^9$ \n- Each digit of $K$ is non-zero           \n\n-----Sample Input:-----\n1\n\n123 5         \n\n-----Sample Output:-----\n27", "starter_code": "", "test_cases": {"inputs": ["1\n123 5"], "outputs": ["27"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d845dc334dd86be8a50fe9f3e901a2cca7ebf07f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01001", "original_id": null, "source": "apps", "domain": "code", "problem": "-----General Statement:-----\nGiven the actual high and low temperatures for the day and the normal high and low temperatures for that day, calculate the average difference from normal.\n\n-----Input:-----\nThe first line of the data set for this problem is an integer that represents the number of data sets that follow. Each data set is on a separate line and consists of today’s high, today’s low, normal high, and normal low – in that order.\n\n-----Output:-----\nIf the average difference is negative, do not output the negative sign (-).\nOutput the amount of deviation from normal, followed by the words\nDEGREE(S) ABOVE NORMAL, or by the words\nDEGREE(S) BELOW NORMAL.\nRound to 1 decimal place. A trailing zero is required if the average is an integer.\nThe output is to be formatted exactly like that for the sample output given below.\n\n-----Assumptions:-----\nTemperatures are in the range –15..100 degrees.\nThe average temperature difference will not be zero.\n\n-----Discussion:-----\nDetermine the average of the difference of the high temperatures and the difference of the low temperatures.\n\n-----Sample Input:-----\n3\n75 45 78 40\n50 32 45 30\n56 48 62 45\n\n-----Sample Output:-----\n1.0 DEGREE(S) ABOVE NORMAL\n3.5 DEGREE(S) ABOVE NORMAL\n1.5 DEGREE(S) BELOW NORMAL", "starter_code": "", "test_cases": {"inputs": ["3\n75 45 78 40\n50 32 45 30\n56 48 62 45"], "outputs": ["1.0 DEGREE(S) ABOVE NORMAL\n3.5 DEGREE(S) ABOVE NORMAL\n1.5 DEGREE(S) BELOW NORMAL"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "970083e3870770de6f935bfe9ae4065db96b9f94", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01006", "original_id": null, "source": "apps", "domain": "code", "problem": "On each of the following $N$ days (numbered $1$ through $N$), Chef is planning to cook either pizza or broccoli. He wrote down a string $A$ with length $N$, where for each valid $i$, if the character $A_i$ is '1', then he will cook pizza on the $i$-th day, while if $A_i$ is '0', he will cook broccoli on this day.\nChefu, his son, loves pizza but hates broccoli ― just like most kids. He wants to select a substring of $A$ with length $K$ and change each character '0' in this substring to '1'. Afterwards, let's define pizza time as the maximum number of consecutive days where Chef will cook pizza. Find the maximum pizza time Chefu can achieve.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $K$. \n- The second line contains a string $A$ with length $N$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the maximum pizza time.\n\n-----Constraints-----\n- $1 \\le T \\le 1,000$\n- $1 \\le K \\le N \\le 10^5$\n- $A$ contains only characters '0' and '1'\n- the sum of $N$ over all test cases does not exceed $10^6$\n\n-----Subtasks-----\nSubtask #1 (50 points):\n- $N \\le 10^3$\n- the sum of $N$ over all test cases does not exceed $10^4$\nSubtask #2 (50 points): original constraints\n\n-----Example Input-----\n2\n13 2\n0101110000101\n6 3\n100001\n\n-----Example Output-----\n5\n4\n\n-----Explanation-----\nExample case 1: Chefu can choose the substring $A[2, 3]$ = \"10\", and change the third character of $A$ to '1'. Then, the pizza time is $5$ days: from day $2$ to day $6$.\nExample case 2: Chefu can choose the substring $A[2, 4]$ = \"000\". Then, the pizza time is $4$ days: from day $1$ to day $4$.", "starter_code": "", "test_cases": {"inputs": ["2\n13 2\n0101110000101\n6 3\n100001"], "outputs": ["5\n4"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "09d357e2c554adce2d834a9bcc0b15dd55eb8ee0", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01011", "original_id": null, "source": "apps", "domain": "code", "problem": "Our chef has recently opened a new restaurant with a unique style. The restaurant is divided into K compartments (numbered from 1 to K) and each compartment can be occupied by at most one customer. \nEach customer that visits the restaurant has a strongly preferred compartment p (1 ≤ p ≤ K), and if that compartment is already occupied, then the customer simply leaves. Now obviously, the chef wants to maximize the total number of customers that dine at his restaurant and so he allows (or disallows) certain customers so as to achieve this task. You are to help him with this. \nGiven a list of N customers with their arrival time, departure time and the preferred compartment, you need to calculate the maximum number of customers that can dine at the restaurant. \n\n-----Input-----\nThe first line contains an integer T denoting the number of test cases. Each of the next T lines contains two integers N and  K , the number of customers that plan to visit the chef's restaurant and the number of compartments the restaurant is divided into respectively. Each of the next N lines contains three integers si, fi and pi , the arrival time, departure time and the strongly preferred compartment of the ith customer respectively.  \n\nNote that the ith customer wants to occupy the pith compartment from [si, fi)  i.e the ith customer leaves just before   fi  so that another customer can occupy that compartment from   fi  onwards.\n\n-----Output-----\nFor every test case, print in a single line the maximum number of customers that dine at the restaurant.\n\n-----Constraints-----\n-  1 ≤  T ≤   30 \n-  0  ≤ N  ≤  105 \n-  1  ≤  K  ≤  109 \n-  0  ≤  si < fi ≤   109 \n-  1  ≤  pi  ≤  K  \n\n-----Example-----\nInput:\n2\n3 3\n1 3 1\n4 6 2\n7 10 3\n4 2\n10 100 1\n100 200 2\n150 500 2\n200 300 2\n\nOutput:\n3\n3\n\n-----Explanation-----\nExample case 1.\n\nAll three customers want different compartments and hence all 3 can be accommodated.\n\nExample case 2.\n\nIf we serve the 1st, 2nd and 4th customers, then we can get a maximum of 3.", "starter_code": "", "test_cases": {"inputs": ["2\n3 3\n1 3 1\n4 6 2\n7 10 3\n4 2\n10 100 1\n100 200 2\n150 500 2\n200 300 2"], "outputs": ["3\n3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "c3276def9fdf430fd5ac644b9438fe2abbbe8a45", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01016", "original_id": null, "source": "apps", "domain": "code", "problem": "You have initially a string of N characters, denoted by A1,A2...AN. You have to print the size of the largest subsequence of string A such that all the characters in that subsequence are distinct ie. no two characters in that subsequence should be same.\n\nA subsequence of string A is a sequence that can be derived from A by deleting some elements  and without changing the order of the remaining elements.\n\n-----Input-----\nFirst line contains T, number of testcases. Each testcase consists of a single string in one line. Each character of the string will be a small alphabet(ie. 'a' to 'z').\n\n-----Output-----\nFor each testcase, print the required answer in one line.\n\n-----Constraints-----\n- 1 ≤ T ≤ 10\n- Subtask 1 (20 points):1 ≤ N ≤ 10\n- Subtask 2 (80 points):1 ≤ N ≤ 105\n\n-----Example-----\nInput:\n2\nabc\naba\n\nOutput:\n3\n2\n\n-----Explanation-----\nFor first testcase, the whole string is a subsequence which has all distinct characters.\n\nIn second testcase, the we can delete last or first 'a' to get the required subsequence.", "starter_code": "", "test_cases": {"inputs": ["2\nabc\naba"], "outputs": ["3\n2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2c29c1222d1c90c1969647ba406927b98236c7d0", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01021", "original_id": null, "source": "apps", "domain": "code", "problem": "There are $N$ sabotages available in the game Among Us, initially all at level $0$. \n$N$ imposters are allotted the task to upgrade the level of the sabotages. \nThe $i^{th}$ imposter $(1 \\leq i \\leq N)$ increases the level of $x^{th}$ sabotage $(1 \\leq x \\leq N)$ by one level  if $gcd(i,x)=i$.\nYou need to find the number of sabotages at LEVEL 5 after all the imposters have completed their tasks.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single line of input, one integer $N$. \n\n-----Output:-----\nFor each testcase, output in a single line the number of sabotages at LEVEL 5.\n\n-----Constraints-----\n- $1 \\leq T \\leq 10^5$\n- $1 \\leq N \\leq 10^{18}$\n\n-----Sample Input:-----\n1\n6\n\n-----Sample Output:-----\n0\n\n-----EXPLANATION:-----\nThe $1^{st}$ sabotage is at level $1$, the $2^{nd}$, $3^{rd}$ and $5^{th}$ sabotages are at level $2$, the $4^{th}$ sabotage is at level $3$ and the $6^{th}$ sabotage is at level $4$.\nNone of them reach level $5$. Hence the output is $0$.", "starter_code": "", "test_cases": {"inputs": ["1\n6"], "outputs": ["0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "3a362a7099cfba951d1d1d73860a4f53af317c2a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01026", "original_id": null, "source": "apps", "domain": "code", "problem": "Raj loves to listen to songs in his free time. It’s his birthday tomorrow and his friend Neelansh wants his gift to be the most unique. Being great at making music, he decides to produce a song for him. However, Raj likes songs according to their beauty. He determines the beauty of the song as the number of times all the octave musical tones are completed in ascending order.\n\nHe begins with a jumbled tone of length N and numbers each octave tone as 1,2,3….8.\n\nNeelansh wants to maximize the beauty of the song but since he uses the trial version of the software,\n- He cannot change the size of N.\n- He cannot introduce any new tone, but can choose any two tones and swap their positions\n\nHowever, Neelansh just received a mail that he needs to submit all his pending assignments by tomorrow. He has tons of assignments left to do, but he doesn’t want to spoil the idea of his gift. Can you help him? \n\n-----INPUT-----\n- The first line contains a single integer T- the number of test cases  \n- The first line of each test case contains a single integer N- the length of the song  \n- The second line contains N- space separated integers ai,  ai+1,.....aN \n\n-----OUTPUT-----\nFor each test case, print a single line containing one integer- the maximum possible beauty of the song  \n\n-----CONSTRAINTS-----\n1<=T<=102\n1<=N<=105\n1<=a<=8\n\n-----EXAMPLE INPUT-----\n2\n\n8\n\n1 2 3 4 5 6 7 8\n\n16\n\n1 2 1 2 3 3 4 4 5 5 6 6 7 8 7 8\n\n-----EXAMPLE OUTPUT-----\n1\n\n2", "starter_code": "", "test_cases": {"inputs": ["2\n8\n1 2 3 4 5 6 7 8\n16\n1 2 1 2 3 3 4 4 5 5 6 6 7 8 7 8"], "outputs": ["1\n2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "65e6859c16a0206388108b075eba1741f200d96b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01031", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef is operating a slush machine. The machine produces slush drinks with $M$ flavors (numbered $1$ through $M$); for each valid $i$, the maximum number of drinks with flavour $i$ the machine can produce is $C_i$.\nChef expects $N$ customers to come buy slush drinks today. The customers are numbered $1$ through $N$ in the order in which they buy the drinks. For each valid $i$, the favorite flavour of the $i$-th customer is $D_i$ and this customer is willing to pay $F_i$ units of money for a drink with this flavour, or $B_i$ units of money for a drink with any other flavuor. Whenever a customer wants to buy a drink:\n- if it is possible to sell this customer a drink with their favourite flavour, Chef must sell them a drink with this flavour\n- otherwise, Chef must sell this customer a drink, but he may choose its flavour\nChef wants to make the maximum possible profit. He is asking you to help him decide the flavours of the drinks he should sell to the customers in order to maximise the profit.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $M$.\n- The second line contains $M$ space-separated integers $C_1, C_2, \\ldots, C_M$.\n- $N$ lines follow. For each valid $i$, the $i$-th of these lines contains three space-separated integers $D_i$, $F_i$ and $B_i$.\n\n-----Output-----\nFor each test case, print two lines:\n- The first of these lines should contain a single integer — the maximum profit.\n- The second line should contain $N$ space-separated integers denoting the flavours of the drinks Chef should sell, in this order.\nIf there are multiple solutions, you may find any one.\n\n-----Constraints-----\n- $1 \\le T \\le 1,000$\n- $2 \\le N, M \\le 10^5$\n- $1 \\le D_i \\le M$ for each valid $i$\n- $1 \\le C_i \\le N$ for each valid $i$\n- $1 \\le B_i < F_i \\le 10^9$ for each valid $i$\n- $C_1+C_2+\\ldots+C_M \\ge N$\n- the sum of $N$ over all test cases does not exceed $10^6$\n- the sum of $M$ over all test cases does not exceed $10^6$\n\n-----Example Input-----\n1\n5 3\n1 2 3\n2 6 3\n2 10 7\n2 50 3\n1 10 5\n1 7 4\n\n-----Example Output-----\n33\n2 2 3 1 3", "starter_code": "", "test_cases": {"inputs": ["1\n5 3\n1 2 3\n2 6 3\n2 10 7\n2 50 3\n1 10 5\n1 7 4"], "outputs": ["33\n2 2 3 1 3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "5b47fd2a159fcae5ec38b8ab3d7c46732f6740f2", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01036", "original_id": null, "source": "apps", "domain": "code", "problem": "After the hundred years of war started by the Fire Nation, its time for the Water Tribes to bring it to an end. Avatar asked Sokka to go to the Southern WarZone from The Northern WarZone and gave him some money in a bag for his journey. Sokka has the World Map to guide him during his journey . The World Map is described as a $N$x$N$ grid where the Northern WarZone is denoted by $(0,0)$ and the Southern WarZone is denoted by $(N-1,N-1)$. Each location on the world map is denoted in a similar way by two integers r and c. For each location having:  \n- $r = c$ denotes neutral land ( $(0,0)$ and $(N-1,N-1)$ also come under this category)       \n- $r < c$ denotes the land under the rule of Water Tribes     \n- $r > c$ denotes the land under the rule of Fire Kingdom   \nBeing wise Sokka travels only from one location to any other valid location (by valid location we mean a location which exists on the world map grid i.e. for that location $0 \\leq r < N$ and $0 \\leq c < N$ ) just to the right $(r,c+1)$ or below $(r+1,c)$ the current location randomly. Due to the times of war , Sokka has to pay one coin  each time he transitions from one nation to another. Here a transition is counted when Sokka is in Water Tribe land and moves to Fire Nation Land crossing the neutral land or vice versa .The first move is obviously never counted as a transition. Moreover , the coin is to be payed exactly once for one such transition (eg. if he makes this transition k times he has to pay k coins).  \nThe initial number of coins Sokka has is $2*N$. The probability that the coins he has when he reaches his destination is lesser than the number of coins he started his journey with can be expressed as a fraction $P/Q$, where P and Q are integers $(P \\geq 0, Q > 0)$  and Q is co-prime with $(10^9)+7$. You should compute $P/Q$ modulo $(10^9)+7$ for $T$ values of $N$.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single line of input, one integer $N$, the size of the world map grid. \n\n-----Output:-----\nFor each testcase, output in a single line , the Probability modulo (10^9)+7.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100000$\n- $2 \\leq N \\leq 10^9$\n\n-----Sample Input:-----\n2    \n\n5\n\n2    \n\n-----Sample Output:-----\n200000002     \n\n0  \n\n-----EXPLANATION:-----\nFor N=2, there is no possible path in which Sokka has to spend money, so the final number of coins in the bag is not lesser than the initial amount.", "starter_code": "", "test_cases": {"inputs": ["2\n5\n2"], "outputs": ["200000002\n0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "21aa7948690de82e967faee6ca844215c89238f3", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01041", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given an array $A$ of $N$ positive and pairwise distinct integers. \nYou can permute the elements in any way you want. \nThe cost of an ordering $(A_1, A_2, \\ldots, A_N)$ is defined as $ (((A_1 \\bmod A_2) \\bmod A_3)......) \\bmod A_N$ where $X \\bmod Y$ means the remainder when $X$ is divided by $Y$. \nYou need to find the maximum cost which can be attained through any possible ordering of the elements.\n\n-----Input:-----\n- The first line contains $T$ denoting the number of test cases.\n- The first line of each testcase contains a single integer $N$. \n- The second line of each testcase contains $N$ space-separated integers, the elements of $A$. \n\n-----Output:-----\n- For each testcase, output the maximum possible cost in a new line. \n\n-----Constraints-----\n- $1 \\leq T \\leq 5*10^5$\n- $2 \\leq N \\leq 5*10^5$\n- $1 \\leq A_i  \\leq 10^9$\n- Sum of $N$ over all testcases is less than or equal to $10^6$\n- All elements in a single testcase are distinct.\n\n-----Subtasks-----\n- 100 points : Original constraints.\n\n-----Sample Input:-----\n1\n2\n7 12\n\n-----Sample Output:-----\n7\n\n-----Explanation:-----\nThe two possible ways to order the elements are [7, 12] and [12, 7]. In the first case, the cost is $7 \\bmod 12 = 7$ and in the second case the cost is $12 \\bmod 7 = 5$. Clearly the answer is 7.", "starter_code": "", "test_cases": {"inputs": ["1\n2\n7 12"], "outputs": ["7"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "716d17f05c83b4679d925cfa57b375627b1378ec", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01046", "original_id": null, "source": "apps", "domain": "code", "problem": "Cheffina challanges chef to rearrange the given array as arr[i] > arr[i+1] < arr[i+2] > arr[i+3].. and so on…, i.e. also arr[i] < arr[i+2] and arr[i+1] < arr[i+3] and arr[i] < arr[i+3] so on.. Chef accepts the challenge, chef starts coding but his code is not compiling help him to write new code.\n\n-----Input:-----\n- First-line will contain $T$, the number of test cases. Then the test cases follow. \n- Each test case contains two lines of input, First $N$ as the size of the array. \n- N space-separated distinct integers.\n\n-----Output:-----\nFor each test case, output in a single line answer given to the Chefffina.\n\n-----Constraints-----\n- $1 \\leq T \\leq 10$\n- $1 \\leq N \\leq 10^5$\n- $1 \\leq arr[i] \\leq 10^5$\n\n-----Sample Input:-----\n2\n4\n4 1 6 3\n5\n4 5 1 6 3\n\n-----Sample Output:-----\n3 1 6 4\n3 1 5 4 6", "starter_code": "", "test_cases": {"inputs": ["2\n4\n4 1 6 3\n5\n4 5 1 6 3"], "outputs": ["3 1 6 4\n3 1 5 4 6"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "3e226341cd40e5e31c0b5827a603704f8abcc444", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01051", "original_id": null, "source": "apps", "domain": "code", "problem": "Mia is working as a waitress at a breakfast diner. She can take up only one shift from 6 shifts a day i.e. from 10 am to 4 pm. She needs to save 300$ after completion of the month. She works only for $D$ days in the month. She estimates that she gets her highest tip in the first shift and the tip starts decreasing by 2% every hour as the day prolongs. She gets a minimum wage of $X$ $ for every shift. And her highest tip in the first shift is $Y$ $. Determine whether Mia will be able to save 300$ from her wages and tips after working $D$ days of the month. If she can, print YES, else print NO.\n\n-----Constraints-----\n- 8 <= D <=30\n- 7 <= X <=30\n- 4 <= Y <= 20\n\n-----Input:-----\n- First line has three parameters $D$, $X$ and $Y$ i.e. number of days worked, minimum wage and highest tip.\n- Second line contains D integers indicating her shifts every $i$-th day she has worked.\n\n-----Output:-----\n- Print YES, if Mia has saved 300$, NO otherwise.\n\n-----Sample Input:-----\n9 17 5\n1 3 2 4 5 6 1 2 2\n\n-----Sample Output:-----\nNO\n\n-----Explanation:-----\nNo. of days Mia worked (D) is 9, so minimum wage she earns (X) is 17 dollars. Highest tip at first hour (Y) = 5 dollars, 1st day she took 1st shift and 2nd day she took 3rd shift and so on. Upon calculation we will find that Mia was not able to save 300 dollars.", "starter_code": "", "test_cases": {"inputs": ["9 17 5\n1 3 2 4 5 6 1 2 2"], "outputs": ["NO"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b9e98760a272c244da1f5c13ed497f93350cc3ea", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01056", "original_id": null, "source": "apps", "domain": "code", "problem": "Vietnamese and Bengali as well.\nAn $N$-bonacci sequence is an infinite sequence $F_1, F_2, \\ldots$ such that for each integer $i > N$, $F_i$ is calculated as $f(F_{i-1}, F_{i-2}, \\ldots, F_{i-N})$, where $f$ is some function. A XOR $N$-bonacci sequence is an $N$-bonacci sequence for which $f(F_{i-1}, F_{i-2}, \\ldots, F_{i-N}) = F_{i-1} \\oplus F_{i−2} \\oplus \\ldots \\oplus F_{i−N}$, where $\\oplus$ denotes the bitwise XOR operation.\nRecently, Chef has found an interesting sequence $S_1, S_2, \\ldots$, which is obtained from prefix XORs of a XOR $N$-bonacci sequence $F_1, F_2, \\ldots$. Formally, for each positive integer $i$, $S_i = F_1 \\oplus F_2 \\oplus \\ldots \\oplus F_i$. You are given the first $N$ elements of the sequence $F$, which uniquely determine the entire sequence $S$.\nYou should answer $Q$ queries. In each query, you are given an index $k$ and you should calculate $S_k$. It is guaranteed that in each query, $S_k$ does not exceed $10^{50}$.\n\n-----Input-----\n- The first line of the input contains two space-separated integers $N$ and $Q$.\n- The second line contains $N$ space-separated integers $F_1, F_2, \\ldots, F_N$.\n- The following $Q$ lines describe queries. Each of these lines contains a single integer $k$.\n\n-----Output-----\nFor each query, print a single line containing one integer $S_k$.\n\n-----Constraints-----\n- $1 \\le N, Q \\le 10^5$\n- $0 \\le F_i \\le 10^9$ for each $i$ such that $1 \\le i \\le N$\n- $1 \\le k \\le 10^9$\n\n-----Example Input-----\n3 4\n0 1 2\n7\n2\n5\n1000000000\n\n-----Example Output-----\n3\n1\n0\n0", "starter_code": "", "test_cases": {"inputs": ["3 4\n0 1 2\n7\n2\n5\n1000000000"], "outputs": ["3\n1\n0\n0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "3675de85743c638a2f9173ea3e5a56b8b29b32f6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01061", "original_id": null, "source": "apps", "domain": "code", "problem": "Many things in this first paragraph are references to some pretty famous YouTube stars, so be careful about rephrasing. Thanks! \nMichael, Kevin and Jake are sharing a cake, in celebration of their Webby award. They named it VCake. Unlike other cakes they considered, this one has finite volume and surface area. It's shaped as a normal rectangular cake with dimensions R centimeters by C centimeters. For the purposes of this problem, we can forget about three dimensions and think of a cake as just a 2D rectangle.\nChef will now cut the cake into three pieces, one for each person. However, the cake's shape and Chef's really old tools pose a few restrictions:\n\n- Chef can only cut the cake, or a cake piece, across a line parallel to one of its sides. \n- Chef can only cut the cake, or a cake piece, from end to end. That is, she cannot cut the cake partially. \n- Chef can only cut the cake, or a cake piece, such that the sides of the resulting pieces (which will be rectangular in shape) are integers. \n\nIn addition, Michael, Kevin and Jake also have a few preferences of their own:\n\n- They want their pieces to be connected (in one piece), and rectangular in shape.\n- Michael wants his piece to have an area exactly M square centimeters. (Again, forget about a third dimension.)\n- Kevin wants his piece to have an area exactly K square centimeters.\n- Jake wants his piece to have an area exactly J square centimeters.\n\nWith these restrictions, Chef is at a loss. Is it possible for Chef to accomplish this task? Please note that the entire cake should be used. There should be no leftover cake.\n\n-----Input-----\nThe first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.\nEach test case consists of a single line containing five space separated integers R, C M, K and J.\n\n-----Output-----\nFor each test case, output a single line containing either “Yes” or “No” (without quotes), denoting whether Chef can accomplish the task or not.\n\n-----Constraints-----\n- 1 ≤ T ≤ 105\n- 1 ≤ R, C ≤ 109\n- 1 ≤ M, K, J ≤ 1018\n\n-----Example-----\nInput:4\n4 5 10 4 6\n4 5 6 10 4\n4 5 4 6 10\n2 2 2 2 2\n\nOutput:Yes\nYes\nYes\nNo\n\n-----Explanation-----\nExample case 1. In this case, Chef can accomplish the task by doing the following slicing.  \npre tt\n_ _ _ _ _       _ _ _ _ _       _ _ _ _ _       _________ \n|         |     |         |     |         |     |M M M M M|\n|         | -- |_ _ _ _ _| -- |_ _ _ _ _| -- |M_M_M_M_M|\n|         |     |         |     |     |   |     |J J J|K K|\n|_ _ _ _ _|     |_ _ _ _ _|     |_ _ _|_ _|     |J_J_J|K_K|\n/tt /pre\nI'll make an image if I have time \nExample case 4. Here, Michael, Kevin and Jake each wants a piece with area 2, but the total area of the cake is only 2×2 = 4. This means the task is impossible.", "starter_code": "", "test_cases": {"inputs": ["4\n4 5 10 4 6\n4 5 6 10 4\n4 5 4 6 10\n2 2 2 2 2"], "outputs": ["Yes\nYes\nYes\nNo"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8f97a19bc5aa73b4b7006aa9fbcf5dc0673c703f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01066", "original_id": null, "source": "apps", "domain": "code", "problem": "A binary string is called a self-destructing string if it can reduced to an empty string by performing the following operation some number of times (possibly zero): Choose a valid integer $i$ such that the $i$-th character of the current string is different from the $i+1$-th character, and remove these two characters from the string.\nYou are given a binary string $s$. Your task is to convert $s$ to a self-destructing string. To do that, you may perform the following operation any number of times (possibly zero): Choose an integer $i$ ($1 \\le i \\le |s|-1$) such that the $i$-th character of $s$ is different from the $i+1$-th character, and invert one of these characters (inverting a character means changing '0' to '1' or '1' to '0', e.g. the string \"01\" can be changed to \"00\").\nFind the smallest number of operations required to convert $s$ to a self-destructing string or determine that it is impossible.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first and only line of each test case contains a single string $s$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the smallest required number of operations or $-1$ if it is impossible to convert $s$ to a self-destructing string.\n\n-----Constraints-----\n- $1 \\le T \\le 1,000$\n- $1 \\le |s| \\le 10^6$\n- $s$ contains only characters '0' and '1'\n- the sum of $|s|$ over all test cases does not exceed $10^6$\n\n-----Example Input-----\n3\n001101\n1101\n110\n\n-----Example Output-----\n0\n1\n-1\n\n-----Explanation-----\nExample case 1: We already have a self-destructing string because \"001101\" can be converted to \"0101\", to \"01\" and finally to an empty string.\nExample case 2: We can choose $i=3$ (since $s_3 \\neq s_4$) and then invert $s_4$ to obtain \"1100\", which is a self-destructing string.\nExample case 3: It can be shown that \"110\" cannot be converted to a self-destructing string.", "starter_code": "", "test_cases": {"inputs": ["3\n001101\n1101\n110"], "outputs": ["0\n1\n-1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f5a0b96426a0bb3f057e2f945335b585a72bd813", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01071", "original_id": null, "source": "apps", "domain": "code", "problem": "You have a sequence $a$ with length $N$ created by removing some elements (possibly zero) from a permutation of numbers $(1, 2, \\dots, N)$. When an element is removed, the length of the sequence doesn't change, but there is an empty spot left where the removed element was. You also have an integer $K$.\nLet's call a permutation $p_1, p_2, \\dots, p_N$ good if:\n- it is possible replace empty spots in $a$ by numbers in such a way that we obtain the permutation $p$\n- the number of positions $i$ ($1 < i \\le N$) such that $p_i > p_{i-1}$ is equal to $K$\nYour task is to find the number of good permutations.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $K$.\n- The second line contains $N$ space-separated integers $a_1, a_2, \\dots, a_N$. Each element of this sequence is either $0$ (indicating an empty spot previously occupied by a removed element) or an integer between $1$ and $N$ inclusive.\n\n-----Output-----\nFor each test case, print a single line containing one integer — the number of good permutations.\n\n-----Constraints-----\n- $1 \\le T \\le 300$\n- $0 \\le K < N \\le 8$\n- each integer between $1$ and $N$ inclusive appears in $a$ at most once\n\n-----Example Input-----\n1\n3 1\n2 0 0\n\n-----Example Output-----\n2\n\n-----Explanation-----\nExample case 1: The two possible good permutations are $(2,3,1)$ and $(2,1,3)$.", "starter_code": "", "test_cases": {"inputs": ["1\n3 1\n2 0 0"], "outputs": ["2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "892d70a7dfa2c31c079b4a5c80929bb7c0146ca5", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01076", "original_id": null, "source": "apps", "domain": "code", "problem": "Devu is a class teacher of a class of n students. One day, in the morning prayer of the school, all the students of his class were standing in a line. You are given information of their arrangement by a string s. The string s consists of only letters 'B' and 'G', where 'B' represents a boy and 'G' represents a girl.\nDevu wants inter-gender interaction among his class should to be maximum. So he does not like seeing two or more boys/girls standing nearby (i.e. continuous) in the line. e.g. he does not like the arrangements BBG and GBB, but he likes BG, GBG etc.\nNow by seeing the initial arrangement s of students, Devu may get furious and now he wants to change this arrangement into a likable arrangement. For achieving that, he can swap positions of any two students (not necessary continuous). Let the cost of swapping people from position i with position j (i ≠ j) be c(i, j). You are provided an integer variable type, then the cost of the the swap will be defined by c(i, j) = |j − i|type.\n\nPlease help Devu in finding minimum cost of swaps needed to convert the current arrangement into a likable one.\n\n-----Input-----\nThe first line of input contains an integer T, denoting the number of test cases. Then T test cases are follow.\nThe first line of each test case contains an integer type, denoting the type of the cost function. Then the next line contains string s of length n, denoting the initial arrangement s of students.\nNote that the integer n is not given explicitly in input.\n\n-----Output-----\nFor each test case, print a single line containing the answer of the test case, that is, the minimum cost to convert the current arrangement into a likable one. If it is not possible to convert the current arrangement into a likable one, then print -1 instead of the minimum cost.\n\n-----Constraints and Subtasks-----Subtask 1: 25 points\n- 1 ≤ T ≤ 105\n- 1 ≤ n ≤ 105\n- type = 0\n- Sum of n over all the test cases in one test file does not exceed 106. \nSubtask 2: 25 points\n- 1 ≤ T ≤ 105\n- 1 ≤ n ≤ 105\n- type = 1\n- Sum of n over all the test cases in one test file does not exceed 106. \nSubtask 3: 25 points\n- 1 ≤ T ≤ 105\n- 1 ≤ n ≤ 105\n- type = 2\n- Sum of n over all the test cases in one test file does not exceed 106. \nSubtask 4: 25 points\n- 1 ≤ T ≤ 102\n- 1 ≤ n ≤ 103\n- type can be 0, 1 or 2, that is type ∈ {0, 1, 2}.\n\n-----Example-----\nInput:\n8\n0\nBB\n0\nBG\n0\nBBGG\n1\nBGG\n1\nBGGB\n1\nBBBGG\n2\nBBGG\n2\nBGB\n\nOutput:\n-1\n0\n1\n1\n1\n3\n1\n0\n\n-----Explanation-----\nNote type of the first 3 test cases is 0. So c(i, j) = 1. Hence we just have to count minimum number of swaps needed.\nExample case 1. There is no way to make sure that both the boys does not stand nearby. So answer is -1.\nExample case 2. Arrangement is already valid. No swap is needed. So answer is 0.\nExample case 3. Swap boy at position 1 with girl at position 2. After swap the arrangement will be BGBG which is a valid arrangement. So answer is 1.\nNow type of the next 3 test cases is 1. So c(i, j) = |j − i|, that is, the absolute value of the difference between i and j.\nExample case 4. Swap boy at position 0 with girl at position 1. After swap the arrangement will be GBG which is a valid arrangement. So answer is |1 - 0| = 1.\nExample case 5. Swap boy at position 0 with girl at position 1. After swap the arrangement will be GBGB which is a valid arrangement. So answer is |1 - 0| = 1.\nExample case 6. Swap boy at position 1 with girl at position 4. After swap the arrangement will be BGBGB which is a valid arrangement. So answer is |4 - 1| = 3.\nThen type of the last 2 test cases is 2. So c(i, j) = (j − i)2\nExample case 7. Swap boy at position 1 with girl at position 2. After swap the arrangement will be BGBG which is a valid arrangement. So answer is (2 - 1)2 = 1.\nExample case 8. Arrangement is already valid. No swap is needed. So answer is 0.", "starter_code": "", "test_cases": {"inputs": ["8\n0\nBB\n0\nBG\n0\nBBGG\n1\nBGG\n1\nBGGB\n1\nBBBGG\n2\nBBGG\n2\nBGB"], "outputs": ["-1\n0\n1\n1\n1\n3\n1\n0"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "864ee1a4e887e02c2a952ec8e7356610104fb250", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01081", "original_id": null, "source": "apps", "domain": "code", "problem": "Given $N *M$ matrix containing elements either $1$ or $0$ and string S of length $N+M-1$ containing characters $0$ or $1$. Your task is to make all the  paths from top left corner to the  bottom right corner of the matrix same as the  given string .You can perform two types of operations any time .Path means you can only allow it to take right or down. \nOperations :\n- Changing the matrix elements from $1$ to $0$ or vice versa  will cost P rupees per element.\n- Changing the character of string  from $1$ to $0$ or vice versa  will cost Q rupees per character.\nYou have to  minimize the cost, (possibly 0) .\n\n-----Input:-----\n- First line of input contains the total no. of test cases $T$. \n- For every test case, first line of input contains two spaced positive integers, $N$ and $M$.\n- Next $N$ lines contains $M$-spaced integers which can be only $0$ or $1$.\n- Next line of input contains a string $S$ of length $N+M-1$.\n- Last line of input contains two spaced integers, $P$ and $Q$.\n\n-----Output:-----\n- $You$ $have$ $to$ $print$ $the$ $minimum$ $cost .$\n\n-----Constraints-----\n- $1 \\leq T \\leq 20$\n- $1 \\leq N, M \\leq 1000$\n- $|S| = N+M-1$\n- $0 \\leq P, Q \\leq 1000$The input/output is quite large, please use fast reading and writing methods.\n\n-----Sample Input-----\n2\n3 3\n1 0 1\n0 1 1\n1 1 0\n10111\n10 5\n3 3 \n0 0 1\n0 1 1\n0 1 1\n00011\n2 9\n\n-----Sample Output-----\n5\n4\n\n-----Explanation-----\n- You can  change the last element of the matrix and also can change the last element of string but the minimum cost will produce by changing string element , therefore it will cost 5 rupees.", "starter_code": "", "test_cases": {"inputs": ["2\n3 3\n1 0 1\n0 1 1\n1 1 0\n10111\n10 5\n3 3\n0 0 1\n0 1 1\n0 1 1\n00011\n2 9"], "outputs": ["5\n4"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "bec37a2211de4988210910fedf8f8d4cb1ced06c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01086", "original_id": null, "source": "apps", "domain": "code", "problem": "Zonal Computing Olympiad 2012, 26 Nov 2011\n\nA sequence of opening and closing brackets is well-bracketed if we can pair up each opening bracket with a matching closing bracket in the usual sense.  For instance, the sequences (), (()) and ()(()) are well-bracketed, while (, ()), (()(), and )(  are not well-bracketed.\n\nThe nesting depth of a well-bracketed sequence tells us the maximum number of levels of inner matched brackets enclosed within outer matched brackets.  For instance, the nesting depth of () and ()()() is 1, the nesting depth of (()) and ()(()) is 2, the nesting depth of ((())) is 3, and so on.  \n\nGiven a well-bracketed sequence, we are interested in computing the following: \n-  The nesting depth, and the first position where it occurs–this will be the position of the first opening bracket at this nesting depth, where the positions are numbered starting with 1.\n-  The maximum number of symbols between any pair of matched  brackets, including both the outer brackets, and the first position where this occurs–that is, the position of the first opening bracket of this segment\n\nFor instance, the nesting depth of ()(())()(()())(()()) is 2 and the first position where this occurs is 4.  The opening bracket at position 10 is also at nesting depth 2 but we have to report the first position where this occurs, which is 4.\n\nIn this sequence, the maximum number of symbols between a pair of matched bracket is 6, starting at position 9. There is another such sequence of length 6 starting at position 15, but this is not the first such position.\n\n-----Input format-----\nThe input consists of two lines. The first line is a single integer N, the length of the bracket sequence. Positions in the sequence are numbered 1,2,…,N. The second line is a sequence of N space-separated integers that encode the bracket expression as follows: 1 denotes an opening bracket ( and 2 denotes a closing bracket ).  Nothing other than 1 or 2 appears in the second line of input and the corresponding expression is guaranteed to be well-bracketed.\n\n-----Output format-----\nYour program should print 4 space-separated integers in a line, denoting the four quantities asked for in the following order: nesting depth, first position that achieves the nesting depth, length of the maximum sequence between matching brackets and the first position where such a maximum length sequence occurs.  \n\n-----Testdata-----\n\nYou may assume that 2 ≤ N ≤ 105.  In 30% of the test cases, 2 ≤ N ≤ 103.\n\n- Subtask 1 (30 marks)\n- Subtask 2 (70 marks)\n\n-----Sample Input-----\n20\n1 2 1 1 2 2 1 2 1 1 2 1 2 2 1 1 2 1 2 2\n\n-----Sample Output-----\n2 4 6 9", "starter_code": "", "test_cases": {"inputs": ["20\n1 2 1 1 2 2 1 2 1 1 2 1 2 2 1 1 2 1 2 2"], "outputs": ["2 4 6 9"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2a15a6b7593116f038fbd760045ea9073970bc3b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01091", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef loves to play with iron (Fe) and magnets (Ma). He took a row of $N$ cells (numbered $1$ through $N$) and placed some objects in some of these cells. You are given a string $S$ with length $N$ describing them; for each valid $i$, the $i$-th character of $S$ is one of the following:\n- 'I' if the $i$-th cell contains a piece of iron\n- 'M' if the $i$-th cell contains a magnet\n- '_' if the $i$-th cell is empty\n- ':' if the $i$-th cell contains a conducting sheet\n- 'X' if the $i$-th cell is blocked\nIf there is a magnet in a cell $i$ and iron in a cell $j$, the attraction power between these cells is $P_{i,j} = K+1 - |j-i| - S_{i,j}$, where $S_{i,j}$ is the number of cells containing sheets between cells $i$ and $j$. This magnet can only attract this iron if $P_{i, j} > 0$ and there are no blocked cells between the cells $i$ and $j$.\nChef wants to choose some magnets (possibly none) and to each of these magnets, assign a piece of iron which this magnet should attract. Each piece of iron may only be attracted by at most one magnet and only if the attraction power between them is positive and there are no blocked cells between them. Find the maximum number of magnets Chef can choose.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains two space-separated integers $N$ and $K$.\n- The second line contains a single string $S$ with length $N$.\n\n-----Output-----\nFor each test case, print a single line containing one integer ― the maximum number of magnets that can attract iron.\n\n-----Constraints-----\n- $1 \\le T \\le 2,000$\n- $1 \\le N \\le 10^5$\n- $0 \\le K \\le 10^5$\n- $S$ contains only characters 'I', 'M', '_', ':' and 'X'\n- the sum of $N$ over all test cases does not exceed $5 \\cdot 10^6$\n\n-----Subtasks-----\nSubtask #1 (30 points): there are no sheets, i.e. $S$ does not contain the character ':'\nSubtask #2 (70 points): original constraints\n\n-----Example Input-----\n2\n4 5\nI::M\n9 10\nMIM_XII:M\n\n-----Example Output-----\n1\n2\n\n-----Explanation-----\nExample case 1: The attraction power between the only magnet and the only piece of iron is $5+1-3-2 = 1$. Note that it decreases with distance and the number of sheets.\nExample case 2:\nThe magnets in cells $1$ and $3$ can attract the piece of iron in cell $2$, since the attraction power is $10$ in both cases. They cannot attract iron in cells $6$ or $7$ because there is a wall between them.\nThe magnet in cell $9$ can attract the pieces of iron in cells $7$ and $6$; the attraction power is $8$ and $7$ respectively.", "starter_code": "", "test_cases": {"inputs": ["2\n4 5\nI::M\n9 10\nMIM_XII:M"], "outputs": ["1\n2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "0573c1387307f59304e8d44e9b7542fe9c6158b9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01096", "original_id": null, "source": "apps", "domain": "code", "problem": "Consider a number X on which K Mag-Inc operations are to be performed. In a Mag-Inc operation, the number X undergoes an increment of A/B times of X where A and B are two integers.\n\nThere is a numerator and a denominator array of size K which contain the ith values of A and B. After K Mag-Inc operations, the number X turns to M.\n\nNow your job is to find what percentage of M is to be decremented from M if it has to be converted back to X. Let this percentage be denoted by Z.\n\nPrint the integral part of Z.\n\n-----Input:-----\n\nFirst line contains an integer T denoting the number of test cases.\n\nFirst line of every test case contains two space separated integers X and K.\n\nThe second and third line of every test case will contain K space separated integers \n\ndenoting the Numerator and Denominator array.\n\n-----Output:-----\n\nFor each test case, print the required result in a single line.\n\n-----Constraints:-----\n1 ≤ T ≤ 100\n1 ≤ K, A, B ≤ 40000\n1≤X≤10^100\n\n-----Example:-----Input:\n2\n100 1\n1 \n4\n100 2\n1 1\n2 3Output:\n20\n50\n\n-----Explanation:-----\n\nCase 2: 100 undergoes an increment of (1/2)*100. Therefore M = 100 + 50.\n\nNow M = 150.\n\nNow again, \n\nM undergoes an increment of (1/3)*150. Therefore, M = 150 + 50. \n\nNow as we want to revert back M = 200 to X i.e. 100, we need to decrement it by a value \n\nof 100 and we know that 100 is 50% of 200.\n\nHence, we print 50.", "starter_code": "", "test_cases": {"inputs": ["2\n100 1\n1\n4\n100 2\n1 1\n2 3"], "outputs": ["20\n50"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e449d27cb9b7c5d99a61fe18d57fe254e3ff05de", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01101", "original_id": null, "source": "apps", "domain": "code", "problem": "Kira likes to play with strings very much. Moreover he likes the shape of 'W' very much. He takes a string and try to make a 'W' shape out of it such that each angular point is a '#' character and each sides has same characters. He calls them W strings.\nFor example, the W string can be formed from \"aaaaa#bb#cc#dddd\" such as:\na\na             d\na     #     d\na   b c   d\na b   c d\n#     #\n\nHe also call the strings which can generate a 'W' shape (satisfying the above conditions) W strings.\nMore formally, a string S is a W string if and only if it satisfies the following conditions (some terms and notations are explained in Note, please see it if you cannot understand):\n- The string S contains exactly 3 '#' characters. Let the indexes of all '#' be P1 < P2 < P3 (indexes are 0-origin).\n- Each substring of S[0, P1−1], S[P1+1, P2−1], S[P2+1, P3−1], S[P3+1, |S|−1] contains exactly one kind of characters, where S[a, b] denotes the non-empty substring from a+1th character to b+1th character, and |S| denotes the length of string S (See Note for details).\nNow, his friend Ryuk gives him a string S and asks him to find the length of the longest W string which is a subsequence of S, with only one condition that there must not be any '#' symbols between the positions of the first and the second '#' symbol he chooses, nor between the second and the third (here the \"positions\" we are looking at are in S), i.e. suppose the index of the '#'s he chooses to make the W string are P1, P2, P3 (in increasing order) in the original string S, then there must be no index i such that S[i] = '#' where P1 < i < P2 or P2 < i < P3.\nHelp Kira and he won't write your name in the Death Note.\nNote:\nFor a given string S, let S[k] denote the k+1th character of string S, and let the index of the character S[k] be k. Let |S| denote the length of the string S. And a substring of a string S is a string S[a, b] = S[a] S[a+1] ... S[b], where 0 ≤ a ≤ b < |S|. And a subsequence of a string S is a string S[i0] S[i1] ... S[in−1], where 0 ≤ i0 < i1 < ... < in−1 < |S|.\nFor example, let S be the string \"kira\", then S[0] = 'k', S[1] = 'i', S[3] = 'a', and |S| = 4. All of S[0, 2] = \"kir\", S[1, 1] = \"i\", and S[0, 3] = \"kira\" are substrings of S, but \"ik\", \"kr\", and \"arik\" are not. All of \"k\", \"kr\", \"kira\", \"kia\" are subsequences of S, but \"ik\", \"kk\" are not.\nFrom the above definition of W string, for example, \"a#b#c#d\", \"aaa#yyy#aaa#yy\", and \"o#oo#ooo#oooo\" are W string, but \"a#b#c#d#e\", \"#a#a#a\", and \"aa##a#a\" are not.\n\n-----Input-----\nFirst line of input contains an integer T, denoting the number of test cases. Then T lines follow. Each line contains a string S.\n\n-----Output-----\nOutput an integer, denoting the length of the longest W string as explained before. If S has no W string as its subsequence, then output 0.\n\n-----Constraints-----\n\n- 1 ≤ T ≤ 100 \n- 1 ≤ |S| ≤ 10000 (104)\n- S contains no characters other than lower English characters ('a' to 'z') and '#' (without quotes)\n\n-----Example-----\nInput:\n3\naaaaa#bb#cc#dddd\nacb#aab#bab#accba\nabc#dda#bb#bb#aca\n\nOutput:\n16\n10\n11\n\n-----Explanation-----\nIn the first case: the whole string forms a W String.\nIn the second case: acb#aab#bab#accba, the longest W string is acb#aab#bab#accba\nIn the third case: abc#dda#bb#bb#aca, note that even though abc#dda#bb#bb#aca (boldened characters form the subsequence) is a W string of length 12, it violates Ryuk's condition that there should not be any #'s inbetween the 3 chosen # positions. One correct string of length 11 is abc#dda#bb#bb#aca", "starter_code": "", "test_cases": {"inputs": ["3\naaaaa#bb#cc#dddd\nacb#aab#bab#accba\nabc#dda#bb#bb#aca\n\n"], "outputs": ["16\n10\n11"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "4550f95803e7e22d714aa1ab37d5c3640b04b9ca", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01106", "original_id": null, "source": "apps", "domain": "code", "problem": "During Quarantine Time Chef is at home and he was quite confused about what to cook so, he went to his son and asked about what would he prefer to have? He replied, cakes.\nNow, chef cook $N$ number of cake and number of layers for every cake is different. After cakes are baked, Chef arranged them in a particular order and then generates a number by putting number of layers of cakes as digit in sequence (e.g., if chef arranges cakes with layers in sequence $2$, $3$ and $5$ then generated number is $235$).\nChef has to make his son powerful in mathematics, so he called his son and ask him to arrange the cakes in all the possible ways and every time when different sequence is generated he has to note down the number. At the end he has to find sum of all the generated numbers. So, help him to complete this task.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- The first line of each test case contains a single integer $N$ denoting number of cakes.\n- The second line contains $N$ space-separated integers $L1$ $L2$ … $LN$ layers of the cake.\n\n-----Output:-----\nFor each test case, print a single line containing sum of all the possible numbers which is generated by arranging cake in different sequence.\n\n-----Constraints :-----\n- $1 \\leq T  \\leq 2*10^5$\n- $1 \\leq N, L1, L2, L3,…, LN \\leq 9$\n\n-----Sample Input:-----\n1\n3\n2 3 5\n\n-----Sample Output:-----\n2220\n\n-----Explanation:-----\nSum of all possibilities :\n$235 + 532 + 253 + 352 + 523 + 325 = 2220 $", "starter_code": "", "test_cases": {"inputs": ["1\n3\n2 3 5"], "outputs": ["2220"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8669fb4c451c71404587bf2822273263cf9c5e9b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01111", "original_id": null, "source": "apps", "domain": "code", "problem": "Istiak is learning about arithmetic progressions. Today, he wrote an arithmetic sequence on a piece of paper. Istiak was very happy that he managed to write an arithmetic sequence and went out for lunch.\nIstiak's friend Rafsan likes to irritate him by playing silly pranks on him. This time, he could have chosen one element of Istiak's sequence and changed it. When Istiak came back, he was devastated to see his sequence ruined — it became a sequence $a_1, a_2, \\ldots, a_N$ (possibly identical to the original sequence, if Rafsan did not change anything, in which case Istiak is just overreacting). Help him recover the original sequence.\nFormally, you have to find an arithmetic sequence $b_1, b_2, \\ldots, b_N$ which differs from $a$ in at most one position. $b$ is said to be an arithmetic sequence if there is a real number $d$ such that $b_i - b_{i-1} = d$ for each $i$ ($2 \\le i \\le N$). If there are multiple valid solutions, you may find any one.\n\n-----Input-----\n- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.\n- The first line of each test case contains a single integer $N$.\n- The second line contains $N$ space-separated integers $a_1, a_2, \\ldots, a_N$.\n\n-----Output-----\nFor each test case, print a single line containing $N$ space-separated integers $b_1, b_2, \\ldots, b_N$. It is guaranteed that a valid solution exists.\n\n-----Constraints-----\n- $4 \\le N \\le 10^5$\n- $|a_i| \\le 10^9$ for each valid $i$\n- the sum of $N$ over all test cases does not exceed $5 \\cdot 10^5$\n\n-----Example Input-----\n3\n4\n1 3 10 7\n5\n-10 -5 0 5 10\n4\n2 2 2 10\n\n-----Example Output-----\n1 3 5 7\n-10 -5 0 5 10\n2 2 2 2\n\n-----Explanation-----\nExample case 1: Rafsan changed the third element from $5$ to $10$.\nExample case 2: No elements were changed.\nExample case 3: Rafsan changed the fourth element from $2$ to $10$.", "starter_code": "", "test_cases": {"inputs": ["3\n4\n1 3 10 7\n5\n-10 -5 0 5 10\n4\n2 2 2 10"], "outputs": ["1 3 5 7\n-10 -5 0 5 10\n2 2 2 2"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "a7d082f16e40ddd24726a20afe1479efd0d2663f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01116", "original_id": null, "source": "apps", "domain": "code", "problem": "Every character in the string “IITMANDI” is given a certain number of points. You are given a scrabble board with only one row. The input contains the positions of score modifiers such as: Double Letter, Triple Letter, Double Word and Triple Word. You need to find the best position to place the string “IITMANDI” such that your score is maximized. \nDouble Letter - Doubles the number of points you get for the letter placed on the double letter.\nTriple Letter - Triples the number of points you get for the letter placed on the triple letter.\nDouble Word - Doubles the number of points you get for the word. Applied after applying above modifiers.\nTriple Word - Triples the number of points you get for the word. Applied after applying the above modifiers.\nThe word has to be read from left to right. You can’t place it in the reverse direction.\n\nThe letters have to be placed continuously on the board.\n\nIf there is no modifier or a double word or triple word modifier before a tile, it's score is added to the total score. The double word and triple modifiers are applied at the end.\n\n-----Input Format-----\n- First line containes a single integer $T$ - the number of test cases.\n- First line of each test case contains a single integer $N$ - the size of the board.    \n- Second line of each test case contains a string of size $N$ representing the board according to the following convention:\n\n'.' - No modifier\n\n'd' - Double letter\n\n't' - Triple letter\n\n'D' - Double word\n\n'T' - Triple word     \n- Third line of each test case contains 8 integers corresponding to the points associated with each letter of the string \"IITMANDI\". Note that the 3 'I's in IITMANDI cannot be interchanged freely. The score of the first 'I' will be equal to the first integer, score of the second 'I' will be equal to the second integer and the score of the last 'I' will be equal to the last integer.\n\n-----Output Format-----\nFor each test case, output a single integer in a new line, the maximum possible score. \n\n-----Constraints-----\n$ 1 \\leq T \\leq 1000 $\n$ 8 \\leq N \\leq 100 $\n$ 0 \\leq $ Points for each character $ \\leq 10^5 $ \n\n-----Sample Input-----\n2\n\n10\n\n..d.t.D..d\n\n10 11 12 9 8 10 11 15\n\n22\n\ndtDtTD..ddT.TtTdDT..TD\n\n12297 5077 28888 17998 12125 27400 31219 21536\n\n-----Sample Output-----\n270\n\n35629632", "starter_code": "", "test_cases": {"inputs": ["2\n10\n..d.t.D..d\n10 11 12 9 8 10 11 15\n22\ndtDtTD..ddT.TtTdDT..TD\n12297 5077 28888 17998 12125 27400 31219 21536"], "outputs": ["270\n35629632"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "4ddd9b9b1ceb1a9ffa7caa569098dbd1b4c432d8", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01121", "original_id": null, "source": "apps", "domain": "code", "problem": "The Fibonacci sequence is defined as F(n) = F(n-1) + F(n-2). You have developed two sequences of numbers. The first sequence that uses the bitwise XOR operation instead of the addition method is called the Xoronacci number. It is described as follows:\nX(n) = X(n-1) XOR X(n-2)\nThe second sequence that uses the bitwise XNOR operation instead of the addition method is called the XNoronacci number. It is described as follows:\nE(n) = E(n-1) XNOR E(n-2)\nThe first and second numbers of the sequence are as follows:\nX(1) = E(1) = a\nX(2) = E(2) = b\nYour task is to determine the value of max(X(n),E(n)), where n is the n th term of the Xoronacci and XNoronacci sequence.\n\n-----Input:-----\nThe first line consists of a single integer T denoting the number of test cases.\nThe first and the only line of each test case consists of three space separated integers a, b and n.\n\n-----Output:-----\nFor each test case print a single integer max(X(n),E(n)).\n\n-----Constraints-----\n- $1 \\leq T \\leq 1000$\n- $2 \\leq a,b,n \\leq 1000000000000$\n\n-----Sample Input:-----\n1\n3 4 2 \n\n-----Sample Output:-----\n4\n\n-----EXPLANATION:-----\nXoronacci Sequence : 3 4 7 …….\nXNoronacci Sequence : 3 4 0 …….\nHere n = 2. Hence max(X(2),E(2)) = 4", "starter_code": "", "test_cases": {"inputs": ["1\n3 4 2"], "outputs": ["4"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "0685d274ae761d2678e3b20b13036c1f60f58e6c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01126", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef is interested to solve series problems. Chef wants to solve a series problem but he can't \nsolve it till now.Can you help Chef to solve the series problem?\n- In series problem, the series goes as follows 1,9,31,73,141 . . . . . . . . \nYour task is to find the Nth term of series. For larger value of $N$ answer becomes very large, So your output should be performed $N$th term modulo 1000000007 ($10^9+7$ ).\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single integer $N$. \n\n-----Output:-----\nFor each testcase,  output in a single line answer i.e. The $N$th term of series modulo 1000000007.\n\n-----Constraints-----\n- $1 \\leq T \\leq 10^5$\n- $1 \\leq N \\leq 10^9$\n\n-----Sample Input:-----\n2\n\n8\n\n10\n\n-----Sample Output:-----\n561\n\n1081", "starter_code": "", "test_cases": {"inputs": ["2\n8\n10"], "outputs": ["561\n1081"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f8344ec6370a3dbc0303a6767bac023413c27035", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01131", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef Tobby asked Bhuvan to brush up his knowledge of statistics for a test. While studying some distributions, Bhuvan learns the fact that for symmetric distributions, the mean and the median are always the same.\nChef Tobby asks Bhuvan out for a game and tells him that it will utilize his new found knowledge. He lays out a total of 109 small tiles in front of Bhuvan. Each tile has a distinct number written on it from 1 to 109.\nChef Tobby gives Bhuvan an integer N and asks him to choose N distinct tiles and arrange them in a line such that the mean of median of all subarrays lies between [N-1, N+1], both inclusive. The median of subarray of even length is the mean of the two numbers in the middle after the subarray is sorted\nBhuvan realizes that his book didn’t teach him how to solve this and asks for your help. Can you solve the problem for him?\nIn case, no solution exists, print -1.\n\n-----Input section-----\nFirst line contains, T, denoting the number of test cases.\nEach of the next T lines, contain a single integer N.\n\n-----Output section-----\nIf no solution, exists print -1.\nIf the solution exists, output N space separated integers denoting the elements of the array A such that above conditions are satisfied. In case, multiple answers exist, you can output any one them.\n\n-----Input constraints-----\n1 ≤ T ≤ 20\n1 ≤ N ≤ 100\n\n-----Sample Input-----\n3\n1\n2\n3\n\n-----Sample Output-----\n1\n1 2\n1 2 3\n\n-----Explanation-----\nFor test case 3, the subarrays and their median are as follows: \n- {1}, median = 1\n- {2}, median = 2\n- {3}, median = 3\n- {1, 2}, median = 1.5\n- {2, 3}, median = 2.5\n- {1, 2, 3}, median = 2\nThe mean of the medians is 2 which lies in the range [2, 4]", "starter_code": "", "test_cases": {"inputs": ["3\n1\n2\n3"], "outputs": ["1\n1 2\n1 2 3"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "2bc8c2246352575dbd8e4c48aaaf0d6682f97798", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01136", "original_id": null, "source": "apps", "domain": "code", "problem": "Ashley likes playing with strings.\n\nShe gives Mojo a fun problem to solve. In her imaginary string world, a string of even length is called as \"Doublindrome\" if both halves of the string are palindromes (both halves have length equal to half of original string).\n\nShe gives Mojo a string and asks him if he can form a \"Doublindrome\" by rearranging the characters of the given string or keeping the string as it is.\n\nAs Mojo is busy playing with cats, solve the problem for him.\n\nPrint \"YES\" (without quotes) if given string can be rearranged to form a \"Doublindrome\" else print \"NO\" (without quotes).\n\n-----Input:-----\n- First line will contain a single integer $T$, the number of testcases. \n- Each testcase consists of two lines, first line consists of an integer $N$ (length of the string) and second line consists of  the string $S$. \n\n-----Output:-----\nFor each testcase, print \"YES\"(without quotes) or \"NO\"(without quotes) on a new line.\n\n-----Constraints-----\n- $1 \\leq T \\leq 10^5$\n- $1 \\leq N \\leq 100$\n- $N$ is always even.\n- String $S$ consists only of lowercase English alphabets.\n\n-----Sample Input:-----\n1\n8\nabbacddc\n\n-----Sample Output:-----\nYES\n\n-----EXPLANATION:-----\nThe given string is a Doublindrome as its 2 halves \"abba\" and \"cddc\" are palindromes.", "starter_code": "", "test_cases": {"inputs": ["1\n8\nabbacddc"], "outputs": ["YES"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "de89bf1c9b8f4e9b55007e4239a6dfdac967a39d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01141", "original_id": null, "source": "apps", "domain": "code", "problem": "A tennis tournament is about to take place with $N$ players participating in it.\nEvery player plays with every other player exactly once and there are no ties. That is, every match has a winner and a loser. \nWith Naman's birthday approaching, he wants to make sure that each player wins the same number of matches so that nobody gets disheartened.  \nYour task is to determine if such a scenario can take place and if yes find one such scenario.\n\n-----Input:-----\n- First line will contain $T$, number of testcases. Then the testcases follow. \n- Each testcase contains of a single integer $N$ denoting number of players.\n\n-----Output:-----\n- If it's impossible for everyone to win the same number of matches, print \"NO\" (without quotes).\n- Otherwise print \"YES\" (without quotes) and then print $N$ lines , each line should consist of a string containing only 0s and 1s and should be of size $N$. \n- If the jth character in the ith line is 1 then it means in the match between $i$ and $j$ , $i$ wins. \n- You will get a WA if the output does not correspond to a valid tournament, or if the constraints are not satisfied.\n- You will get also WA verdict if any 2 lines have contradicting results or if a player beats himself.\n\n-----Constraints-----\n- $1 \\leq T \\leq 100$\n- $2 \\leq N \\leq 100$\n\n-----Subtasks-----\n- 10 points : $2 \\leq N \\leq 6$\n- 90 points :  Original Constraints. \n\n-----Sample Input:-----\n2\n3\n2\n\n-----Sample Output:-----\nYES\n010\n001\n100\nNO\n\n-----Explanation:-----\nOne such scenario for $N$ = $3$ is when player $1$ beats player $2$, player $2$ to beats player $3$ and player $3$ beats player $1$. Here all players win exactly $1$ match.", "starter_code": "", "test_cases": {"inputs": ["2\n3\n2"], "outputs": ["YES\n010\n001\n100\nNO"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f9cd54f4f9cdc18a3311e13bc9803a5a82635dc9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01146", "original_id": null, "source": "apps", "domain": "code", "problem": "In this problem the input will consist of a number of lines of English text consisting of the letters of the English alphabet, the punctuation marks ' (apostrophe), . (full stop), , (comma), ; (semicolon), :(colon) and white space characters (blank, newline).\nYour task is print the words in the text in lexicographic order (that is, dictionary order). Each word should appear exactly once in your list. You can ignore the case (for instance, \"The\" and \"the\" are to be treated as the same word). There should be no uppercase letters in the output.\nFor example, consider the following candidate for the input text: \nThis is a sample piece of text to illustrate this \nproblem.\n\nThe corresponding output would read as:\na\nillustrate\nis\nof\npiece\nproblem\nsample\ntext\nthis\nto\n\n-----Input format-----\n- The first line of input contains a single integer $N$, indicating the number of lines in the input.\n- This is followed by $N$ lines of input text.\n\n-----Output format-----\n- The first line of output contains a single integer $M$ indicating the number of distinct words in the given text. \n- The next $M$ lines list out these words in lexicographic order.\n\n-----Constraints-----\n- $1 \\leq N \\leq 10000$\n- There are at most 80 characters in each line.\n- There are at the most 1000 distinct words in the given text.\n\n-----Sample Input-----\n2\nThis is a sample piece of text to illustrate this \nproblem. \n\n-----Sample Output-----\n10\na\nillustrate\nis\nof\npiece\nproblem\nsample\ntext\nthis\nto", "starter_code": "", "test_cases": {"inputs": ["2\nThis is a sample piece of text to illustrate this\nproblem."], "outputs": ["10\na\nillustrate\nis\nof\npiece\nproblem\nsample\ntext\nthis\nto"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "4fecf8208bface4c7c9a555259f76b0d7f03b249", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01151", "original_id": null, "source": "apps", "domain": "code", "problem": "Chef likes problems on geometry a lot. Please help him to solve one such problem.\nFind all possible triangles with integer sides which has the radius of inscribed circle (also known as incircle) equal to R.\nTwo triangles are said to be different if they have at least one different side lengths. Formally, let there be two triangles T1, T2. Let a, b, c denote the sides of triangle T1, such that a ≤ b ≤ c. Similarly, Let d, e, f denote the sides of triangle T2, such that d ≤ e ≤ f. Then T1 will said to be different from T2 if either a ≠ d, or b ≠ e or c ≠ f.\n\n-----Input-----\nThere is a single test case per test file.\nThe only line of input contains an integer R.\n\n-----Output-----\nOutput in first line single number - number of triangles satisfying statement.\nOrder the sides of triangles in non-decreasing order. Output all triangles in non-decreasing order, i.e. order first by smallest sides, otherwise by second smallest sides, if first and second sides equal, then by third.\n\n-----Constraints-----\n- 1 ≤ R ≤ 100 \n\n-----Subtasks-----\n- Subtask #1: (20 points)  1 ≤ R ≤ 3\n- Subtask #2: (30 points)  1 ≤ R ≤ 20\n- Subtask #3: (50 points)  Original constraints\n\n-----Example-----\nInput:2\n\nOutput:5\n5 12 13\n6 8 10\n6 25 29\n7 15 20\n9 10 17", "starter_code": "", "test_cases": {"inputs": ["2"], "outputs": ["5\n5 12 13\n6 8 10\n6 25 29\n7 15 20\n9 10 17"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "de7935ae156208dba5ac51743c8fd3c5fe519159", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01156", "original_id": null, "source": "apps", "domain": "code", "problem": "Consider a currency system in which there are notes of six denominations, namely, Rs. 1, Rs. 2, Rs. 5, Rs. 10, Rs. 50, Rs. 100.\nIf the sum of Rs. N is input, write a program to computer smallest number of notes that will combine to give Rs. N.\n\n-----Input-----\n\nThe first line contains an integer T, total number of testcases. Then follow T lines, each line contains an integer N. \n\n-----Output-----\nFor each test case, display the smallest number of notes that will combine to give N, in a new line.\n\n-----Constraints-----\n- 1 ≤ T ≤ 1000\n- 1 ≤ N ≤ 1000000\n\n-----Example-----\nInput\n3 \n1200\n500\n242\n\nOutput\n12\n5\n7", "starter_code": "", "test_cases": {"inputs": ["3\n1200\n500\n242"], "outputs": ["12\n5\n7"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "0c0a5ef16fbb827bfdfa732f526fcdfd3452b621", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01161", "original_id": null, "source": "apps", "domain": "code", "problem": "Shivam owns a gambling house, which has a special wheel called The Wheel of Fortune. \nThis wheel is meant for giving free coins to people coming in the house. \n\nThe wheel of fortune is a game of chance. It uses a spinning wheel with exactly N numbered pockets and a coin is placed in between every consecutive pocket. The wheel is spun in either of the two ways.\nBefore the wheel is turned, all the coins are restored and players bet on a number K.\nThen a needle is made to point to any one of the pocket which has number K written on it.\nWheel is then spun till the needle encounters number K again and the player gets all the coins the needle has encountered.\n\nShivam being the owner of the gambling house, has the authority to place the needle on any of the K numbered pockets and also he could rotate the wheel in either of the two ways.\nShivam has to figure out a way to minimize number of coins that he has to spend on every given bet.\nYou are given a wheel having N elements and Q players. Each player bets on a number K from the wheel. For each player you have to print minimum number of coins Shivam has to spend.\n\n\n-----Input-----\n- The first line of the input contains an integer T denoting the number of test cases . The description of T testcases follow.\n\n- The first line of each test case contains single integer N .\n\n- The second line of each test case contains N space seperated integers denoting the numbers on the wheel.\n\n- The third line of each test case contains a single integer Q denoting the number of players.\n- Then, Q lines follow a single integer K from the N numbers of the wheel \n\n-----Output-----\nFor each player, output the minimum number of coins Shivam has to spend.\n\n\n-----Constraints-----\n\n- 1 ≤ T ≤ 10\n- 1 ≤ N ≤ 100000\n- 1 ≤ Number written on the Wheel ≤ 1000\n- 1 ≤ Q ≤ 10000\n- 1 ≤ K ≤ 1000\n-  It is guaranteed that K belongs to the N numbers written on the wheel.\n\n-----Example-----\nInput:\n\n2\n\n3\n\n1 2 3\n\n3\n\n1\n\n2\n\n3\n\n6\n\n2 1 5 3 2 1\n\n4\n\n1\n\n2\n\n3\n\n5\nOutput:\n\n3\n\n3\n\n3\n\n2\n\n2\n\n6\n\n6", "starter_code": "", "test_cases": {"inputs": ["2\n3\n1 2 3\n3\n1\n2\n3\n6\n2 1 5 3 2 1\n4\n1\n2\n3\n5"], "outputs": ["3\n3\n3\n2\n2\n6\n6"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "7b14f319c0b9783214986539a53030a8ef20a1b1", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01166", "original_id": null, "source": "apps", "domain": "code", "problem": "We are given a certain number ```n``` and we do the product partitions of it.\n```[59, 3, 2, 2, 2]``` is a product partition of ```1416``` because:\n```\n59 * 3 * 2 * 2 * 2 = 1416\n```\nWe form a score, ```sc``` for each partition in the following way:\n- if ```d1, d2, ...., dk``` are the prime factors of ```n```, and ```f1, f2, ...., fk```, the corresponding frequencies for each factor, we calculate:\n\n\n\nSuposse that we have that ```n = 1416``` \nThe product partitions of this number with a corresponding special score are as follows:\n```\nProduct Partition           Score(sc)\n[59, 3, 2, 2, 2]             350    # equals to: (59^1 + 3^1 + 2^3) * 5\n[177, 2, 2, 2]               740    # equals to: (177^1 + 2^3) * 4\n[118, 3, 2, 2]               500\n[59, 6, 2, 2]                276\n[354, 2, 2]                 1074\n[59, 4, 3, 2]                272\n[236, 3, 2]                  723\n[177, 4, 2]                  549\n[118, 6, 2]                  378\n[59, 12, 2]                  219\n[708, 2]                    1420  <---- maximum value\n[118, 4, 3]                  375\n[59, 8, 3]                   210\n[472, 3]                     950\n[59, 6, 4]                   207\n[354, 4]                     716\n[236, 6]                     484\n[177, 8]                     370\n[118, 12]                    260\n[59, 24]                     166  <---- minimum value\n```\nSo we need a function that may give us the product partition with maximum or minimum score.\n\nThe function ```find_spec_prod_part()``` will receive two arguments:\n\n- an integer ```n, n > 0```\n- a command as a string, one of the following ones: ```'max' or 'min'```\n\nThe function should output a list with two elements: the found product partition (as a list sorted in descendin order) with its corresponding score.\n```\nfind_spec_prod_part(n, com) ---> [prod_partition, score]\n```\nLet'see some cases:\n```python\nfind_spec_prod_part(1416, 'max') == [[708, 2], 1420]\n\nfind_spec_prod_part(1416, 'min') == [[59, 24], 166]\n```\n\nThe function should reject prime numbers:\n```python\nfind_spec_prod_part(10007 , 'max') == \"It is a prime number\"\n```\nEnjoy it!\n\nHint: In this kata, optimization is one of the purposes or tags. The algorithm to produce the product partition is a key factor in terms of speed. Your code will be tested for an ```n``` value up to ```500000```.", "starter_code": "\ndef find_spec_prod_part(n, com):\n\t", "test_cases": {"inputs": [[1416, "max"], [1416, "min"], [10007, "max"]], "outputs": [[[[708, 2], 1420]], [[[59, 24], 166]], ["It is a prime number"]], "fn_name": "find_spec_prod_part"}, "test_case_format": "function_call", "n_test_cases_total": 3, "n_test_cases_kept": 3, "test_cases_truncated": false, "problem_sha1": "c2f3434ade3295a47d0de76f22dcdf3c30ac1c91", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "find_spec_prod_part"}
{"seed_id": "apps-01171", "original_id": null, "source": "apps", "domain": "code", "problem": "Create a function that differentiates a polynomial for a given value of `x`.\n\nYour function will receive 2 arguments: a polynomial as a string, and a point to evaluate the equation as an integer.\n\n## Assumptions:\n\n* There will be a coefficient near each `x`, unless the coefficient equals `1` or `-1`.\n* There will be an exponent near each `x`, unless the exponent equals `0` or `1`.\n* All exponents will be greater or equal to zero\n\n## Examples:\n\n```python\ndifferenatiate(\"12x+2\", 3)      ==>   returns 12\ndifferenatiate(\"x^2+3x+2\", 3)   ==>   returns 9\n```", "starter_code": "\ndef differentiate(equation, point):\n\t", "test_cases": {"inputs": [["12x+2", 3], ["x-66", 3], ["x^2-x", 3], ["-5x^2+10x+4", 3], ["x^2+3x+3", 3], ["1000x^2+300x+200", 531], ["21x^2+35x+3", 2071], ["66x^3+3x^2+3", 441], ["21x^4+3x^3", 414], ["-21x^5+3x^3", 12398], ["-x^2+3x-3", 1234567908], ["-7x^5+22x^4-55x^3-94x^2+87x-56", -3], ["-123x^5+3x", 8559], ["x^2", 59884848483559]], "outputs": [[12], [1], [5], [-20], [9], [1062300], [87017], [38509884], [5962009860], [-2480823269890144044], [-2469135813], [-6045], [-3300404885229567012], [119769696967118]], "fn_name": "differentiate"}, "test_case_format": "function_call", "n_test_cases_total": 14, "n_test_cases_kept": 14, "test_cases_truncated": false, "problem_sha1": "d244902247b910024f4c6c5ca9d6c0abde2e4b0a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "differentiate"}
{"seed_id": "apps-01176", "original_id": null, "source": "apps", "domain": "code", "problem": "Consider the following array:\n\n```\n[1, 12, 123, 1234, 12345, 123456, 1234567, 12345678, 123456789, 12345678910, 1234567891011...]\n```\n\nIf we join these blocks of numbers, we come up with an infinite sequence which starts with `112123123412345123456...`. The list is infinite.\n\nYou will be given an number (`n`) and your task will be to return the element at that index in the sequence, where `1 ≤ n ≤ 10^18`. Assume the indexes start with `1`, not `0`.  For example:\n\n```\nsolve(1) = 1, because the first character in the sequence is 1. There is no index 0. \nsolve(2) = 1, because the second character is also 1.\nsolve(3) = 2, because the third character is 2.\n```\n\nMore examples in the test cases. Good luck!", "starter_code": "\ndef solve(n):\n\t", "test_cases": {"inputs": [[1], [2], [3], [100], [2100], [31000], [55], [123456], [123456789], [999999999999999999], [1000000000000000000], [999999999999999993]], "outputs": [[1], [1], [2], [1], [2], [2], [1], [6], [3], [4], [1], [7]], "fn_name": "solve"}, "test_case_format": "function_call", "n_test_cases_total": 12, "n_test_cases_kept": 12, "test_cases_truncated": false, "problem_sha1": "fa09d7b1762f18f474ae8712cd03b6b54380afb2", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "solve"}
{"seed_id": "apps-01181", "original_id": null, "source": "apps", "domain": "code", "problem": "Let's define `increasing` numbers as the numbers whose digits, read from left to right, are never less than the previous ones: 234559 is an example of increasing number.\n\nConversely, `decreasing` numbers have all the digits read from left to right so that no digits is bigger than the previous one: 97732 is an example of decreasing number.\n\nYou do not need to be the next Gauss to figure that all numbers with 1 or 2 digits are either increasing or decreasing: 00, 01, 02, ..., 98, 99 are all belonging to one of this categories (if not both, like 22 or 55): 101 is indeed the first number which does NOT fall into either of the categories. Same goes for all the numbers up to 109, while 110 is again a decreasing number.\n\nNow your task is rather easy to declare (a bit less to perform): you have to build a function to return the total occurrences of all the increasing or decreasing numbers *below* 10 raised to the xth power (x will always be >= 0).\n\nTo give you a starting point, there are a grand total of increasing and decreasing numbers as shown in the table:\n\n|Total  | Below\n|---------------\n|1      | 1\n|10     | 10\n|100    | 100\n|475    | 1000\n|1675   | 10000\n|4954   | 100000\n|12952  | 1000000\n\nThis means that your function will have to behave like this:\n```python\ntotal_inc_dec(0)==1\ntotal_inc_dec(1)==10\ntotal_inc_dec(2)==100\ntotal_inc_dec(3)==475\ntotal_inc_dec(4)==1675\ntotal_inc_dec(5)==4954\ntotal_inc_dec(6)==12952\n```\n\n**Tips:** efficiency and trying to figure out how it works are essential: with a brute force approach, some tests with larger numbers may take more than the total computing power currently on Earth to be finished in the short allotted time.\n\nTo make it even clearer, the increasing or decreasing numbers between in the range 101-200 are: [110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 122, 123, 124, 125, 126, 127, 128, 129, 133, 134, 135, 136, 137, 138, 139, 144, 145, 146, 147, 148, 149, 155, 156, 157, 158, 159, 166, 167, 168, 169, 177, 178, 179, 188, 189, 199, 200], that is 47 of them. In the following range, 201-300, there are 41 of them and so on, getting rarer and rarer.\n\n**Trivia:** just for the sake of your own curiosity, a number which is neither decreasing of increasing is called a `bouncy` number, like, say, 3848 or 37294; also, usually 0 is not considered being increasing, decreasing or bouncy, but it will be for the purpose of this kata", "starter_code": "\ndef total_inc_dec(x):\n\t", "test_cases": {"inputs": [[0], [1], [2], [3], [4], [5], [6], [10], [20], [50]], "outputs": [[1], [10], [100], [475], [1675], [4954], [12952], [277033], [40059819], [87959698326]], "fn_name": "total_inc_dec"}, "test_case_format": "function_call", "n_test_cases_total": 10, "n_test_cases_kept": 10, "test_cases_truncated": false, "problem_sha1": "0c5b0ec44ff44579ce4db3af961bc8fe9ab2868e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "total_inc_dec"}
{"seed_id": "apps-01186", "original_id": null, "source": "apps", "domain": "code", "problem": "Given two strings s1 and s2, we want to visualize how different the two strings are.\nWe will only take into account the *lowercase* letters (a to z).\nFirst let us count the frequency of each *lowercase* letters in s1 and s2.\n\n`s1 = \"A aaaa bb c\"`\n\n`s2 = \"& aaa bbb c d\"`\n\n`s1 has 4 'a', 2 'b', 1 'c'`\n\n`s2 has 3 'a', 3 'b', 1 'c', 1 'd'`\n\nSo the maximum for 'a' in s1 and s2 is 4 from s1; the maximum for 'b' is 3 from s2.\nIn the following we will not consider letters when the maximum of their occurrences\nis less than or equal to 1.\n\nWe can resume the differences between s1 and s2 in the following string:\n`\"1:aaaa/2:bbb\"`\nwhere `1` in `1:aaaa` stands for string s1 and `aaaa` because the maximum for `a` is 4.\nIn the same manner `2:bbb` stands for string s2 and `bbb` because the maximum for `b` is 3.\n\nThe task is to produce a string in which each *lowercase* letters of s1 or s2 appears as many times as\nits maximum if this maximum is *strictly greater than 1*; these letters will be prefixed by the \nnumber of the string where they appear with their maximum value and `:`. \nIf the maximum is in s1 as well as in s2 the prefix is `=:`.\n\nIn the result, substrings (a substring is for example 2:nnnnn or 1:hhh; it contains the prefix) will be in decreasing order of their length and when they have the same length sorted in ascending lexicographic order (letters and digits - more precisely sorted by codepoint); the different groups will be separated by '/'. See examples and \"Example Tests\".\n\nHopefully other examples can make this clearer.\n\n```\ns1 = \"my&friend&Paul has heavy hats! &\"\ns2 = \"my friend John has many many friends &\"\nmix(s1, s2) --> \"2:nnnnn/1:aaaa/1:hhh/2:mmm/2:yyy/2:dd/2:ff/2:ii/2:rr/=:ee/=:ss\"\n\ns1 = \"mmmmm m nnnnn y&friend&Paul has heavy hats! &\"\ns2 = \"my frie n d Joh n has ma n y ma n y frie n ds n&\"\nmix(s1, s2) --> \"1:mmmmmm/=:nnnnnn/1:aaaa/1:hhh/2:yyy/2:dd/2:ff/2:ii/2:rr/=:ee/=:ss\"\n\ns1=\"Are the kids at home? aaaaa fffff\"\ns2=\"Yes they are here! aaaaa fffff\"\nmix(s1, s2) --> \"=:aaaaaa/2:eeeee/=:fffff/1:tt/2:rr/=:hh\"\n```\n# Note for Swift, R, PowerShell\nThe prefix `=:` is replaced by `E:`\n``` \ns1 = \"mmmmm m nnnnn y&friend&Paul has heavy hats! &\"\ns2 = \"my frie n d Joh n has ma n y ma n y frie n ds n&\"\nmix(s1, s2) --> \"1:mmmmmm/E:nnnnnn/1:aaaa/1:hhh/2:yyy/2:dd/2:ff/2:ii/2:rr/E:ee/E:ss\"\n```", "starter_code": "\ndef mix(s1, s2):\n\t", "test_cases": {"inputs": [["Are they here", "yes, they are here"], ["looping is fun but dangerous", "less dangerous than coding"], [" In many languages", " there's a pair of functions"], ["Lords of the Fallen", "gamekult"], ["codewars", "codewars"], ["A generation must confront the looming ", "codewarrs"]], "outputs": [["2:eeeee/2:yy/=:hh/=:rr"], ["1:ooo/1:uuu/2:sss/=:nnn/1:ii/2:aa/2:dd/2:ee/=:gg"], ["1:aaa/1:nnn/1:gg/2:ee/2:ff/2:ii/2:oo/2:rr/2:ss/2:tt"], ["1:ee/1:ll/1:oo"], [""], ["1:nnnnn/1:ooooo/1:tttt/1:eee/1:gg/1:ii/1:mm/=:rr"]], "fn_name": "mix"}, "test_case_format": "function_call", "n_test_cases_total": 6, "n_test_cases_kept": 6, "test_cases_truncated": false, "problem_sha1": "da960e33bf1fab342b8b1d812b5aad54a79587e2", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "mix"}
{"seed_id": "apps-01191", "original_id": null, "source": "apps", "domain": "code", "problem": "This is a very simply formulated task. Let's call an integer number `N` 'green' if `N²` ends with all of the digits of `N`. Some examples:\n\n`5` is green, because `5² = 25` and `25` ends with `5`.\n\n`11` is not green, because `11² = 121` and `121` does not end with `11`.\n\n`376` is green, because `376² = 141376` and `141376` ends with `376`.\n\nYour task is to write a function `green` that returns `n`th green number, starting with `1` - `green (1) == 1`\n\n---\n\n## Data range\n\n```if:haskell\n`n <= 4000` for Haskell\n```\n```if:java\n`n <= 5000` for Java\n```\n```if:python\n`n <= 5000` for Python\n```\n```if:javascript\n`n <= 3000` for JavaScript\n\nReturn values should be `String`s, and should be exact. A BigNum library is recommended.\n```", "starter_code": "\ndef green(n):\n\t", "test_cases": {"inputs": [[1], [2], [3], [4], [12], [13], [100], [110]], "outputs": [[1], [5], [6], [25], [2890625], [7109376], [6188999442576576769103890995893380022607743740081787109376], [9580863811000557423423230896109004106619977392256259918212890625]], "fn_name": "green"}, "test_case_format": "function_call", "n_test_cases_total": 8, "n_test_cases_kept": 8, "test_cases_truncated": false, "problem_sha1": "366e2b4369bcb2245cd81a4f6a4bac01b7148023", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "green"}
{"seed_id": "apps-01196", "original_id": null, "source": "apps", "domain": "code", "problem": "To give credit where credit is due: This problem was taken from the ACMICPC-Northwest Regional Programming Contest. Thank you problem writers.\n\nYou are helping an archaeologist decipher some runes. He knows that this ancient society used a Base 10 system, and that they never start a number with a leading zero. He's figured out most of the digits as well as a few operators, but he needs your help to figure out the rest.\n\nThe professor will give you a simple math expression, of the form\n\n```\n[number][op][number]=[number]\n```\n\nHe has converted all of the runes he knows into digits. The only operators he knows are addition (`+`),subtraction(`-`), and multiplication (`*`), so those are the only ones that will appear. Each number will be in the range from -1000000 to 1000000, and will consist of only the digits 0-9, possibly a leading -, and maybe a few ?s. If there are ?s in an expression, they represent a digit rune that the professor doesn't know (never an operator, and never a leading -). All of the ?s in an expression will represent the same digit (0-9), and it won't be one of the other given digits in the expression. No number will begin with a 0 unless the number itself is  0, therefore 00 would not be a valid number. \n\nGiven an expression, figure out the value of the rune represented by the question mark. If more than one digit works, give the lowest one. If no digit works, well, that's bad news for the professor - it means that he's got some of his runes wrong. output -1 in that case.\n\nComplete the method to solve the expression to find the value of the unknown rune. The method takes a string as a paramater repressenting the expression and will return an int value representing the unknown rune or -1 if no such rune exists.\n\n~~~if:php\n**Most of the time, the professor will be able to figure out most of the runes himself, but sometimes, there may be exactly 1 rune present in the expression that the professor cannot figure out (resulting in all question marks where the digits are in the expression) so be careful ;)**\n~~~", "starter_code": "\ndef solve_runes(runes):\n\t", "test_cases": {"inputs": [["123?45*?=?"], ["?*123?45=?"], ["??605*-63=-73???5"], ["123?45+?=123?45"], ["?8?170-1?6256=7?2?14"], ["?38???+595???=833444"], ["123?45-?=123?45"], ["-7715?5--484?00=-28?9?5"], ["50685?--1?5630=652?8?"], ["??+??=??"], ["-?56373--9216=-?47157"]], "outputs": [[0], [0], [1], [0], [9], [2], [0], [6], [4], [-1], [8]], "fn_name": "solve_runes"}, "test_case_format": "function_call", "n_test_cases_total": 11, "n_test_cases_kept": 11, "test_cases_truncated": false, "problem_sha1": "8234333b8747bea9fc63f05c06bfc4cb665e497d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "solve_runes"}
{"seed_id": "apps-01201", "original_id": null, "source": "apps", "domain": "code", "problem": "In this Kata we focus on finding a sum S(n) which is the total number of divisors taken for all natural numbers less or equal to n. More formally, we investigate the sum of n components denoted by d(1) + d(2) + ... + d(n) in which for any i starting from 1 up to n the value of d(i) tells us how many distinct numbers divide i without a remainder. \n\nYour solution should work for possibly large values of n without a timeout.\nAssume n to be greater than zero and not greater than 999 999 999 999 999.\nBrute force approaches will not be feasible options in such cases. It is fairly simple to conclude that for every n>1 there holds a recurrence S(n) = S(n-1) + d(n) with initial case S(1) = 1.\n\nFor example:\nS(1) = 1\nS(2) = 3\nS(3) = 5\nS(4) = 8\nS(5) = 10\n\nBut is the fact useful anyway? If you find it is rather not, maybe this will help: \n\nTry to convince yourself that for any natural k, the number S(k) is the same as the number of pairs (m,n) that solve the inequality mn <= k in natural numbers.\nOnce it becomes clear, we can think of a partition of all the solutions into classes just by saying that a pair (m,n) belongs to the class indexed by n.\nThe question now arises if it is possible to count solutions of n-th class. If f(n) stands for the number of solutions that belong to n-th class, it means that S(k) = f(1) + f(2) + f(3) + ...\n\nThe reasoning presented above leads us to some kind of a formula for S(k), however not necessarily the most efficient one. Can you imagine that all the solutions to inequality mn <= k can be split using sqrt(k) as pivotal item?", "starter_code": "\ndef count_divisors(n):\n\t", "test_cases": {"inputs": [[5], [10], [20], [59], [105], [785], [1001], [8009], [9999999999999], [9999999999998], [9999999999995], [9999999949950]], "outputs": [[10], [27], [66], [249], [510], [5364], [7077], [73241], [300880375389561], [300880375389537], [300880375389493], [300880373832097]], "fn_name": "count_divisors"}, "test_case_format": "function_call", "n_test_cases_total": 12, "n_test_cases_kept": 12, "test_cases_truncated": false, "problem_sha1": "1ed6666b60bb3eed8b86f15e92f6e9fde41bea0e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "count_divisors"}
{"seed_id": "apps-01206", "original_id": null, "source": "apps", "domain": "code", "problem": "-----Description-----\nThe Antique Comedians of India prefer comedies to tragedies. Unfortunately, most of the ancient plays are tragedies. Therefore the dramatic advisor of ACI has decided to transfigure some tragedies into comedies. Obviously, this work is very hard because the basic sense of the play must be kept intact, although all the things change to their opposites. For example the numbers: if any number appears in the tragedy, it must be converted to its reversed form before being accepted into the comedy play. A reversed number is a number written in Arabic numerals but the order of digits is reversed. The first digit becomes last and vice versa. For example, if the main hero had 1245 strawberries in the tragedy, he has 5421 of them now. Note that all the leading zeros are omitted. That means if the number ends with a zero, the zero is lost by reversing (e.g. 1200 gives 21). Also, note that the reversed number never has any trailing zeros. ACI needs to calculate with reversed numbers. Your task is to add two reversed numbers and output their reversed sum. Of course, the result is not unique because any particular number is a reversed form of several numbers (e.g. 23 could be 32, 320, or 3200 before reversing). Thus we must assume that no zeros were lost by reversing (e.g. assume that the original number was 23).\n\n-----Input-----\nThe input consists of N cases. The first line of the input contains only positive integer N. Then follow the cases. Each case consists of exactly one line with two positive integers separated by space. These are the reversed numbers you are to add. Numbers will be at most 200 characters long.\n\n-----Output-----\nFor each case, print exactly one line containing only one integer - the reversed sum of two reversed numbers. Omit any leading zeros in the output.\n\n-----Sample Input-----\n3\n24 1\n4358 754\n305 794\n\n-----Sample Output-----\n34\n1998\n1", "starter_code": "", "test_cases": {"inputs": ["3\n24 1\n4358 754\n305 794"], "outputs": ["34\n1998\n1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e4c450c236ed2e41ab8226210293c02a4a3c4915", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01211", "original_id": null, "source": "apps", "domain": "code", "problem": "Toad Zitz has an array of integers, each integer is between $0$ and $m-1$ inclusive. The integers are $a_1, a_2, \\ldots, a_n$.\n\nIn one operation Zitz can choose an integer $k$ and $k$ indices $i_1, i_2, \\ldots, i_k$ such that $1 \\leq i_1 < i_2 < \\ldots < i_k \\leq n$. He should then change $a_{i_j}$ to $((a_{i_j}+1) \\bmod m)$ for each chosen integer $i_j$. The integer $m$ is fixed for all operations and indices.\n\nHere $x \\bmod y$ denotes the remainder of the division of $x$ by $y$.\n\nZitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.\n\n\n-----Input-----\n\nThe first line contains two integers $n$ and $m$ ($1 \\leq n, m \\leq 300\\,000$) — the number of integers in the array and the parameter $m$.\n\nThe next line contains $n$ space-separated integers $a_1, a_2, \\ldots, a_n$ ($0 \\leq a_i < m$) — the given array.\n\n\n-----Output-----\n\nOutput one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print $0$.\n\nIt is easy to see that with enough operations Zitz can always make his array non-decreasing.\n\n\n-----Examples-----\nInput\n5 3\n0 0 0 1 2\n\nOutput\n0\n\nInput\n5 7\n0 6 1 3 2\n\nOutput\n1\n\n\n\n-----Note-----\n\nIn the first example, the array is already non-decreasing, so the answer is $0$.\n\nIn the second example, you can choose $k=2$, $i_1 = 2$, $i_2 = 5$, the array becomes $[0,0,1,3,3]$. It is non-decreasing, so the answer is $1$.", "starter_code": "", "test_cases": {"inputs": ["5 3\n0 0 0 1 2\n", "5 7\n0 6 1 3 2\n", "10 10\n5 0 5 9 4 6 4 5 0 0\n", "4 6\n0 3 5 1\n", "6 4\n1 3 0 2 1 0\n", "10 1000\n981 824 688 537 969 72 39 734 929 718\n", "10 300000\n111862 91787 271781 182224 260248 142019 30716 102643 141870 19206\n", "100 10\n8 4 4 9 0 7 9 5 1 1 2 3 7 1 8 4 8 8 6 0 8 7 8 3 7 0 6 4 8 4 2 7 0 0 3 8 4 4 2 0 0 4 7 2 4 7 9 1 3 3 6 2 9 6 0 6 3 5 6 5 5 3 0 0 8 7 1 4 2 4 1 3 9 7 9 0 6 6 7 4 2 3 7 1 7 3 5 1 4 3 7 5 7 5 0 5 1 9 0 9\n", "100 1\n0 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 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\n", "100 2\n1 1 0 1 0 1 0 0 0 1 0 1 0 0 1 1 1 1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 1 1 1 0 1 0 0 1 0 0 1 0 1 0 1 1 1 0 1 1 0 1 1 0 1 0 0 0 1 0 1 1 0 1 1 0 1 0 1 0 0 0 0 0 1 0 0 0 0 1 1 1\n", "100 1000\n980 755 745 448 424 691 210 545 942 979 555 783 425 942 495 741 487 514 752 434 187 874 372 617 414 505 659 445 81 397 243 986 441 587 31 350 831 801 194 103 723 166 108 182 252 846 328 905 639 690 738 638 986 340 559 626 572 808 442 410 179 549 880 153 449 99 434 945 163 687 173 797 999 274 975 626 778 456 407 261 988 43 25 391 937 856 54 110 884 937 940 205 338 250 903 244 424 871 979 810\n", "1 1\n0\n", "10 10\n1 2 3 4 5 6 7 8 9 0\n", "2 1\n0 0\n", "2 2\n0 1\n", "2 2\n1 0\n"], "outputs": ["0\n", "1\n", "6\n", "3\n", "2\n", "463\n", "208213\n", "8\n", "0\n", "1\n", "860\n", "0\n", "9\n", "0\n", "0\n", "1\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 16, "n_test_cases_kept": 16, "test_cases_truncated": false, "problem_sha1": "7477ca77079da8a5f5dba12dd1243843abe4a38b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01216", "original_id": null, "source": "apps", "domain": "code", "problem": "Nikita likes tasks on order statistics, for example, he can easily find the $k$-th number in increasing order on a segment of an array. But now Nikita wonders how many segments of an array there are such that a given number $x$ is the $k$-th number in increasing order on this segment. In other words, you should find the number of segments of a given array such that there are exactly $k$ numbers of this segment which are less than $x$.\n\nNikita wants to get answer for this question for each $k$ from $0$ to $n$, where $n$ is the size of the array.\n\n\n-----Input-----\n\nThe first line contains two integers $n$ and $x$ $(1 \\le n \\le 2 \\cdot 10^5, -10^9 \\le x \\le 10^9)$.\n\nThe second line contains $n$ integers $a_1, a_2, \\ldots, a_n$ $(-10^9 \\le a_i \\le 10^9)$ — the given array.\n\n\n-----Output-----\n\nPrint $n+1$ integers, where the $i$-th number is the answer for Nikita's question for $k=i-1$.\n\n\n-----Examples-----\nInput\n5 3\n1 2 3 4 5\n\nOutput\n6 5 4 0 0 0 \nInput\n2 6\n-5 9\n\nOutput\n1 2 0 \nInput\n6 99\n-1 -1 -1 -1 -1 -1\n\nOutput\n0 6 5 4 3 2 1", "starter_code": "", "test_cases": {"inputs": ["5 3\n1 2 3 4 5\n", "2 6\n-5 9\n", "6 99\n-1 -1 -1 -1 -1 -1\n", "5 -2\n-1 -1 -4 -5 1\n", "5 -6\n-4 2 -7 -1 -5\n", "10 29\n88 57 -3 -9 16 48 -84 80 -73 -46\n", "1 1000000000\n1\n", "2 -1000000000\n465132 210\n", "10 -8\n7 -1 0 -8 8 -1 -10 -7 4 0\n", "10 9\n-2 6 0 -6 7 -8 -5 4 -3 3\n", "10 5\n-3 2 1 -5 -3 6 -5 10 -10 -10\n", "10 -3\n-7 6 6 9 4 0 3 8 9 -2\n", "10 -7\n5 5 6 6 7 10 3 -7 -2 5\n"], "outputs": ["6 5 4 0 0 0 ", "1 2 0 ", "0 6 5 4 3 2 1 ", "4 5 6 0 0 0 ", "6 9 0 0 0 0 ", "5 13 11 11 8 4 3 0 0 0 0 ", "0 1 ", "3 0 0 ", "27 28 0 0 0 0 0 0 0 0 0 ", "0 10 9 8 7 6 5 4 3 2 1 ", "2 13 11 9 7 6 4 2 1 0 0 ", "45 10 0 0 0 0 0 0 0 0 0 ", "55 0 0 0 0 0 0 0 0 0 0 "]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 13, "n_test_cases_kept": 13, "test_cases_truncated": false, "problem_sha1": "d17a11f4245bc21d3206e0ee71f6b0ea7f10f178", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01221", "original_id": null, "source": "apps", "domain": "code", "problem": "Bessie and the cows are playing with sequences and need your help. They start with a sequence, initially containing just the number 0, and perform n operations. Each operation is one of the following:  Add the integer x_{i} to the first a_{i} elements of the sequence.  Append an integer k_{i} to the end of the sequence. (And hence the size of the sequence increases by 1)  Remove the last element of the sequence. So, the size of the sequence decreases by one. Note, that this operation can only be done if there are at least two elements in the sequence. \n\nAfter each operation, the cows would like to know the average of all the numbers in the sequence. Help them!\n\n\n-----Input-----\n\nThe first line contains a single integer n (1 ≤ n ≤ 2·10^5) — the number of operations. The next n lines describe the operations. Each line will start with an integer t_{i} (1 ≤ t_{i} ≤ 3), denoting the type of the operation (see above). If t_{i} = 1, it will be followed by two integers a_{i}, x_{i} (|x_{i}| ≤ 10^3; 1 ≤ a_{i}). If t_{i} = 2, it will be followed by a single integer k_{i} (|k_{i}| ≤ 10^3). If t_{i} = 3, it will not be followed by anything.\n\nIt is guaranteed that all operations are correct (don't touch nonexistent elements) and that there will always be at least one element in the sequence.\n\n\n-----Output-----\n\nOutput n lines each containing the average of the numbers in the sequence after the corresponding operation.\n\nThe answer will be considered correct if its absolute or relative error doesn't exceed 10^{ - 6}.\n\n\n-----Examples-----\nInput\n5\n2 1\n3\n2 3\n2 1\n3\n\nOutput\n0.500000\n0.000000\n1.500000\n1.333333\n1.500000\n\nInput\n6\n2 1\n1 2 20\n2 2\n1 2 -3\n3\n3\n\nOutput\n0.500000\n20.500000\n14.333333\n12.333333\n17.500000\n17.000000\n\n\n\n-----Note-----\n\nIn the second sample, the sequence becomes $\\{0 \\} \\rightarrow \\{0,1 \\} \\rightarrow \\{20,21 \\} \\rightarrow \\{20,21,2 \\} \\rightarrow \\{17,18,2 \\} \\rightarrow \\{17,18 \\} \\rightarrow \\{17 \\}$", "starter_code": "", "test_cases": {"inputs": ["5\n2 1\n3\n2 3\n2 1\n3\n", "6\n2 1\n1 2 20\n2 2\n1 2 -3\n3\n3\n", "1\n1 1 1\n", "1\n2 1\n", "2\n2 1\n1 2 1\n", "5\n2 1\n1 2 1\n2 1\n2 1\n1 2 1\n", "5\n1 1 7\n1 1 7\n1 1 7\n2 5\n1 2 2\n", "5\n1 1 -48\n1 1 19\n1 1 -35\n2 -67\n1 2 -13\n", "1\n1 1 0\n", "1\n2 0\n", "5\n2 -980\n1 2 -156\n2 641\n2 -253\n2 -514\n"], "outputs": ["0.500000\n0.000000\n1.500000\n1.333333\n1.500000\n", "0.500000\n20.500000\n14.333333\n12.333333\n17.500000\n17.000000\n", "1.000000\n", "0.500000\n", "0.500000\n1.500000\n", "0.500000\n1.500000\n1.333333\n1.250000\n1.750000\n", "7.000000\n14.000000\n21.000000\n13.000000\n15.000000\n", "-48.000000\n-29.000000\n-64.000000\n-65.500000\n-78.500000\n", "0.000000\n", "0.000000\n", "-490.000000\n-646.000000\n-217.000000\n-226.000000\n-283.600000\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 11, "n_test_cases_kept": 11, "test_cases_truncated": false, "problem_sha1": "cab5d837dc8ac9e3041a8029fec35c1d51d3f0f7", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01226", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given an array $a$ of $n$ integers and an integer $s$. It is guaranteed that $n$ is odd.\n\nIn one operation you can either increase or decrease any single element by one. Calculate the minimum number of operations required to make the median of the array being equal to $s$.\n\nThe median of the array with odd length is the value of the element which is located on the middle position after the array is sorted. For example, the median of the array $6, 5, 8$ is equal to $6$, since if we sort this array we will get $5, 6, 8$, and $6$ is located on the middle position.\n\n\n-----Input-----\n\nThe first line contains two integers $n$ and $s$ ($1\\le n\\le 2\\cdot 10^5-1$, $1\\le s\\le 10^9$) — the length of the array and the required value of median.\n\nThe second line contains $n$ integers $a_1, a_2, \\ldots, a_n$ ($1\\le a_i \\le 10^9$) — the elements of the array $a$.\n\nIt is guaranteed that $n$ is odd.\n\n\n-----Output-----\n\nIn a single line output the minimum number of operations to make the median being equal to $s$.\n\n\n-----Examples-----\nInput\n3 8\n6 5 8\n\nOutput\n2\nInput\n7 20\n21 15 12 11 20 19 12\n\nOutput\n6\n\n\n-----Note-----\n\nIn the first sample, $6$ can be increased twice. The array will transform to $8, 5, 8$, which becomes $5, 8, 8$ after sorting, hence the median is equal to $8$.\n\nIn the second sample, $19$ can be increased once and $15$ can be increased five times. The array will become equal to $21, 20, 12, 11, 20, 20, 12$. If we sort this array we get $11, 12, 12, 20, 20, 20, 21$, this way the median is $20$.", "starter_code": "", "test_cases": {"inputs": ["3 8\n6 5 8\n", "7 20\n21 15 12 11 20 19 12\n", "3 1\n1 2 5\n", "1 100\n105\n", "5 1\n2 2 4 6 1\n", "1 100\n88\n", "1 1\n100000\n", "3 4\n1 2 5\n", "1 1\n1\n", "3 10\n5 5 10\n"], "outputs": ["2", "6", "1", "5", "2", "12", "99999", "2", "0", "5"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 10, "n_test_cases_kept": 10, "test_cases_truncated": false, "problem_sha1": "e038295cfcc6b77d615809ba6673d34f795936c7", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01231", "original_id": null, "source": "apps", "domain": "code", "problem": "Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute\n\n$$ (a_1 + a_2) \\oplus (a_1 + a_3) \\oplus \\ldots \\oplus (a_1 + a_n) \\\\ \\oplus (a_2 + a_3) \\oplus \\ldots \\oplus (a_2 + a_n) \\\\ \\ldots \\\\ \\oplus (a_{n-1} + a_n) \\\\ $$\n\nHere $x \\oplus y$ is a bitwise XOR operation (i.e. $x$ ^ $y$ in many modern programming languages). You can read about it in Wikipedia: https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation.\n\n\n-----Input-----\n\nThe first line contains a single integer $n$ ($2 \\leq n \\leq 400\\,000$) — the number of integers in the array.\n\nThe second line contains integers $a_1, a_2, \\ldots, a_n$ ($1 \\leq a_i \\leq 10^7$).\n\n\n-----Output-----\n\nPrint a single integer — xor of all pairwise sums of integers in the given array.\n\n\n-----Examples-----\nInput\n2\n1 2\n\nOutput\n3\nInput\n3\n1 2 3\n\nOutput\n2\n\n\n-----Note-----\n\nIn the first sample case there is only one sum $1 + 2 = 3$.\n\nIn the second sample case there are three sums: $1 + 2 = 3$, $1 + 3 = 4$, $2 + 3 = 5$. In binary they are represented as $011_2 \\oplus 100_2 \\oplus 101_2 = 010_2$, thus the answer is 2.\n\n$\\oplus$ is the bitwise xor operation. To define $x \\oplus y$, consider binary representations of integers $x$ and $y$. We put the $i$-th bit of the result to be 1 when exactly one of the $i$-th bits of $x$ and $y$ is 1. Otherwise, the $i$-th bit of the result is put to be 0. For example, $0101_2 \\, \\oplus \\, 0011_2 = 0110_2$.", "starter_code": "", "test_cases": {"inputs": ["2\n1 2\n", "3\n1 2 3\n", "2\n1 1\n", "100\n1 2 3 4 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 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100\n", "50\n1 2 3 4 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 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n", "51\n50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100\n", "3\n2 2 8\n"], "outputs": ["3", "2", "2", "102", "3", "148", "4"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 7, "n_test_cases_kept": 7, "test_cases_truncated": false, "problem_sha1": "b89d72f6a93a50f14837030609233fd630369623", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01236", "original_id": null, "source": "apps", "domain": "code", "problem": "There is a country with $n$ citizens. The $i$-th of them initially has $a_{i}$ money. The government strictly controls the wealth of its citizens. Whenever a citizen makes a purchase or earns some money, they must send a receipt to the social services mentioning the amount of money they currently have.\n\nSometimes the government makes payouts to the poor: all citizens who have strictly less money than $x$ are paid accordingly so that after the payout they have exactly $x$ money. In this case the citizens don't send a receipt.\n\nYou know the initial wealth of every citizen and the log of all events: receipts and payouts. Restore the amount of money each citizen has after all events.\n\n\n-----Input-----\n\nThe first line contains a single integer $n$ ($1 \\le n \\le 2 \\cdot 10^{5}$) — the numer of citizens.\n\nThe next line contains $n$ integers $a_1$, $a_2$, ..., $a_n$ ($0 \\le a_{i} \\le 10^{9}$) — the initial balances of citizens.\n\nThe next line contains a single integer $q$ ($1 \\le q \\le 2 \\cdot 10^{5}$) — the number of events.\n\nEach of the next $q$ lines contains a single event. The events are given in chronological order.\n\nEach event is described as either 1 p x ($1 \\le p \\le n$, $0 \\le x \\le 10^{9}$), or 2 x ($0 \\le x \\le 10^{9}$). In the first case we have a receipt that the balance of the $p$-th person becomes equal to $x$. In the second case we have a payoff with parameter $x$.\n\n\n-----Output-----\n\nPrint $n$ integers — the balances of all citizens after all events.\n\n\n-----Examples-----\nInput\n4\n1 2 3 4\n3\n2 3\n1 2 2\n2 1\n\nOutput\n3 2 3 4 \n\nInput\n5\n3 50 2 1 10\n3\n1 2 0\n2 8\n1 3 20\n\nOutput\n8 8 20 8 10 \n\n\n\n-----Note-----\n\nIn the first example the balances change as follows: 1 2 3 4 $\\rightarrow$ 3 3 3 4 $\\rightarrow$ 3 2 3 4 $\\rightarrow$ 3 2 3 4\n\nIn the second example the balances change as follows: 3 50 2 1 10 $\\rightarrow$ 3 0 2 1 10 $\\rightarrow$ 8 8 8 8 10 $\\rightarrow$ 8 8 20 8 10", "starter_code": "", "test_cases": {"inputs": ["4\n1 2 3 4\n3\n2 3\n1 2 2\n2 1\n", "5\n3 50 2 1 10\n3\n1 2 0\n2 8\n1 3 20\n", "10\n1 2 3 4 5 6 7 8 9 10\n10\n2 1\n2 2\n2 3\n2 4\n2 5\n2 6\n2 7\n2 8\n2 9\n2 10\n", "5\n1 2 3 4 5\n10\n1 1 0\n2 1\n1 2 0\n2 2\n1 3 0\n2 3\n1 4 0\n2 4\n1 5 0\n2 5\n", "10\n7 9 4 4 7 6 3 7 9 8\n10\n1 3 2\n1 10 5\n1 5 3\n1 5 2\n1 2 9\n1 2 9\n1 2 10\n1 5 7\n1 6 10\n1 10 9\n", "1\n1\n3\n2 4\n1 1 2\n2 10\n"], "outputs": ["3 2 3 4 \n", "8 8 20 8 10 \n", "10 10 10 10 10 10 10 10 10 10 \n", "5 5 5 5 5 \n", "7 10 2 4 7 10 3 7 9 9 \n", "10 \n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 6, "n_test_cases_kept": 6, "test_cases_truncated": false, "problem_sha1": "a1bafe971cb2aa5175be86904967a16a984a3b17", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01241", "original_id": null, "source": "apps", "domain": "code", "problem": "Let's denote as $\\text{popcount}(x)$ the number of bits set ('1' bits) in the binary representation of the non-negative integer x.\n\nYou are given multiple queries consisting of pairs of integers l and r. For each query, find the x, such that l ≤ x ≤ r, and $\\text{popcount}(x)$ is maximum possible. If there are multiple such numbers find the smallest of them.\n\n\n-----Input-----\n\nThe first line contains integer n — the number of queries (1 ≤ n ≤ 10000).\n\nEach of the following n lines contain two integers l_{i}, r_{i} — the arguments for the corresponding query (0 ≤ l_{i} ≤ r_{i} ≤ 10^18).\n\n\n-----Output-----\n\nFor each query print the answer in a separate line.\n\n\n-----Examples-----\nInput\n3\n1 2\n2 4\n1 10\n\nOutput\n1\n3\n7\n\n\n\n-----Note-----\n\nThe binary representations of numbers from 1 to 10 are listed below:\n\n1_10 = 1_2\n\n2_10 = 10_2\n\n3_10 = 11_2\n\n4_10 = 100_2\n\n5_10 = 101_2\n\n6_10 = 110_2\n\n7_10 = 111_2\n\n8_10 = 1000_2\n\n9_10 = 1001_2\n\n10_10 = 1010_2", "starter_code": "", "test_cases": {"inputs": ["3\n1 2\n2 4\n1 10\n", "55\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n2 2\n2 3\n2 4\n2 5\n2 6\n2 7\n2 8\n2 9\n2 10\n3 3\n3 4\n3 5\n3 6\n3 7\n3 8\n3 9\n3 10\n4 4\n4 5\n4 6\n4 7\n4 8\n4 9\n4 10\n5 5\n5 6\n5 7\n5 8\n5 9\n5 10\n6 6\n6 7\n6 8\n6 9\n6 10\n7 7\n7 8\n7 9\n7 10\n8 8\n8 9\n8 10\n9 9\n9 10\n10 10\n", "18\n1 10\n1 100\n1 1000\n1 10000\n1 100000\n1 1000000\n1 10000000\n1 100000000\n1 1000000000\n1 10000000000\n1 100000000000\n1 1000000000000\n1 10000000000000\n1 100000000000000\n1 1000000000000000\n1 10000000000000000\n1 100000000000000000\n1 1000000000000000000\n", "3\n0 0\n1 3\n2 4\n", "17\n0 0\n0 8\n1 8\n36 39\n3 4\n3 7\n2 17\n8 12\n9 12\n10 12\n10 15\n6 14\n8 15\n9 15\n15 15\n100000000000000000 1000000000000000000\n99999999999999999 1000000000000000000\n"], "outputs": ["1\n3\n7\n", "1\n1\n3\n3\n3\n3\n7\n7\n7\n7\n2\n3\n3\n3\n3\n7\n7\n7\n7\n3\n3\n3\n3\n7\n7\n7\n7\n4\n5\n5\n7\n7\n7\n7\n5\n5\n7\n7\n7\n7\n6\n7\n7\n7\n7\n7\n7\n7\n7\n8\n9\n9\n9\n9\n10\n", "7\n63\n511\n8191\n65535\n524287\n8388607\n67108863\n536870911\n8589934591\n68719476735\n549755813887\n8796093022207\n70368744177663\n562949953421311\n9007199254740991\n72057594037927935\n576460752303423487\n", "0\n3\n3\n", "0\n7\n7\n39\n3\n7\n15\n11\n11\n11\n15\n7\n15\n15\n15\n576460752303423487\n576460752303423487\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 5, "n_test_cases_kept": 5, "test_cases_truncated": false, "problem_sha1": "7cdf7662d92787e2a34a5073a74ecd571a12cda2", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01246", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a rectangular parallelepiped with sides of positive integer lengths $A$, $B$ and $C$. \n\nFind the number of different groups of three integers ($a$, $b$, $c$) such that $1\\leq a\\leq b\\leq c$ and parallelepiped $A\\times B\\times C$ can be paved with parallelepipeds $a\\times b\\times c$. Note, that all small parallelepipeds have to be rotated in the same direction.\n\nFor example, parallelepiped $1\\times 5\\times 6$ can be divided into parallelepipeds $1\\times 3\\times 5$, but can not be divided into parallelepipeds $1\\times 2\\times 3$.\n\n\n-----Input-----\n\nThe first line contains a single integer $t$ ($1 \\leq t \\leq 10^5$) — the number of test cases.\n\nEach of the next $t$ lines contains three integers $A$, $B$ and $C$ ($1 \\leq A, B, C \\leq 10^5$) — the sizes of the parallelepiped.\n\n\n-----Output-----\n\nFor each test case, print the number of different groups of three points that satisfy all given conditions.\n\n\n-----Example-----\nInput\n4\n1 1 1\n1 6 1\n2 2 2\n100 100 100\n\nOutput\n1\n4\n4\n165\n\n\n\n-----Note-----\n\nIn the first test case, rectangular parallelepiped $(1, 1, 1)$ can be only divided into rectangular parallelepiped with sizes $(1, 1, 1)$.\n\nIn the second test case, rectangular parallelepiped $(1, 6, 1)$ can be divided into rectangular parallelepipeds with sizes $(1, 1, 1)$, $(1, 1, 2)$, $(1, 1, 3)$ and $(1, 1, 6)$.\n\nIn the third test case, rectangular parallelepiped $(2, 2, 2)$ can be divided into rectangular parallelepipeds with sizes $(1, 1, 1)$, $(1, 1, 2)$, $(1, 2, 2)$ and $(2, 2, 2)$.", "starter_code": "", "test_cases": {"inputs": ["4\n1 1 1\n1 6 1\n2 2 2\n100 100 100\n", "10\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n", "10\n9 6 8\n5 5 2\n8 9 2\n2 7 9\n6 4 10\n1 1 8\n2 8 1\n10 6 3\n7 5 2\n9 5 4\n", "1\n100000 100000 100000\n"], "outputs": ["1\n4\n4\n165\n", "1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n", "41\n6\n21\n12\n39\n4\n7\n26\n8\n18\n", "8436\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 4, "n_test_cases_kept": 4, "test_cases_truncated": false, "problem_sha1": "b6f64b482234daa908e270c793fdaade65b59933", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01251", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given two integer sequences, each of length N: a_1, ..., a_N and b_1, ..., b_N.\nThere are N^2 ways to choose two integers i and j such that 1 \\leq i, j \\leq N. For each of these N^2 pairs, we will compute a_i + b_j and write it on a sheet of paper.\nThat is, we will write N^2 integers in total.\nCompute the XOR of these N^2 integers.\nDefinition of XOR\nThe XOR of integers c_1, c_2, ..., c_m is defined as follows:\n - Let the XOR be X. In the binary representation of X, the digit in the 2^k's place (0 \\leq k; k is an integer) is 1 if there are an odd number of integers among c_1, c_2, ...c_m whose binary representation has 1 in the 2^k's place, and 0 if that number is even.\nFor example, let us compute the XOR of 3 and 5. The binary representation of 3 is 011, and the binary representation of 5 is 101, thus the XOR has the binary representation 110, that is, the XOR is 6.\n\n-----Constraints-----\n - All input values are integers.\n - 1 \\leq N \\leq 200,000\n - 0 \\leq a_i, b_i < 2^{28}\n\n-----Input-----\nInput is given from Standard Input in the following format:\nN\na_1 a_2 ... a_N\nb_1 b_2 ... b_N\n\n-----Output-----\nPrint the result of the computation.\n\n-----Sample Input-----\n2\n1 2\n3 4\n\n-----Sample Output-----\n2\n\nOn the sheet, the following four integers will be written: 4(1+3), 5(1+4), 5(2+3) and 6(2+4).", "starter_code": "", "test_cases": {"inputs": ["2\n1 2\n3 4\n", "6\n4 6 0 0 3 3\n0 5 6 5 0 3\n", "5\n1 2 3 4 5\n1 2 3 4 5\n", "1\n0\n0\n"], "outputs": ["2\n", "8\n", "2\n", "0\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 4, "n_test_cases_kept": 4, "test_cases_truncated": false, "problem_sha1": "77f998863e7efb46a6d58a49546ce372cafe1cdd", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01256", "original_id": null, "source": "apps", "domain": "code", "problem": "Let x be a string of length at least 1.\nWe will call x a good string, if for any string y and any integer k (k \\geq 2), the string obtained by concatenating k copies of y is different from x.\nFor example, a, bbc and cdcdc are good strings, while aa, bbbb and cdcdcd are not.\nLet w be a string of length at least 1.\nFor a sequence F=(\\,f_1,\\,f_2,\\,...,\\,f_m) consisting of m elements,\nwe will call F a good representation of w, if the following conditions are both satisfied:\n - For any i \\, (1 \\leq i \\leq m), f_i is a good string.\n - The string obtained by concatenating f_1,\\,f_2,\\,...,\\,f_m in this order, is w.\nFor example, when w=aabb, there are five good representations of w:\n - (aabb)\n - (a,abb)\n - (aab,b)\n - (a,ab,b)\n - (a,a,b,b)\nAmong the good representations of w, the ones with the smallest number of elements are called the best representations of w.\nFor example, there are only one best representation of w=aabb: (aabb).\nYou are given a string w. Find the following:\n - the number of elements of a best representation of w\n - the number of the best representations of w, modulo 1000000007 \\, (=10^9+7)\n(It is guaranteed that a good representation of w always exists.)\n\n-----Constraints-----\n - 1 \\leq |w| \\leq 500000 \\, (=5 \\times 10^5)\n - w consists of lowercase letters (a-z).\n\n-----Partial Score-----\n - 400 points will be awarded for passing the test set satisfying 1 \\leq |w| \\leq 4000.\n\n-----Input-----\nThe input is given from Standard Input in the following format:\nw\n\n-----Output-----\nPrint 2 lines.\n - In the first line, print the number of elements of a best representation of w.\n - In the second line, print the number of the best representations of w, modulo 1000000007.\n\n-----Sample Input-----\naab\n\n-----Sample Output-----\n1\n1\n", "starter_code": "", "test_cases": {"inputs": ["aab\n", "bcbc\n", "ddd\n"], "outputs": ["1\n1\n", "2\n3\n", "3\n1\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 3, "n_test_cases_kept": 3, "test_cases_truncated": false, "problem_sha1": "368770074c3dae4d59a3f5388bb1942e1e59e46e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01261", "original_id": null, "source": "apps", "domain": "code", "problem": "For an array $b$ of length $m$ we define the function $f$ as  $ f(b) = \\begin{cases} b[1] & \\quad \\text{if } m = 1 \\\\ f(b[1] \\oplus b[2],b[2] \\oplus b[3],\\dots,b[m-1] \\oplus b[m]) & \\quad \\text{otherwise,} \\end{cases} $ \n\nwhere $\\oplus$ is bitwise exclusive OR.\n\nFor example, $f(1,2,4,8)=f(1\\oplus2,2\\oplus4,4\\oplus8)=f(3,6,12)=f(3\\oplus6,6\\oplus12)=f(5,10)=f(5\\oplus10)=f(15)=15$\n\nYou are given an array $a$ and a few queries. Each query is represented as two integers $l$ and $r$. The answer is the maximum value of $f$ on all continuous subsegments of the array $a_l, a_{l+1}, \\ldots, a_r$.\n\n\n-----Input-----\n\nThe first line contains a single integer $n$ ($1 \\le n \\le 5000$) — the length of $a$.\n\nThe second line contains $n$ integers $a_1, a_2, \\dots, a_n$ ($0 \\le a_i \\le 2^{30}-1$) — the elements of the array.\n\nThe third line contains a single integer $q$ ($1 \\le q \\le 100\\,000$) — the number of queries.\n\nEach of the next $q$ lines contains a query represented as two integers $l$, $r$ ($1 \\le l \\le r \\le n$).\n\n\n-----Output-----\n\nPrint $q$ lines — the answers for the queries.\n\n\n-----Examples-----\nInput\n3\n8 4 1\n2\n2 3\n1 2\n\nOutput\n5\n12\n\nInput\n6\n1 2 4 8 16 32\n4\n1 6\n2 5\n3 4\n1 2\n\nOutput\n60\n30\n12\n3\n\n\n\n-----Note-----\n\nIn first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.\n\nIn second sample, optimal segment for first query are $[3,6]$, for second query — $[2,5]$, for third — $[3,4]$, for fourth — $[1,2]$.", "starter_code": "", "test_cases": {"inputs": ["3\n8 4 1\n2\n2 3\n1 2\n", "6\n1 2 4 8 16 32\n4\n1 6\n2 5\n3 4\n1 2\n"], "outputs": ["5\n12\n", "60\n30\n12\n3\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 2, "n_test_cases_kept": 2, "test_cases_truncated": false, "problem_sha1": "7ef2c8b9eb19c69371ebeb1678170a734da3e909", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01266", "original_id": null, "source": "apps", "domain": "code", "problem": "When Misha hits his favorite gym, he comes across an interesting problem with the barbell. In the gym, someone always leaves the weight plates in the strangest places you can imagine and sometime it's difficult to equip the barbell the way you want. Let's imagine that you have N weight plates placed in any order (remember that any gym has no more than K different types of weight plates and all weights are square-free). As a preliminary step towards solving this problem, Misha wants to simulate a simple gym, and for this purpose you have to deal with some queries:\n\n- [1 I X] Set the weight of the ith weight plate to value X.\n\n- [2 L R] Reverse the sequence of weight plates in the interval from L to R, where 1 ≤ L ≤ R ≤ N.\n\n- [3 L R W] Check the interval from L to R to find out if you can make the weight W using only weight plates on this interval. (Note: this type of query will appear no more than P times)\n\nPlease help Misha in solving this problem. \n\n-----Input-----\nFirst line of input contains the number of weight plates N, and number of queries Q. Next line contains N integers w1, w2, ..., wN, where wi is the weight of the ith weight plate. Next Q lines contain some queries described above. \n\n-----Output-----\nFor all queries of the third type: print \"Yes\" if your check returns a positive outcome, and \"No\" otherwise.\n\n-----Constraints-----\n- 1 ≤ N, W, Q ≤ 105\n- K ≤ 10\n- P ≤ 1000\n- All numbers in the input are positive integers and ≤ 105.\n- All the weights are square-free.\n\n-----Subtasks-----\n- Subtask 1: 1 ≤ N ≤ 103, 1 ≤ W ≤ 103, Q = 1 - 10 pts.\n\n- Subtask 2: 1 ≤ N ≤ 103, 1 ≤ W ≤ 103, 1 ≤ Q ≤ 103, P ≤ 100 - 15 pts\n- Subtask 3: 1 ≤ N ≤ 104, 1 ≤ W ≤ 104, 1 ≤ Q ≤ 104, P ≤ 300 - 25 pts.\n\n- Subtask 4: 1 ≤ N ≤ 105, 1 ≤ W ≤ 105, 1 ≤ Q ≤ 105, K ≤ 2 - 20 pts.\n\n- Subtask 5: Original constraints - 30 pts.\n\n-----Example-----First\nInput:5 10\n1 2 3 5 6\n3 2 3 3\n3 2 3 4\n3 2 3 5\n2 2 5\n3 2 4 8\n1 2 1\n3 2 4 8\n2 1 4 \n3 2 4 3 \n3 1 5 7 \n\nOutput:Yes\nNo\nYes\nYes\nYes\nNo\nYesSecond\nInput:3 4\n2013 2015 2017\n3 1 3 4030\n1 1 111\n3 1 3 4030\n3 1 2 111\n\nOutput:Yes\nNo\nYes\n\n-----Explanation:-----First test explanation (step by step)\n1 2 3 5 6\n3 2 3 3 ([2, 3] 3=3 => Yes)\n3 2 3 4 ([2, 3] can't make 4 => No)\n3 2 3 5 ([2, 3] 2+3=5 => Yes)\n2 2 5 (Reverse: [1, 6, 5, 3, 2])\n3 2 4 8 ([6, 5, 3] 5+3=8 => Yes)\n1 2 1 (Set: [1, 1, 5, 3, 2])\n3 2 4 8 ([1, 5, 3] 5+3=8 => Yes)\n2 1 4  (Reverse: [3, 5, 1, 1, 2])\n3 2 4 3 ([5, 1, 1] can't make 3 => No)\n3 1 5 7 ([3, 5, 1, 1, 2] 2+1+1+3=7 => Yes)", "starter_code": "", "test_cases": {"inputs": ["5 10\n1 2 3 5 6\n3 2 3 3\n3 2 3 4\n3 2 3 5\n2 2 5\n3 2 4 8\n1 2 1\n3 2 4 8\n2 1 4 \n3 2 4 3 \n3 1 5 7 ", "3 4\n2013 2015 2017\n3 1 3 4030\n1 1 111\n3 1 3 4030\n3 1 2 111"], "outputs": ["Yes\nNo\nYes\nYes\nYes\nNo\nYes", "Yes\nNo\nYes"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 2, "n_test_cases_kept": 2, "test_cases_truncated": false, "problem_sha1": "ff85a8b00eebaee9719c82c5eb458cf0e3a18598", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01271", "original_id": null, "source": "apps", "domain": "code", "problem": "A hypergraph is a generalization of a graph, where an edge can connect any number of vertices. A k-uniform hypergraph is a hypergraph such that all its hyperedges have size k. For more information, see Wikipedia.\n\nLet's call a particular hypergraph a hypertree if it is connected (that is, you can move from any vertex to any other vertex using only its hyperedges) and removing any of its hyperedges makes the hypergraph disconnected (note that this definition of hypertrees differs from the standard one).\n\nGiven just one integer N, find the number of 3-uniform hypertrees on N vertices. Two 3-uniform hypertrees are considered different if a hyperedge (u, v, w) exists such that it is present in exactly one of these hypertrees (note that the order of vertices in the hyperedge doesn't matter, and neither does the order of hyperedges in the hypertree).\n\n-----Input-----\nThe first line of the input contains an integer T -- the number of test cases (at most 15). Then T lines follow, each contains an integer N (3 ≤ N ≤ 17).\n\nImportant! Please include all code used in solving this problem in your solution.\n\n-----Output-----\nFor each test case output one line containing the requested number. It's guaranteed that this number won't exceed 263-1.\n\n-----Examples-----\nInput:\n4\n3\n4\n5\n8\n\nOutput:\n1\n6\n25\n93268\n\nExplanation:\nThere is just one 3-uniform hypertree on 3 vertices: {(1,2,3)}. There are six of them on 4 vertices: {(1,2,3), (1,2,4)}, {(1,2,3), (1,3,4)}, {(1,2,3), (2,3,4)}, {(1,2,4), (1,3,4)}, {(1,2,4), (2,3,4)}, {(1,3,4), (2,3,4)}. Two of the 25 possible hypertrees on 5 vertices are {(1,2,3), (3,4,5)} and {(1,2,3), (1,2,4), (1,2,5)}.", "starter_code": "", "test_cases": {"inputs": ["4\n3\n4\n5\n8\n\n"], "outputs": ["1\n6\n25\n93268"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "92e837ea52401f8aff951f7dc3dc470e33d6f8e6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01276", "original_id": null, "source": "apps", "domain": "code", "problem": "The only difference between easy and hard versions is constraints.\n\nYou are given a sequence $a$ consisting of $n$ positive integers.\n\nLet's define a three blocks palindrome as the sequence, consisting of at most two distinct elements (let these elements are $a$ and $b$, $a$ can be equal $b$) and is as follows: $[\\underbrace{a, a, \\dots, a}_{x}, \\underbrace{b, b, \\dots, b}_{y}, \\underbrace{a, a, \\dots, a}_{x}]$. There $x, y$ are integers greater than or equal to $0$. For example, sequences $[]$, $[2]$, $[1, 1]$, $[1, 2, 1]$, $[1, 2, 2, 1]$ and $[1, 1, 2, 1, 1]$ are three block palindromes but $[1, 2, 3, 2, 1]$, $[1, 2, 1, 2, 1]$ and $[1, 2]$ are not.\n\nYour task is to choose the maximum by length subsequence of $a$ that is a three blocks palindrome.\n\nYou have to answer $t$ independent test cases.\n\nRecall that the sequence $t$ is a a subsequence of the sequence $s$ if $t$ can be derived from $s$ by removing zero or more elements without changing the order of the remaining elements. For example, if $s=[1, 2, 1, 3, 1, 2, 1]$, then possible subsequences are: $[1, 1, 1, 1]$, $[3]$ and $[1, 2, 1, 3, 1, 2, 1]$, but not $[3, 2, 3]$ and $[1, 1, 1, 1, 2]$.\n\n\n-----Input-----\n\nThe first line of the input contains one integer $t$ ($1 \\le t \\le 2000$) — the number of test cases. Then $t$ test cases follow.\n\nThe first line of the test case contains one integer $n$ ($1 \\le n \\le 2000$) — the length of $a$. The second line of the test case contains $n$ integers $a_1, a_2, \\dots, a_n$ ($1 \\le a_i \\le 26$), where $a_i$ is the $i$-th element of $a$. Note that the maximum value of $a_i$ can be up to $26$.\n\nIt is guaranteed that the sum of $n$ over all test cases does not exceed $2000$ ($\\sum n \\le 2000$).\n\n\n-----Output-----\n\nFor each test case, print the answer — the maximum possible length of some subsequence of $a$ that is a three blocks palindrome.\n\n\n-----Example-----\nInput\n6\n8\n1 1 2 2 3 2 1 1\n3\n1 3 3\n4\n1 10 10 1\n1\n26\n2\n2 1\n3\n1 1 1\n\nOutput\n7\n2\n4\n1\n1\n3", "starter_code": "", "test_cases": {"inputs": ["6\n8\n1 1 2 2 3 2 1 1\n3\n1 3 3\n4\n1 10 10 1\n1\n26\n2\n2 1\n3\n1 1 1\n"], "outputs": ["7\n2\n4\n1\n1\n3\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "6fc4fe2540bad97b9a0b679a83a85d5dc04c135b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01281", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a string $s[1 \\dots n]$ consisting of lowercase Latin letters. It is guaranteed that $n = 2^k$ for some integer $k \\ge 0$.\n\nThe string $s[1 \\dots n]$ is called $c$-good if at least one of the following three conditions is satisfied:  The length of $s$ is $1$, and it consists of the character $c$ (i.e. $s_1=c$); The length of $s$ is greater than $1$, the first half of the string consists of only the character $c$ (i.e. $s_1=s_2=\\dots=s_{\\frac{n}{2}}=c$) and the second half of the string (i.e. the string $s_{\\frac{n}{2} + 1}s_{\\frac{n}{2} + 2} \\dots s_n$) is a $(c+1)$-good string;  The length of $s$ is greater than $1$, the second half of the string consists of only the character $c$ (i.e. $s_{\\frac{n}{2} + 1}=s_{\\frac{n}{2} + 2}=\\dots=s_n=c$) and the first half of the string (i.e. the string $s_1s_2 \\dots s_{\\frac{n}{2}}$) is a $(c+1)$-good string. \n\nFor example: \"aabc\" is 'a'-good, \"ffgheeee\" is 'e'-good.\n\nIn one move, you can choose one index $i$ from $1$ to $n$ and replace $s_i$ with any lowercase Latin letter (any character from 'a' to 'z').\n\nYour task is to find the minimum number of moves required to obtain an 'a'-good string from $s$ (i.e. $c$-good string for $c=$ 'a'). It is guaranteed that the answer always exists.\n\nYou have to answer $t$ independent test cases.\n\nAnother example of an 'a'-good string is as follows. Consider the string $s = $\"cdbbaaaa\". It is an 'a'-good string, because:  the second half of the string (\"aaaa\") consists of only the character 'a';  the first half of the string (\"cdbb\") is 'b'-good string, because:   the second half of the string (\"bb\") consists of only the character 'b';  the first half of the string (\"cd\") is 'c'-good string, because:   the first half of the string (\"c\") consists of only the character 'c';  the second half of the string (\"d\") is 'd'-good string.   \n\n\n-----Input-----\n\nThe first line of the input contains one integer $t$ ($1 \\le t \\le 2 \\cdot 10^4$) — the number of test cases. Then $t$ test cases follow.\n\nThe first line of the test case contains one integer $n$ ($1 \\le n \\le 131~072$) — the length of $s$. It is guaranteed that $n = 2^k$ for some integer $k \\ge 0$. The second line of the test case contains the string $s$ consisting of $n$ lowercase Latin letters.\n\nIt is guaranteed that the sum of $n$ does not exceed $2 \\cdot 10^5$ ($\\sum n \\le 2 \\cdot 10^5$).\n\n\n-----Output-----\n\nFor each test case, print the answer — the minimum number of moves required to obtain an 'a'-good string from $s$ (i.e. $c$-good string with $c =$ 'a'). It is guaranteed that the answer exists.\n\n\n-----Example-----\nInput\n6\n8\nbbdcaaaa\n8\nasdfghjk\n8\nceaaaabb\n8\nbbaaddcc\n1\nz\n2\nac\n\nOutput\n0\n7\n4\n5\n1\n1", "starter_code": "", "test_cases": {"inputs": ["6\n8\nbbdcaaaa\n8\nasdfghjk\n8\nceaaaabb\n8\nbbaaddcc\n1\nz\n2\nac\n"], "outputs": ["0\n7\n4\n5\n1\n1\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "fe3ad2e457eb7d6598e3536f8ea866e7e3f13c64", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01286", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array arr of positive integers sorted in a strictly increasing order, and an integer k.\nFind the kth positive integer that is missing from this array.\n \nExample 1:\nInput: arr = [2,3,4,7,11], k = 5\nOutput: 9\nExplanation: The missing positive integers are [1,5,6,8,9,10,12,13,...]. The 5th missing positive integer is 9.\n\nExample 2:\nInput: arr = [1,2,3,4], k = 2\nOutput: 6\nExplanation: The missing positive integers are [5,6,7,...]. The 2nd missing positive integer is 6.\n\n \nConstraints:\n\n1 <= arr.length <= 1000\n1 <= arr[i] <= 1000\n1 <= k <= 1000\narr[i] < arr[j] for 1 <= i < j <= arr.length", "starter_code": "\nclass Solution:\n    def findKthPositive(self, arr: List[int], k: int) -> int:\n        ", "test_cases": {"inputs": [[[2, 3, 4, 7, 11], 5]], "outputs": [9], "fn_name": "findKthPositive"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "da1d38f027a45e4184e55317b0167dbc32d68c3e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "findKthPositive"}
{"seed_id": "apps-01291", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a positive integer num consisting only of digits 6 and 9.\nReturn the maximum number you can get by changing at most one digit (6 becomes 9, and 9 becomes 6).\n \nExample 1:\nInput: num = 9669\nOutput: 9969\nExplanation: \nChanging the first digit results in 6669.\nChanging the second digit results in 9969.\nChanging the third digit results in 9699.\nChanging the fourth digit results in 9666. \nThe maximum number is 9969.\n\nExample 2:\nInput: num = 9996\nOutput: 9999\nExplanation: Changing the last digit 6 to 9 results in the maximum number.\nExample 3:\nInput: num = 9999\nOutput: 9999\nExplanation: It is better not to apply any change.\n \nConstraints:\n\n1 <= num <= 10^4\nnum's digits are 6 or 9.", "starter_code": "\nclass Solution:\n    def maximum69Number (self, num: int) -> int:\n        ", "test_cases": {"inputs": [[9669]], "outputs": [9969], "fn_name": "maximum69Number"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e0867520acfc51c3d0a844f3e39bab1be7c8429d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maximum69Number"}
{"seed_id": "apps-01296", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array of integers arr, and three integers a, b and c. You need to find the number of good triplets.\nA triplet (arr[i], arr[j], arr[k]) is good if the following conditions are true:\n\n0 <= i < j < k < arr.length\n|arr[i] - arr[j]| <= a\n|arr[j] - arr[k]| <= b\n|arr[i] - arr[k]| <= c\n\nWhere |x| denotes the absolute value of x.\nReturn the number of good triplets.\n \nExample 1:\nInput: arr = [3,0,1,1,9,7], a = 7, b = 2, c = 3\nOutput: 4\nExplanation: There are 4 good triplets: [(3,0,1), (3,0,1), (3,1,1), (0,1,1)].\n\nExample 2:\nInput: arr = [1,1,2,2,3], a = 0, b = 0, c = 1\nOutput: 0\nExplanation: No triplet satisfies all conditions.\n\n \nConstraints:\n\n3 <= arr.length <= 100\n0 <= arr[i] <= 1000\n0 <= a, b, c <= 1000", "starter_code": "\nclass Solution:\n    def countGoodTriplets(self, arr: List[int], a: int, b: int, c: int) -> int:\n        ", "test_cases": {"inputs": [[[3, 0, 1, 1, 9, 7], 7, 2, 3]], "outputs": [4], "fn_name": "countGoodTriplets"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "10804601ffff2c7a924d5d86ef7e6cb3b9339840", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "countGoodTriplets"}
{"seed_id": "apps-01301", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.\n\nYou may assume that the array is non-empty and the majority element always exist in the array.\n\nExample 1:\n\n\nInput: [3,2,3]\nOutput: 3\n\nExample 2:\n\n\nInput: [2,2,1,1,1,2,2]\nOutput: 2", "starter_code": "\nclass Solution:\n    def majorityElement(self, nums: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[3, 2, 3]]], "outputs": [3], "fn_name": "majorityElement"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "dea6acf616994ca04511496b7a227d33da35889d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "majorityElement"}
{"seed_id": "apps-01306", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a binary array, find the maximum number of consecutive 1s in this array.\n\nExample 1:\n\nInput: [1,1,0,1,1,1]\nOutput: 3\nExplanation: The first two digits or the last three digits are consecutive 1s.\n    The maximum number of consecutive 1s is 3.\n\n\n\nNote:\n\nThe input array will only contain 0 and 1.\nThe length of input array is a positive integer and will not exceed 10,000", "starter_code": "\nclass Solution:\n    def findMaxConsecutiveOnes(self, nums: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[1, 0, 1, 1, 0, 1]]], "outputs": [2], "fn_name": "findMaxConsecutiveOnes"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "090bb4043078c6cc7d5c10e8bd9d24166e2b1eb2", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "findMaxConsecutiveOnes"}
{"seed_id": "apps-01311", "original_id": null, "source": "apps", "domain": "code", "problem": "We have two special characters. The first character can be represented by one bit 0. The second character can be represented by two bits (10 or 11).  \n\nNow given a string represented by several bits. Return whether the last character must be a one-bit character or not. The given string will always end with a zero.\n\nExample 1:\n\nInput: \nbits = [1, 0, 0]\nOutput: True\nExplanation: \nThe only way to decode it is two-bit character and one-bit character. So the last character is one-bit character.\n\n\n\nExample 2:\n\nInput: \nbits = [1, 1, 1, 0]\nOutput: False\nExplanation: \nThe only way to decode it is two-bit character and two-bit character. So the last character is NOT one-bit character.\n\n\n\nNote:\n1 .\nbits[i] is always 0 or 1.", "starter_code": "\nclass Solution:\n    def isOneBitCharacter(self, bits: List[int]) -> bool:\n        ", "test_cases": {"inputs": [[[1, 0, 0]]], "outputs": [true], "fn_name": "isOneBitCharacter"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "49d3db3840b90618de413f798a78737abfe7d731", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "isOneBitCharacter"}
{"seed_id": "apps-01316", "original_id": null, "source": "apps", "domain": "code", "problem": "Implement strStr().\n\nReturn the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.\n\nExample 1:\n\n\nInput: haystack = \"hello\", needle = \"ll\"\nOutput: 2\n\n\nExample 2:\n\n\nInput: haystack = \"aaaaa\", needle = \"bba\"\nOutput: -1\n\n\nClarification:\n\nWhat should we return when needle is an empty string? This is a great question to ask during an interview.\n\nFor the purpose of this problem, we will return 0 when needle is an empty string. This is consistent to C's strstr() and Java's indexOf().", "starter_code": "\nclass Solution:\n    def strStr(self, haystack: str, needle: str) -> int:\n        ", "test_cases": {"inputs": [["\"hello\"", "\"ll\""]], "outputs": [-1], "fn_name": "strStr"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "220303c58d2bf680546d46796d62ed118fb4228e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "strStr"}
{"seed_id": "apps-01321", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a positive integer n, find and return the longest distance between any two adjacent 1's in the binary representation of n. If there are no two adjacent 1's, return 0.\nTwo 1's are adjacent if there are only 0's separating them (possibly no 0's). The distance between two 1's is the absolute difference between their bit positions. For example, the two 1's in \"1001\" have a distance of 3.\n \nExample 1:\nInput: n = 22\nOutput: 2\nExplanation: 22 in binary is \"10110\".\nThe first adjacent pair of 1's is \"10110\" with a distance of 2.\nThe second adjacent pair of 1's is \"10110\" with a distance of 1.\nThe answer is the largest of these two distances, which is 2.\nNote that \"10110\" is not a valid pair since there is a 1 separating the two 1's underlined.\n\nExample 2:\nInput: n = 5\nOutput: 2\nExplanation: 5 in binary is \"101\".\n\nExample 3:\nInput: n = 6\nOutput: 1\nExplanation: 6 in binary is \"110\".\n\nExample 4:\nInput: n = 8\nOutput: 0\nExplanation: 8 in binary is \"1000\".\nThere aren't any adjacent pairs of 1's in the binary representation of 8, so we return 0.\n\nExample 5:\nInput: n = 1\nOutput: 0\n\n \nConstraints:\n\n1 <= n <= 109", "starter_code": "\nclass Solution:\n    def binaryGap(self, n: int) -> int:\n        ", "test_cases": {"inputs": [[22]], "outputs": [2], "fn_name": "binaryGap"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "8160cd9b2aed2d73663f32ea8c5ee77f10fe4229", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "binaryGap"}
{"seed_id": "apps-01326", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string s consisting only of letters 'a' and 'b'. In a single step you can remove one palindromic subsequence from s.\nReturn the minimum number of steps to make the given string empty.\nA string is a subsequence of a given string, if it is generated by deleting some characters of a given string without changing its order.\nA string is called palindrome if is one that reads the same backward as well as forward.\n \nExample 1:\nInput: s = \"ababa\"\nOutput: 1\nExplanation: String is already palindrome\n\nExample 2:\nInput: s = \"abb\"\nOutput: 2\nExplanation: \"abb\" -> \"bb\" -> \"\". \nRemove palindromic subsequence \"a\" then \"bb\".\n\nExample 3:\nInput: s = \"baabb\"\nOutput: 2\nExplanation: \"baabb\" -> \"b\" -> \"\". \nRemove palindromic subsequence \"baab\" then \"b\".\n\nExample 4:\nInput: s = \"\"\nOutput: 0\n\n \nConstraints:\n\n0 <= s.length <= 1000\ns only consists of letters 'a' and 'b'", "starter_code": "\nclass Solution:\n    def removePalindromeSub(self, s: str) -> int:\n        ", "test_cases": {"inputs": [["\"ababa\""]], "outputs": [1], "fn_name": "removePalindromeSub"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "a98b5691399565f37a773d5ecaf68ed3ea34e864", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "removePalindromeSub"}
{"seed_id": "apps-01331", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a positive integer, return its corresponding column title as appear in an Excel sheet.\n\nFor example:\n\n\n    1 -> A\n    2 -> B\n    3 -> C\n    ...\n    26 -> Z\n    27 -> AA\n    28 -> AB \n    ...\n\n\nExample 1:\n\n\nInput: 1\nOutput: \"A\"\n\n\nExample 2:\n\n\nInput: 28\nOutput: \"AB\"\n\n\nExample 3:\n\n\nInput: 701\nOutput: \"ZY\"", "starter_code": "\nclass Solution:\n    def convertToTitle(self, n: int) -> str:\n        ", "test_cases": {"inputs": [[1]], "outputs": ["A"], "fn_name": "convertToTitle"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "52f245a480414f476db6ada1269393e4487c1fc5", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "convertToTitle"}
{"seed_id": "apps-01336", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an integer, write an algorithm to convert it to hexadecimal. For negative integer, two’s complement method is used.\n\n\nNote:\n\nAll letters in hexadecimal (a-f) must be in lowercase.\nThe hexadecimal string must not contain extra leading 0s. If the number is zero, it is represented by a single zero character '0'; otherwise, the first character in the hexadecimal string will not be the zero character.\nThe given number is guaranteed to fit within the range of a 32-bit signed integer.\nYou must not use any method provided by the library which converts/formats the number to hex directly.\n\n\n\nExample 1:\n\nInput:\n26\n\nOutput:\n\"1a\"\n\n\n\nExample 2:\n\nInput:\n-1\n\nOutput:\n\"ffffffff\"", "starter_code": "\nclass Solution:\n    def toHex(self, num: int) -> str:\n        ", "test_cases": {"inputs": [[26]], "outputs": ["1a"], "fn_name": "toHex"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "74ea617508e605a6662a01bdd4044f8d31ba25f3", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "toHex"}
{"seed_id": "apps-01341", "original_id": null, "source": "apps", "domain": "code", "problem": "Alice and Bob take turns playing a game, with Alice starting first.\nInitially, there is a number N on the chalkboard.  On each player's turn, that player makes a move consisting of:\n\nChoosing any x with 0 < x < N and N % x == 0.\nReplacing the number N on the chalkboard with N - x.\n\nAlso, if a player cannot make a move, they lose the game.\nReturn True if and only if Alice wins the game, assuming both players play optimally.\n \n\n\n\nExample 1:\nInput: 2\nOutput: true\nExplanation: Alice chooses 1, and Bob has no more moves.\n\n\nExample 2:\nInput: 3\nOutput: false\nExplanation: Alice chooses 1, Bob chooses 1, and Alice has no more moves.\n\n \nNote:\n\n1 <= N <= 1000", "starter_code": "\nclass Solution:\n    def divisorGame(self, N: int) -> bool:\n        ", "test_cases": {"inputs": [[2]], "outputs": [true], "fn_name": "divisorGame"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "9d398b82caf084be1872780be69827c27a39b0b7", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "divisorGame"}
{"seed_id": "apps-01346", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given a string representing an attendance record for a student. The record only contains the following three characters:\n\n\n\n'A' : Absent. \n'L' : Late.\n 'P' : Present. \n\n\n\n\nA student could be rewarded if his attendance record doesn't contain more than one 'A' (absent) or more than two continuous 'L' (late).    \n\nYou need to return whether the student could be rewarded according to his attendance record.\n\nExample 1:\n\nInput: \"PPALLP\"\nOutput: True\n\n\n\nExample 2:\n\nInput: \"PPALLL\"\nOutput: False", "starter_code": "\nclass Solution:\n    def checkRecord(self, s: str) -> bool:\n        ", "test_cases": {"inputs": [["\"PPALLP\""]], "outputs": [true], "fn_name": "checkRecord"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f4d9492aa0a21b1d8e2f109a09cebb2cee8802b1", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "checkRecord"}
{"seed_id": "apps-01351", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given an array A of strings.\nA move onto S consists of swapping any two even indexed characters of S, or any two odd indexed characters of S.\nTwo strings S and T are special-equivalent if after any number of moves onto S, S == T.\nFor example, S = \"zzxy\" and T = \"xyzz\" are special-equivalent because we may make the moves \"zzxy\" -> \"xzzy\" -> \"xyzz\" that swap S[0] and S[2], then S[1] and S[3].\nNow, a group of special-equivalent strings from A is a non-empty subset of A such that:\n\nEvery pair of strings in the group are special equivalent, and;\nThe group is the largest size possible (ie., there isn't a string S not in the group such that S is special equivalent to every string in the group)\n\nReturn the number of groups of special-equivalent strings from A.\n \n\nExample 1:\nInput: [\"abcd\",\"cdab\",\"cbad\",\"xyzz\",\"zzxy\",\"zzyx\"]\nOutput: 3\nExplanation: \nOne group is [\"abcd\", \"cdab\", \"cbad\"], since they are all pairwise special equivalent, and none of the other strings are all pairwise special equivalent to these.\n\nThe other two groups are [\"xyzz\", \"zzxy\"] and [\"zzyx\"].  Note that in particular, \"zzxy\" is not special equivalent to \"zzyx\".\n\n\nExample 2:\nInput: [\"abc\",\"acb\",\"bac\",\"bca\",\"cab\",\"cba\"]\nOutput: 3\n \n\n\n\n\n\n\nNote:\n\n1 <= A.length <= 1000\n1 <= A[i].length <= 20\nAll A[i] have the same length.\nAll A[i] consist of only lowercase letters.", "starter_code": "\nclass Solution:\n    def numSpecialEquivGroups(self, A: List[str]) -> int:\n        ", "test_cases": {"inputs": [[["\"abcd\"", "\"cdab\"", "\"cbad\"", "\"xyzz\"", "\"zzxy\"", "\"zzyx\""]]], "outputs": [3], "fn_name": "numSpecialEquivGroups"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "727b03ff3bad5718b9c2a524bc05993be21afa15", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "numSpecialEquivGroups"}
{"seed_id": "apps-01356", "original_id": null, "source": "apps", "domain": "code", "problem": "Suppose you have a long flowerbed in which some of the plots are planted and some are not. However, flowers cannot be planted in adjacent plots - they would compete for water and both would die.\n\nGiven a flowerbed (represented as an array containing 0 and 1, where 0 means empty and 1 means not empty), and a number n, return if n new flowers can be planted in it without violating the no-adjacent-flowers rule.\n\nExample 1:\n\nInput: flowerbed = [1,0,0,0,1], n = 1\nOutput: True\n\n\n\nExample 2:\n\nInput: flowerbed = [1,0,0,0,1], n = 2\nOutput: False\n\n\n\nNote:\n\nThe input array won't violate no-adjacent-flowers rule.\nThe input array size is in the range of [1, 20000].\nn is a non-negative integer which won't exceed the input array size.", "starter_code": "\nclass Solution:\n    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:\n        ", "test_cases": {"inputs": [[[1, 0, 0, 0, 1], 1]], "outputs": [true], "fn_name": "canPlaceFlowers"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "988ca45e9d70906eec6d6f0e9bdceaa52093a358", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "canPlaceFlowers"}
{"seed_id": "apps-01361", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a non-empty string check if it can be constructed by taking a substring of it and appending multiple copies of the substring together.  You may assume the given string consists of lowercase English letters only and its length  will not exceed 10000. \n\nExample 1:\n\nInput: \"abab\"\n\nOutput: True\n\nExplanation: It's the substring \"ab\" twice.\n\n\n\nExample 2:\n\nInput: \"aba\"\n\nOutput: False\n\n\n\nExample 3:\n\nInput: \"abcabcabcabc\"\n\nOutput: True\n\nExplanation: It's the substring \"abc\" four times. (And the substring \"abcabc\" twice.)", "starter_code": "\nclass Solution:\n    def repeatedSubstringPattern(self, s: str) -> bool:\n        ", "test_cases": {"inputs": [["\"abab\""]], "outputs": [false], "fn_name": "repeatedSubstringPattern"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "856ad008574653dd2040306dc86d25feb550756c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "repeatedSubstringPattern"}
{"seed_id": "apps-01366", "original_id": null, "source": "apps", "domain": "code", "problem": "The Leetcode file system keeps a log each time some user performs a change folder operation.\nThe operations are described below:\n\n\"../\" : Move to the parent folder of the current folder. (If you are already in the main folder, remain in the same folder).\n\"./\" : Remain in the same folder.\n\"x/\" : Move to the child folder named x (This folder is guaranteed to always exist).\n\nYou are given a list of strings logs where logs[i] is the operation performed by the user at the ith step.\nThe file system starts in the main folder, then the operations in logs are performed.\nReturn the minimum number of operations needed to go back to the main folder after the change folder operations.\n \nExample 1:\n\nInput: logs = [\"d1/\",\"d2/\",\"../\",\"d21/\",\"./\"]\nOutput: 2\nExplanation: Use this change folder operation \"../\" 2 times and go back to the main folder.\n\nExample 2:\n\nInput: logs = [\"d1/\",\"d2/\",\"./\",\"d3/\",\"../\",\"d31/\"]\nOutput: 3\n\nExample 3:\nInput: logs = [\"d1/\",\"../\",\"../\",\"../\"]\nOutput: 0\n\n \nConstraints:\n\n1 <= logs.length <= 103\n2 <= logs[i].length <= 10\nlogs[i] contains lowercase English letters, digits, '.', and '/'.\nlogs[i] follows the format described in the statement.\nFolder names consist of lowercase English letters and digits.", "starter_code": "\nclass Solution:\n    def minOperations(self, logs: List[str]) -> int:\n        ", "test_cases": {"inputs": [[["\"d1/\"", "\"d2/\"", "\"../\"", "\"d21/\"", "\"./\""]]], "outputs": [5], "fn_name": "minOperations"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "1f8a411fdad58b16535968966eb2e3e009123efe", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "minOperations"}
{"seed_id": "apps-01371", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an integer array arr, return true if there are three consecutive odd numbers in the array. Otherwise, return false.\n \nExample 1:\nInput: arr = [2,6,4,1]\nOutput: false\nExplanation: There are no three consecutive odds.\n\nExample 2:\nInput: arr = [1,2,34,3,4,5,7,23,12]\nOutput: true\nExplanation: [5,7,23] are three consecutive odds.\n\n \nConstraints:\n\n1 <= arr.length <= 1000\n1 <= arr[i] <= 1000", "starter_code": "\nclass Solution:\n    def threeConsecutiveOdds(self, arr: List[int]) -> bool:\n        ", "test_cases": {"inputs": [[[2, 6, 4, 1]]], "outputs": [false], "fn_name": "threeConsecutiveOdds"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "07766b99bdbdf35107be0273d3499cdd1f2bd4eb", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "threeConsecutiveOdds"}
{"seed_id": "apps-01376", "original_id": null, "source": "apps", "domain": "code", "problem": "Say you have an array for which the ith element is the price of a given stock on day i.\n\nDesign an algorithm to find the maximum profit. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).\n\nNote: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).\n\nExample 1:\n\n\nInput: [7,1,5,3,6,4]\nOutput: 7\nExplanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.\n             Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.\n\n\nExample 2:\n\n\nInput: [1,2,3,4,5]\nOutput: 4\nExplanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.\n             Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are\n             engaging multiple transactions at the same time. You must sell before buying again.\n\n\nExample 3:\n\n\nInput: [7,6,4,3,1]\nOutput: 0\nExplanation: In this case, no transaction is done, i.e. max profit = 0.", "starter_code": "\nclass Solution:\n    def maxProfit(self, prices: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[7, 1, 5, 3, 6, 4]]], "outputs": [7], "fn_name": "maxProfit"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "13a728fd5e930460ae62c502f90e5fae0e42e8b4", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maxProfit"}
{"seed_id": "apps-01381", "original_id": null, "source": "apps", "domain": "code", "problem": "You are given an array of strings words and a string chars.\nA string is good if it can be formed by characters from chars (each character can only be used once).\nReturn the sum of lengths of all good strings in words.\n \nExample 1:\nInput: words = [\"cat\",\"bt\",\"hat\",\"tree\"], chars = \"atach\"\nOutput: 6\nExplanation: \nThe strings that can be formed are \"cat\" and \"hat\" so the answer is 3 + 3 = 6.\n\nExample 2:\nInput: words = [\"hello\",\"world\",\"leetcode\"], chars = \"welldonehoneyr\"\nOutput: 10\nExplanation: \nThe strings that can be formed are \"hello\" and \"world\" so the answer is 5 + 5 = 10.\n\n \nNote:\n\n1 <= words.length <= 1000\n1 <= words[i].length, chars.length <= 100\nAll strings contain lowercase English letters only.", "starter_code": "\nclass Solution:\n    def countCharacters(self, words: List[str], chars: str) -> int:\n        ", "test_cases": {"inputs": [[["\"cat\"", "\"bt\"", "\"hat\"", "\"tree\""], "\"atach\""]], "outputs": [10], "fn_name": "countCharacters"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "a92a6dd205a417ae224bbbe9c3b7f0955526205b", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "countCharacters"}
{"seed_id": "apps-01386", "original_id": null, "source": "apps", "domain": "code", "problem": "Every email consists of a local name and a domain name, separated by the @ sign.\nFor example, in alice@leetcode.com, alice is the local name, and leetcode.com is the domain name.\nBesides lowercase letters, these emails may contain '.'s or '+'s.\nIf you add periods ('.') between some characters in the local name part of an email address, mail sent there will be forwarded to the same address without dots in the local name.  For example, \"alice.z@leetcode.com\" and \"alicez@leetcode.com\" forward to the same email address.  (Note that this rule does not apply for domain names.)\nIf you add a plus ('+') in the local name, everything after the first plus sign will be ignored. This allows certain emails to be filtered, for example m.y+name@email.com will be forwarded to my@email.com.  (Again, this rule does not apply for domain names.)\nIt is possible to use both of these rules at the same time.\nGiven a list of emails, we send one email to each address in the list.  How many different addresses actually receive mails? \n \n\nExample 1:\nInput: [\"test.email+alex@leetcode.com\",\"test.e.mail+bob.cathy@leetcode.com\",\"testemail+david@lee.tcode.com\"]\nOutput: 2\nExplanation: \"testemail@leetcode.com\" and \"testemail@lee.tcode.com\" actually receive mails\n\n \nNote:\n\n1 <= emails[i].length <= 100\n1 <= emails.length <= 100\nEach emails[i] contains exactly one '@' character.\nAll local and domain names are non-empty.\nLocal names do not start with a '+' character.", "starter_code": "\nclass Solution:\n    def numUniqueEmails(self, emails: List[str]) -> int:\n        ", "test_cases": {"inputs": [[["\"test.email+alex@leetcode.com\"", "\"test.e.mail+bob.cathy@leetcode.com\"", "\"testemail+david@lee\n.tcode.com\""]]], "outputs": [2], "fn_name": "numUniqueEmails"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "9f728c4d438cef0d167915dd54f9af00d7a97de3", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "numUniqueEmails"}
{"seed_id": "apps-01391", "original_id": null, "source": "apps", "domain": "code", "problem": "The Tribonacci sequence Tn is defined as follows: \nT0 = 0, T1 = 1, T2 = 1, and Tn+3 = Tn + Tn+1 + Tn+2 for n >= 0.\nGiven n, return the value of Tn.\n \nExample 1:\nInput: n = 4\nOutput: 4\nExplanation:\nT_3 = 0 + 1 + 1 = 2\nT_4 = 1 + 1 + 2 = 4\n\nExample 2:\nInput: n = 25\nOutput: 1389537\n\n \nConstraints:\n\n0 <= n <= 37\nThe answer is guaranteed to fit within a 32-bit integer, ie. answer <= 2^31 - 1.", "starter_code": "\nclass Solution:\n    def tribonacci(self, n: int) -> int:\n        ", "test_cases": {"inputs": [[4]], "outputs": [4], "fn_name": "tribonacci"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "33a371cc69381956698120d69dd3a267ead9cae9", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "tribonacci"}
{"seed_id": "apps-01396", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a non-empty array of non-negative integers nums, the degree of this array is defined as the maximum frequency of any one of its elements.\nYour task is to find the smallest possible length of a (contiguous) subarray of nums, that has the same degree as nums.\n\nExample 1:\n\nInput: [1, 2, 2, 3, 1]\nOutput: 2\nExplanation: \nThe input array has a degree of 2 because both elements 1 and 2 appear twice.\nOf the subarrays that have the same degree:\n[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]\nThe shortest length is 2. So return 2.\n\n\n\n\nExample 2:\n\nInput: [1,2,2,3,1,4,2]\nOutput: 6\n\n\n\nNote:\nnums.length will be between 1 and 50,000.\nnums[i] will be an integer between 0 and 49,999.", "starter_code": "\nclass Solution:\n    def findShortestSubArray(self, nums: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[1, 2, 2, 3, 1]]], "outputs": [2], "fn_name": "findShortestSubArray"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e35b70801a63e091640f7824930c9f985ceec41c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "findShortestSubArray"}
{"seed_id": "apps-01401", "original_id": null, "source": "apps", "domain": "code", "problem": "Write a function to find the longest common prefix string amongst an array of strings.\n\nIf there is no common prefix, return an empty string \"\".\n\nExample 1:\n\n\nInput: [\"flower\",\"flow\",\"flight\"]\nOutput: \"fl\"\n\n\nExample 2:\n\n\nInput: [\"dog\",\"racecar\",\"car\"]\nOutput: \"\"\nExplanation: There is no common prefix among the input strings.\n\n\nNote:\n\nAll given inputs are in lowercase letters a-z.", "starter_code": "\nclass Solution:\n    def longestCommonPrefix(self, strs: List[str]) -> str:\n        ", "test_cases": {"inputs": [[["\"flower\"", "\"flow\"", "\"flight\""]]], "outputs": ["\"fl"], "fn_name": "longestCommonPrefix"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e89b6204ee8252ec24c0eae136de833d5f02a649", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "longestCommonPrefix"}
{"seed_id": "apps-01406", "original_id": null, "source": "apps", "domain": "code", "problem": "Given a string s of zeros and ones, return the maximum score after splitting the string into two non-empty substrings (i.e. left substring and right substring).\nThe score after splitting a string is the number of zeros in the left substring plus the number of ones in the right substring.\n \nExample 1:\nInput: s = \"011101\"\nOutput: 5 \nExplanation: \nAll possible ways of splitting s into two non-empty substrings are:\nleft = \"0\" and right = \"11101\", score = 1 + 4 = 5 \nleft = \"01\" and right = \"1101\", score = 1 + 3 = 4 \nleft = \"011\" and right = \"101\", score = 1 + 2 = 3 \nleft = \"0111\" and right = \"01\", score = 1 + 1 = 2 \nleft = \"01110\" and right = \"1\", score = 2 + 1 = 3\n\nExample 2:\nInput: s = \"00111\"\nOutput: 5\nExplanation: When left = \"00\" and right = \"111\", we get the maximum score = 2 + 3 = 5\n\nExample 3:\nInput: s = \"1111\"\nOutput: 3\n\n \nConstraints:\n\n2 <= s.length <= 500\nThe string s consists of characters '0' and '1' only.", "starter_code": "\nclass Solution:\n    def maxScore(self, s: str) -> int:\n        ", "test_cases": {"inputs": [["\"011101\""]], "outputs": [5], "fn_name": "maxScore"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "15f7af05ccf3451cec9af4d806c3c630203bf706", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "maxScore"}
{"seed_id": "apps-01411", "original_id": null, "source": "apps", "domain": "code", "problem": "Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array.\n\nExample 1:\n\n\nInput: [3,0,1]\nOutput: 2\n\n\nExample 2:\n\n\nInput: [9,6,4,2,3,5,7,0,1]\nOutput: 8\n\n\nNote:\nYour algorithm should run in linear runtime complexity. Could you implement it using only constant extra space complexity?", "starter_code": "\nclass Solution:\n    def missingNumber(self, nums: List[int]) -> int:\n        ", "test_cases": {"inputs": [[[3, 0, 1]]], "outputs": [2], "fn_name": "missingNumber"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "a50ba1ca0419f2b97a86f4a4e173b5db4b4f53ee", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "missingNumber"}
{"seed_id": "apps-01416", "original_id": null, "source": "apps", "domain": "code", "problem": "On an 8 x 8 chessboard, there is one white rook.  There also may be empty squares, white bishops, and black pawns.  These are given as characters 'R', '.', 'B', and 'p' respectively. Uppercase characters represent white pieces, and lowercase characters represent black pieces.\nThe rook moves as in the rules of Chess: it chooses one of four cardinal directions (north, east, west, and south), then moves in that direction until it chooses to stop, reaches the edge of the board, or captures an opposite colored pawn by moving to the same square it occupies.  Also, rooks cannot move into the same square as other friendly bishops.\nReturn the number of pawns the rook can capture in one move.\n \nExample 1:\n\nInput: [[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\"p\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\"R\",\".\",\".\",\".\",\"p\"],[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\"p\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"]]\nOutput: 3\nExplanation: \nIn this example the rook is able to capture all the pawns.\n\nExample 2:\n\nInput: [[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"],[\".\",\"p\",\"p\",\"p\",\"p\",\"p\",\".\",\".\"],[\".\",\"p\",\"p\",\"B\",\"p\",\"p\",\".\",\".\"],[\".\",\"p\",\"B\",\"R\",\"B\",\"p\",\".\",\".\"],[\".\",\"p\",\"p\",\"B\",\"p\",\"p\",\".\",\".\"],[\".\",\"p\",\"p\",\"p\",\"p\",\"p\",\".\",\".\"],[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"]]\nOutput: 0\nExplanation: \nBishops are blocking the rook to capture any pawn.\n\nExample 3:\n\nInput: [[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\"p\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\"p\",\".\",\".\",\".\",\".\"],[\"p\",\"p\",\".\",\"R\",\".\",\"p\",\"B\",\".\"],[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\"B\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\"p\",\".\",\".\",\".\",\".\"],[\".\",\".\",\".\",\".\",\".\",\".\",\".\",\".\"]]\nOutput: 3\nExplanation: \nThe rook can capture the pawns at positions b5, d6 and f5.\n\n \nNote:\n\nboard.length == board[i].length == 8\nboard[i][j] is either 'R', '.', 'B', or 'p'\nThere is exactly one cell with board[i][j] == 'R'", "starter_code": "\nclass Solution:\n    def numRookCaptures(self, board: List[List[str]]) -> int:\n        ", "test_cases": {"inputs": [[[["\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\""], ["\".\"", "\".\"", "\".\"", "\"p\"", "\".\"", "\".\"", "\".\"", "\".\""], ["\".\"", "\".\"", "\".\"", "\"R\"", "\".\"\n", "\".\"", "\".\"", "\"p\""], ["\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\""], ["\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\""], ["\".\"", "\".\"\n", "\".\"", "\"p\"", "\".\"", "\".\"", "\".\"", "\".\""], ["\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\""], ["\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\".\"", "\"\n.\""], [], []]]], "outputs": [0], "fn_name": "numRookCaptures"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e8fd3cfc03cd17b27858fa40448fefdb634cd55f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "numRookCaptures"}
{"seed_id": "apps-01421", "original_id": null, "source": "apps", "domain": "code", "problem": "At a lemonade stand, each lemonade costs $5. \nCustomers are standing in a queue to buy from you, and order one at a time (in the order specified by bills).\nEach customer will only buy one lemonade and pay with either a $5, $10, or $20 bill.  You must provide the correct change to each customer, so that the net transaction is that the customer pays $5.\nNote that you don't have any change in hand at first.\nReturn true if and only if you can provide every customer with correct change.\n \n\nExample 1:\nInput: [5,5,5,10,20]\nOutput: true\nExplanation: \nFrom the first 3 customers, we collect three $5 bills in order.\nFrom the fourth customer, we collect a $10 bill and give back a $5.\nFrom the fifth customer, we give a $10 bill and a $5 bill.\nSince all customers got correct change, we output true.\n\n\nExample 2:\nInput: [5,5,10]\nOutput: true\n\n\nExample 3:\nInput: [10,10]\nOutput: false\n\n\nExample 4:\nInput: [5,5,10,10,20]\nOutput: false\nExplanation: \nFrom the first two customers in order, we collect two $5 bills.\nFor the next two customers in order, we collect a $10 bill and give back a $5 bill.\nFor the last customer, we can't give change of $15 back because we only have two $10 bills.\nSince not every customer received correct change, the answer is false.\n\n \nNote:\n\n0 <= bills.length <= 10000\nbills[i] will be either 5, 10, or 20.", "starter_code": "\nclass Solution:\n    def lemonadeChange(self, bills: List[int]) -> bool:\n        ", "test_cases": {"inputs": [[[5, 5, 5, 10, 20]]], "outputs": [true], "fn_name": "lemonadeChange"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "e706b50a7b6a28516f3c46af637dab8917ffb2b5", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "lemonadeChange"}
{"seed_id": "apps-01426", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Function Descriptions=====\n.remove(x)\n\nThis operation removes element x from the set.\nIf element x does not exist, it raises a KeyError.\nThe .remove(x) operation returns None.\n\nExample\n\n>>> s = set([1, 2, 3, 4, 5, 6, 7, 8, 9])\n>>> s.remove(5)\n>>> print s\nset([1, 2, 3, 4, 6, 7, 8, 9])\n>>> print s.remove(4)\nNone\n>>> print s\nset([1, 2, 3, 6, 7, 8, 9])\n>>> s.remove(0)\nKeyError: 0\n\n.discard(x)\n\nThis operation also removes element x from the set.\nIf element x does not exist, it does not raise a KeyError.\nThe .discard(x) operation returns None.\n\nExample\n\n>>> s = set([1, 2, 3, 4, 5, 6, 7, 8, 9])\n>>> s.discard(5)\n>>> print s\nset([1, 2, 3, 4, 6, 7, 8, 9])\n>>> print s.discard(4)\nNone\n>>> print s\nset([1, 2, 3, 6, 7, 8, 9])\n>>> s.discard(0)\n>>> print s\nset([1, 2, 3, 6, 7, 8, 9])\n\n.pop()\n\nThis operation removes and return an arbitrary element from the set.\nIf there are no elements to remove, it raises a KeyError.\n\nExample\n\n>>> s = set([1])\n>>> print s.pop()\n1\n>>> print s\nset([])\n>>> print s.pop()\nKeyError: pop from an empty set\n\n=====Problem Statement=====\nYou have a non-empty set s, and you have to execute N commands given in N lines.\nThe commands will be pop, remove and discard. \n\n=====Input Format=====\nThe first line contains integer n, the number of elements in the set s.\nThe second line contains n space separated elements of set s. All of the elements are non-negative integers, less than or equal to 9.\nThe third line contains integer N, the number of commands.\nThe next N lines contains either pop, remove and/or discard commands followed by their associated value.\n\n=====Constraints=====\n0 < n < 20\n0 < N < 20\n\n=====Output Format====\nPrint the sum of the elements of set s on a single line.", "starter_code": "\nn = int(input())\ns = set(map(int, input().split()))", "test_cases": {"inputs": ["9\n1 2 3 4 5 6 7 8 9\n10\npop\nremove 9\ndiscard 9\ndiscard 8\nremove 7\npop\ndiscard 6\nremove 5\npop\ndiscard 5"], "outputs": ["4"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "66bf9513e55f1370753ce492b720f720f0995e9f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01431", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Problem Statement=====\nGiven a list of rational numbers,find their product.\n\nConcept\nThe reduce() function applies a function of two arguments cumulatively on a list of objects in succession from left to right to reduce it to one value. Say you have a list, say [1,2,3] and you have to find its sum.\n\n>>> reduce(lambda x, y : x + y,[1,2,3])\n6\n\nYou can also define an initial value. If it is specified, the function will assume initial value as the value given, and then reduce. It is equivalent to adding the initial value at the beginning of the list. For example:\n\n>>> reduce(lambda x, y : x + y, [1,2,3], -3)\n3\n\n>>> from fractions import gcd\n>>> reduce(gcd, [2,4,8], 3)\n1\n\n=====Input Format=====\nFirst line contains n, the number of rational numbers.\nThe ith of next n lines contain two integers each, the numerator (N_i) and denominator (D_i) of the ith rational number in the list.\n\n=====Constraints=====\n1≤n≤100\n1≤N_i,D_i≤10^9\n\n=====Output Format=====\nPrint only one line containing the numerator and denominator of the product of the numbers in the list in its simplest form, i.e. numerator and denominator have no common divisor other than 1.", "starter_code": "\nfrom fractions import Fraction\nfrom functools import reduce\n\ndef product(fracs):\n    t = # complete this line with a reduce statement\n    return t.numerator, t.denominator\n\nif __name__ == '__main__':\n    fracs = []\n    for _ in range(int(input())):\n        fracs.append(Fraction(*map(int, input().split())))\n    result = product(fracs)\n    print(*result)", "test_cases": {"inputs": ["3\n1 2\n3 4\n10 6"], "outputs": ["5 8"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d02e5bf1dd9aad1cc014f87725b87bccc61dc236", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01436", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Function Descriptions=====\nCalendar Module\nThe calendar module allows you to output calendars and provides additional useful functions for them.\n\nclass calendar.TextCalendar([firstweekday])\n\nThis class can be used to generate plain text calendars.\n\nSample Code\n>>> import calendar\n>>> \n>>> print calendar.TextCalendar(firstweekday=6).formatyear(2015)\n                                  2015\n\n      January                   February                   March\nSu Mo Tu We Th Fr Sa      Su Mo Tu We Th Fr Sa      Su Mo Tu We Th Fr Sa\n             1  2  3       1  2  3  4  5  6  7       1  2  3  4  5  6  7\n 4  5  6  7  8  9 10       8  9 10 11 12 13 14       8  9 10 11 12 13 14\n11 12 13 14 15 16 17      15 16 17 18 19 20 21      15 16 17 18 19 20 21\n18 19 20 21 22 23 24      22 23 24 25 26 27 28      22 23 24 25 26 27 28\n25 26 27 28 29 30 31                                29 30 31\n\n       April                      May                       June\nSu Mo Tu We Th Fr Sa      Su Mo Tu We Th Fr Sa      Su Mo Tu We Th Fr Sa\n          1  2  3  4                      1  2          1  2  3  4  5  6\n 5  6  7  8  9 10 11       3  4  5  6  7  8  9       7  8  9 10 11 12 13\n12 13 14 15 16 17 18      10 11 12 13 14 15 16      14 15 16 17 18 19 20\n19 20 21 22 23 24 25      17 18 19 20 21 22 23      21 22 23 24 25 26 27\n26 27 28 29 30            24 25 26 27 28 29 30      28 29 30\n                          31\n\n        July                     August                  September\nSu Mo Tu We Th Fr Sa      Su Mo Tu We Th Fr Sa      Su Mo Tu We Th Fr Sa\n          1  2  3  4                         1             1  2  3  4  5\n 5  6  7  8  9 10 11       2  3  4  5  6  7  8       6  7  8  9 10 11 12\n12 13 14 15 16 17 18       9 10 11 12 13 14 15      13 14 15 16 17 18 19\n19 20 21 22 23 24 25      16 17 18 19 20 21 22      20 21 22 23 24 25 26\n26 27 28 29 30 31         23 24 25 26 27 28 29      27 28 29 30\n                          30 31\n\n      October                   November                  December\nSu Mo Tu We Th Fr Sa      Su Mo Tu We Th Fr Sa      Su Mo Tu We Th Fr Sa\n             1  2  3       1  2  3  4  5  6  7             1  2  3  4  5\n 4  5  6  7  8  9 10       8  9 10 11 12 13 14       6  7  8  9 10 11 12\n11 12 13 14 15 16 17      15 16 17 18 19 20 21      13 14 15 16 17 18 19\n18 19 20 21 22 23 24      22 23 24 25 26 27 28      20 21 22 23 24 25 26\n25 26 27 28 29 30 31      29 30                     27 28 29 30 31\n\n=====Problem Statement=====\nYou are given a date. Your task is to find what the day is on that date.\n\n=====Input Format=====\nA single line of input containing the space separated month, day and year, respectively, in MM DD YYYY format.\n\n=====Constraints=====\n2000<year<3000\n\n=====Output Format=====\nOutput the correct day in capital letters.", "starter_code": "\n# Enter your code here. Read input from STDIN. Print output to STDOUT", "test_cases": {"inputs": ["08 05 2015"], "outputs": ["WEDNESDAY"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b5760c5ac8a03b9663cc9a5de68c61983fba6001", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01441", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Function Descriptions=====\nSo far, we have only heard of Python's powers. Now, we will witness them!\n\nPowers or exponents in Python can be calculated using the built-in power function. Call the power function a^b as shown below:\n>>> pow(a,b) \n\nor\n\n>>> a**b\n\nIt's also possible to calculate a^b mod m.\n>>> pow(a,b,m)  \n\nThis is very helpful in computations where you have to print the resultant % mod.\n\nNote: Here, a and b can be floats or negatives, but, if a third argument is present, b cannot be negative.\n\nNote: Python has a math module that has its own pow(). It takes two arguments and returns a float. Frankly speaking, we will never use math.pow().\n\n=====Problem Statement=====\nYou are given three integers: a, b, and m, respectively. Print two lines.\nThe first line should print the result of pow(a,b). The second line should print the result of pow(a,b,m).\n\n=====Input Format=====\nThe first line contains a, the second line contains b, and the third line contains m.\n\n=====Constraints=====\n1≤a≤10\n1≤b≤10\n2≤m≤1000", "starter_code": "\n# Enter your code here. Read input from STDIN. Print output to STDOUT", "test_cases": {"inputs": ["3\n4\n5"], "outputs": ["81\n1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "0f2f0b39e705df083b280fc0060132bb116fa961", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01446", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Problem Statement=====\nYou are given a string S. S contains alphanumeric characters only. Your task is to sort the string S in the following manner:\nAll sorted lowercase letters are ahead of uppercase letters.\nAll sorted uppercase letters are ahead of digits.\nAll sorted odd digits are ahead of sorted even digits.\n\n=====Input Format=====\nA single line of input contains the string S.\n\n=====Constraints=====\n0<len(S)<1000\n\n=====Output Format=====\nOutput the sorted string S.", "starter_code": "\n# Enter your code here. Read input from STDIN. Print output to STDOUT", "test_cases": {"inputs": ["Sorting1234"], "outputs": ["ginortS1324"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "4857d5c348f1534862ed8c16a5142e258e8b474e", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01451", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Problem Statement=====\nYou are given n words. Some words may repeat. For each word, output its number of occurrences. The output order should correspond with the input order of appearance of the word. See the sample input/output for clarification.\n\nNote: Each input line ends with a \"\\n\" character.\n\n=====Constraints=====\n1≤n≤10^5\nThe sum of the lengths of all the words do not exceed 10^6\nAll the words are composed of lowercase English letters only.\n\n=====Input Format=====\nThe first line contains the integer, n.\nThe next n lines each contain a word.\n\n=====Output Format=====\nOutput 2 lines.\nOn the first line, output the number of distinct words from the input.\nOn the second line, output the number of occurrences for each distinct word according to their appearance in the input.", "starter_code": "\n# Enter your code here. Read input from STDIN. Print output to STDOUT", "test_cases": {"inputs": ["4\nbcdef\nabcdefg\nbcde\nbcdef\n"], "outputs": ["3\n2 1 1"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "c63c54daaddf45f43a9512bc961876a96779d6cf", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01456", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Problem Statement=====\nYou are given a positive integer N. Print a numerical triangle of height N - 1 like the one below:\n1\n22\n333\n4444\n55555\n......\n\nCan you do it using only arithmetic operations, a single for loop and print statement?\n\nUse no more than two lines. The first line (the for statement) is already written for you. You have to complete the print statement.\n\nNote: Using anything related to strings will give a score of 0.\n\n=====Input Format=====\nA single line containing integer, N.\n\n=====Constraints=====\n1≤N≤9\n\n=====Output Format=====\nPrint N - 1 lines as explained above.", "starter_code": "\nfor i in range(1,int(input())): #More than 2 lines will result in 0 score. Do not leave a blank line also\n    print", "test_cases": {"inputs": ["5"], "outputs": ["1\n22\n333\n4444"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "461dc852cae401055428a07b6575bfcb63f95662", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01461", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Problem Statement=====\nYou are given a string s consisting only of digits 0-9, commas ,, and dots .\n\nYour task is to complete the regex_pattern defined below, which will be used to re.split() all of the , and . symbols in s.\n\nIt’s guaranteed that every comma and every dot in s is preceeded and followed by a digit.", "starter_code": "\nregex_pattern = r\"\"\t# Do not delete 'r'.\n\nimport re\nprint(\"\\n\".join(re.split(regex_pattern, input())))", "test_cases": {"inputs": ["100,000,000.000\n"], "outputs": ["100\n000\n000\n000\n"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "35d76b9c582701a96e26f9582aa0dc7e8f1e1ed6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01466", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Problem Statement=====\nIntegers in Python can be as big as the bytes in your machine's memory. There is no limit in size as there is: 2^31 - 1 (c++ int) or 2^63 - 1 (C++ long long int).\nAs we know, a^b the result of grows really fast with increasing b.\nLet's do some calculations on very large integers.\nTask\nRead four numbers, a, b, c, and d, and print the result of a^b + c^d.\n\n=====Input Format=====\nIntegers a, b, c, and d are given on four separate lines, respectively.\n\n=====Constraints=====\n1≤a≤1000\n1≤b≤1000\n1≤c≤1000\n1≤d≤1000\n\n=====Output Format=====\nPrint the result of a^b + c^d on one line.", "starter_code": "\n# Enter your code here. Read input from STDIN. Print output to STDOUT", "test_cases": {"inputs": ["9\n29\n7\n27"], "outputs": ["4710194409608608369201743232"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "0933ad80c079f8f9766ee1cac7a10227817ceccf", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01471", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Problem Statement=====\nMr. Anant Asankhya is the manager at the INFINITE hotel. The hotel has an infinite amount of rooms.\n\nOne fine day, a finite number of tourists come to stay at the hotel.\nThe tourists consist of:\n→ A Captain.\n→ An unknown group of families consisting of K members per group where K ≠ 1.\n\nThe Captain was given a separate room, and the rest were given one room per group.\n\nMr. Anant has an unordered list of randomly arranged room entries. The list consists of the room numbers for all of the tourists. The room numbers will appear K times per group except for the Captain's room.\n\nMr. Anant needs you to help him find the Captain's room number.\nThe total number of tourists or the total number of groups of families is not known to you.\nYou only know the value of K and the room number list.\n\n=====Input Format=====\nThe first consists of an integer, K, the size of each group.\nThe second line contains the unordered elements of the room number list.\n\n=====Constraints=====\n1<K<1000\n\n=====Output Format=====\nOutput the Captain's room number.", "starter_code": "\n# Enter your code here. Read input from STDIN. Print output to STDOUT", "test_cases": {"inputs": ["5\n1 2 3 6 5 4 4 2 5 3 6 1 6 5 3 2 4 1 2 5 1 4 3 6 8 4 3 1 5 6 2"], "outputs": ["8"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "c9d2d431cffe57fa0dac8813c9087f11bfa79611", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01476", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Function Descriptions=====\nWe have seen the applications of union, intersection, difference and symmetric difference operations, but these operations do not make any changes or mutations to the set.\n\nWe can use the following operations to create mutations to a set:\n\n.update() or |=\nUpdate the set by adding elements from an iterable/another set.\n\n>>> H = set(\"Hacker\")\n>>> R = set(\"Rank\")\n>>> H.update(R)\n>>> print H\nset(['a', 'c', 'e', 'H', 'k', 'n', 'r', 'R'])\n\n.intersection_update() or &=\nUpdate the set by keeping only the elements found in it and an iterable/another set.\n\n>>> H = set(\"Hacker\")\n>>> R = set(\"Rank\")\n>>> H.intersection_update(R)\n>>> print H\nset(['a', 'k'])\n\n.difference_update() or -=\nUpdate the set by removing elements found in an iterable/another set.\n\n>>> H = set(\"Hacker\")\n>>> R = set(\"Rank\")\n>>> H.difference_update(R)\n>>> print H\nset(['c', 'e', 'H', 'r'])\n\n.symmetric_difference_update() or ^=\nUpdate the set by only keeping the elements found in either set, but not in both.\n\n>>> H = set(\"Hacker\")\n>>> R = set(\"Rank\")\n>>> H.symmetric_difference_update(R)\n>>> print H\nset(['c', 'e', 'H', 'n', 'r', 'R'])\n\n=====Problem Statement=====\nYou are given a set A and N number of other sets. These N number of sets have to perform some specific mutation operations on set A.\n\nYour task is to execute those operations and print the sum of elements from set A.\n\n=====Input Format=====\nThe first line contains the number of elements in set A.\nThe second line contains the space separated list of elements in set A.\nThe third line contains integer N, the number of other sets.\nThe next 2 * N lines are divided into N parts containing two lines each.\nThe first line of each part contains the space separated entries of the operation name and the length of the other set.\nThe second line of each part contains space separated list of elements in the other set.\n\n=====Constraints=====\n0<len(set(A))<1000\n0<len(otherSets)<100\n0<N<100\n\n=====Output Format=====\nOutput the sum of elements in set A.", "starter_code": "\n# Enter your code here. Read input from STDIN. Print output to STDOUT", "test_cases": {"inputs": ["16\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 24 52\n4\nintersection_update 10\n2 3 5 6 8 9 1 4 7 11\nupdate 2\n55 66\nsymmetric_difference_update 5\n22 7 35 62 58\ndifference_update 7\n11 22 35 55 58 62 66"], "outputs": ["38"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "5647db8086d843d912b4c80a5c342b55e17dfebb", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01481", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Function Descriptions=====\ncollections.OrderedDict\n\nAn OrderedDict is a dictionary that remembers the order of the keys that were inserted first. If a new entry overwrites an existing entry, the original insertion position is left unchanged.\n\nExample\nCode\n>>> from collections import OrderedDict\n>>> \n>>> ordinary_dictionary = {}\n>>> ordinary_dictionary['a'] = 1\n>>> ordinary_dictionary['b'] = 2\n>>> ordinary_dictionary['c'] = 3\n>>> ordinary_dictionary['d'] = 4\n>>> ordinary_dictionary['e'] = 5\n>>> \n>>> print ordinary_dictionary\n{'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4}\n>>> \n>>> ordered_dictionary = OrderedDict()\n>>> ordered_dictionary['a'] = 1\n>>> ordered_dictionary['b'] = 2\n>>> ordered_dictionary['c'] = 3\n>>> ordered_dictionary['d'] = 4\n>>> ordered_dictionary['e'] = 5\n>>> \n>>> print ordered_dictionary\nOrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])\n\n=====Problem Statement=====\nYou are the manager of a supermarket.\nYou have a list of N items together with their prices that consumers bought on a particular day.\nYour task is to print each item_name and net_price in order of its first occurrence.\n\nitem_name = Name of the item.\nnet_price = Quantity of the item sold multiplied by the price of each item.\n\n=====Input Format=====\nThe first line contains the number of items, N.\nThe next N lines contains the item's name and price, separated by a space.\n\n=====Constraints=====\n0<N≤100\n\n=====Output Format=====\nPrint the item_name and net_price in order of its first occurrence.", "starter_code": "\n# Enter your code here. Read input from STDIN. Print output to STDOUT", "test_cases": {"inputs": ["9\nBANANA FRIES 12\nPOTATO CHIPS 30\nAPPLE JUICE 10\nCANDY 5\nAPPLE JUICE 10\nCANDY 5\nCANDY 5\nCANDY 5\nPOTATO CHIPS 30"], "outputs": ["BANANA FRIES 12\nPOTATO CHIPS 60\nAPPLE JUICE 20\nCANDY 20"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "f0bff9b472cc9b52bfdc27988819f9f0a989b4d6", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01486", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Problem Statement=====\nYou are given a string and your task is to swap cases. In other words, convert all lowercase letters to uppercase letters and vice versa.\n\n=====Example=====\n\nWww.HackerRank.com → wWW.hACKERrANK.COM\nPythonist 2 → pYTHONIST 2\n\n=====Input Format=====\nA single line containing a string S.\n\n=====Output Format=====\nPrint the modified string S.", "starter_code": "\ndef swap_case(s):\n    return\n\nif __name__ == '__main__':\n    s = input()\n    result = swap_case(s)\n    print(result)", "test_cases": {"inputs": [["HackerRank.com presents \"Pythonist 2\"."]], "outputs": ["hACKERrANK.COM PRESENTS \"pYTHONIST 2\"."], "fn_name": "swap_case"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "b19fd1fb20eedf8ca929721dd0154f0461c4671f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "swap_case"}
{"seed_id": "apps-01491", "original_id": null, "source": "apps", "domain": "code", "problem": "=====Problem Statement=====\nYou are given a string S.\nYour task is to find out whether is a valid regex or not.\n\n=====Input Format=====\nThe first line contains integer T, the number of test cases.\nThe next T lines contains the string S.\n\n=====Constraints=====\n0<T<100\n\n=====Output Format=====\nPrint \"True\" or \"False\" for each test case without quotes.", "starter_code": "\n# Enter your code here. Read input from STDIN. Print output to STDOUT", "test_cases": {"inputs": ["2\n.*\\+\n.*+"], "outputs": ["True\nFalse"]}, "test_case_format": "stdin_stdout", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "d5b8067aa13ad0bb28693158d4ed46b3367c30f3", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true}
{"seed_id": "apps-01496", "original_id": null, "source": "apps", "domain": "code", "problem": "For this game of `BINGO`, you will receive a single array of 10 numbers from 1 to 26 as an input. Duplicate numbers within the array are possible.\n\nEach number corresponds to their alphabetical order letter (e.g. 1 = A. 2 = B, etc). Write a function where you will win the game if your numbers can spell `\"BINGO\"`. They do not need to be in the right order in the input array). Otherwise you will lose. Your outputs should be `\"WIN\"` or `\"LOSE\"` respectively.", "starter_code": "\ndef bingo(array):\n\t", "test_cases": {"inputs": [[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], [[20, 12, 23, 14, 6, 22, 12, 17, 2, 26]], [[1, 2, 3, 7, 5, 14, 7, 15, 9, 10]], [[5, 2, 13, 7, 5, 14, 17, 15, 9, 10]]], "outputs": [["LOSE"], ["LOSE"], ["WIN"], ["WIN"]], "fn_name": "bingo"}, "test_case_format": "function_call", "n_test_cases_total": 4, "n_test_cases_kept": 4, "test_cases_truncated": false, "problem_sha1": "8137945f081f4df1b34d88585214d477958c06da", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "bingo"}
{"seed_id": "apps-01501", "original_id": null, "source": "apps", "domain": "code", "problem": "There's a waiting room with N chairs set in single row. Chairs are consecutively numbered from 1 to N. First is closest to the entrance (which is exit as well).\n \nFor some reason people choose a chair in the following way\n\n1. Find a place as far from other people as possible\n2. Find a place as close to exit as possible\n\nAll chairs must be occupied before the first person will be served\n\nSo it looks like this for 10 chairs and 10 patients\n\n\n\n\nChairs\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n\n\n\n\nPatients\n1\n7\n5\n8\n3\n9\n4\n6\n10\n2\n\n\n\n\nYour task is to find last patient's chair's number. \n\nInput - N - integer greater than 2 - number of chairs.\nOutput should positive integer too - last patient's chair's number\n\nHave fun :)", "starter_code": "\ndef last_chair(n):\n\t", "test_cases": {"inputs": [[10]], "outputs": [[9]], "fn_name": "last_chair"}, "test_case_format": "function_call", "n_test_cases_total": 1, "n_test_cases_kept": 1, "test_cases_truncated": false, "problem_sha1": "512d022d7ffe944ce62ca7743df77473b39d4f1c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "last_chair"}
{"seed_id": "apps-01506", "original_id": null, "source": "apps", "domain": "code", "problem": "Your job at E-Corp is both boring and difficult. It isn't made any easier by the fact that everyone constantly wants to have a meeting with you, and that the meeting rooms are always taken!\n\nIn this kata, you will be given an array. Each value represents a meeting room. Your job? Find the **first** empty one and return its index (N.B. There may be more than one empty room in some test cases). \n\n'X' --> busy\n'O' --> empty\n\nIf all rooms are busy, return 'None available!'.\n\n\nMore in this series:\n\nThe Office I - Outed\nThe Office II - Boredeom Score\nThe Office III - Broken Photocopier\nThe Office V - Find a Chair", "starter_code": "\ndef meeting(rooms):\n\t", "test_cases": {"inputs": [[["X", "O", "X"]], [["O", "X", "X", "X", "X"]], [["X", "X", "O", "X", "X"]], [["X"]]], "outputs": [[1], [0], [2], ["None available!"]], "fn_name": "meeting"}, "test_case_format": "function_call", "n_test_cases_total": 4, "n_test_cases_kept": 4, "test_cases_truncated": false, "problem_sha1": "3c64211f825640f21d930c75b508f3cfb5fc2249", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "meeting"}
{"seed_id": "apps-01511", "original_id": null, "source": "apps", "domain": "code", "problem": "You will be given a string (x) featuring a cat 'C', a dog 'D' and a mouse 'm'. The rest of the string will be made up of '.'. \n\nYou need to find out if the cat can catch the mouse from it's current position. The cat can jump (j) characters. \n\nAlso, the cat cannot jump over the dog.\n\nSo:\n\nif j = 5:\n\n```..C.....m.``` returns 'Caught!'  <-- not more than j characters between\n\n```.....C............m......``` returns 'Escaped!'  <-- as there are more than j characters between the two, the cat can't jump far enough\n\nif j = 10:\n\n```...m.........C...D``` returns 'Caught!' <--Cat can jump far enough and jump is not over dog\n\n```...m....D....C.......``` returns 'Protected!' <-- Cat can jump far enough, but dog is in the way, protecting the mouse\n\nFinally, if all three animals are not present, return 'boring without all three'", "starter_code": "\ndef cat_mouse(x,j):\n\t", "test_cases": {"inputs": [["..D.....C.m", 2], ["............C.............D..m...", 8], ["m.C...", 5], [".CD......m.", 10], [".CD......m.", 1]], "outputs": [["Caught!"], ["Escaped!"], ["boring without all three"], ["Protected!"], ["Escaped!"]], "fn_name": "cat_mouse"}, "test_case_format": "function_call", "n_test_cases_total": 5, "n_test_cases_kept": 5, "test_cases_truncated": false, "problem_sha1": "1f319aec5e91806dff0feac1ff6f64b3784fe4dd", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "cat_mouse"}
{"seed_id": "apps-01516", "original_id": null, "source": "apps", "domain": "code", "problem": "In a far away country called AlgoLandia, there are `N` islands numbered `1` to `N`. Each island is denoted by `k[i]`. King Algolas, king of AlgoLandia, built `N - 1` bridges in the country. A bridge is built between islands `k[i]` and `k[i+1]`. Bridges are two-ways and are expensive to build.\n\nThe problem is that there are gangs who wants to destroy the bridges. In order to protect the bridges, the king wants to assign elite guards to the bridges. A bridge between islands `k[i]` and `k[i+1]` is safe when there is an elite guard in island `k[i]` or `k[i+1]`. There are already elite guards assigned in some islands.\n\nYour task now is to determine the minimum number of additional elite guards that needs to be hired to guard all the bridges.\n\n### Note:\nYou are given a sequence `k` with `N` length.\n`k[i] = true`, means that there is an elite guard in that island; `k[i] = false` means no elite guard. It is guaranteed that AlgoLandia have at least `2` islands.\n\n### Sample Input 1\n```\nk = [true, true, false, true, false]\n```\n\n### Sample Output 1\n```\n0\n```\n\n### Sample Input 2\n```\nk = [false, false, true, false, false]\n```\n### Sample Output 2\n```\n2\n```", "starter_code": "\ndef find_needed_guards(k):\n\t", "test_cases": {"inputs": [[[true, true, false, true, false]], [[false, false, true, false, false]], [[false, false, false, false, false]], [[false, false, false, false, false, false]], [[false, false]], [[true, false]], [[false, false, false, true, false, false, false, true]], [[false, false, true, false, true, true, true, false, true, true, true, false, true, false, false, false, true, false, false, true, true, true, true, true, false, true, false, true, true, false]], [[true, false, true, true, false, true, false, false, false, true, true, false, true, true, false, true, false, false, true, true, false, true, false, true, true, false, false, false, true, false, false, false, true, false, true, true, true, true, true, true, false]], [[true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, false, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, false, true, true, true, true]], [[true, true, true]], [[true, true, true, true, false, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true]], [[true, true, true, false, true]], [[true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true]], [[true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, false, true, true, true, true, true, true, false, true, true, true, false, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, false, true, true, true, true, true, true, true, true, true, true, true, true, true]], [[true, true, true, true, true, true, true, true, true, true, true, false]], [[true, true]], [[true, true, true, true, true, true, false, false, false, true, true, true, true, false, true, true, true, true, true, false, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true]], [[true, true, false, false, false, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, false, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, false, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]]], "outputs": [[0], [2], [2], [3], [1], [0], [2], [3], [4], [0], [0], [1], [0], [1], [1], [0], [0], [1], [2]], "fn_name": "find_needed_guards"}, "test_case_format": "function_call", "n_test_cases_total": 19, "n_test_cases_kept": 19, "test_cases_truncated": false, "problem_sha1": "7edf1556a556987df32dd840876974862bf84c34", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "find_needed_guards"}
{"seed_id": "apps-01521", "original_id": null, "source": "apps", "domain": "code", "problem": "It's tricky keeping track of who is owed what when spending money in a group. Write a function to balance the books.\n\n* The function should take one parameter: an object/dict with two or more name-value pairs which represent the members of the group and the amount spent by each.\n* The function should return an object/dict with the same names, showing how much money the members should pay or receive.\n\n**Further points:**\n\n* The values should be positive numbers if the person should receive money from the group, negative numbers if they owe money to the group.\n* If value is a decimal, round to two decimal places.\n \nTranslations and comments (and upvotes!) welcome.\n\n### Example\n\n3 friends go out together: A spends £20, B spends £15, and C spends £10. The function should return an object/dict showing that A should receive £5, B should receive £0, and C should pay £5.", "starter_code": "\ndef split_the_bill(x):\n\t", "test_cases": {"inputs": [[{"A": 20, "B": 15, "C": 10}], [{"A": 40, "B": 25, "X": 10}], [{"A": 40, "B": 25, "C": 10, "D": 153, "E": 58}], [{"A": 475, "B": 384, "C": 223, "D": 111, "E": 19}], [{"A": 20348, "B": 493045, "C": 2948, "D": 139847, "E": 48937534, "F": 1938724, "G": 4, "H": 2084}]], "outputs": [[{"A": 5.0, "B": 0.0, "C": -5.0}], [{"A": 15.0, "B": 0.0, "X": -15.0}], [{"A": -17.2, "B": -32.2, "C": -47.2, "D": 95.8, "E": 0.8}], [{"A": 232.6, "B": 141.6, "C": -19.4, "D": -131.4, "E": -223.4}], [{"A": -6421468.75, "B": -5948771.75, "C": -6438868.75, "D": -6301969.75, "E": 42495717.25, "F": -4503092.75, "G": -6441812.75, "H": -6439732.75}]], "fn_name": "split_the_bill"}, "test_case_format": "function_call", "n_test_cases_total": 5, "n_test_cases_kept": 5, "test_cases_truncated": false, "problem_sha1": "765171515d51f17ad999b168821e480eca346bf0", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "split_the_bill"}
{"seed_id": "apps-01526", "original_id": null, "source": "apps", "domain": "code", "problem": "Remove the parentheses\n=\nIn this kata you are given a string for example:\n\n```python\n\"example(unwanted thing)example\"\n```\n\nYour task is to remove everything inside the parentheses as well as the parentheses themselves.\n\nThe example above would return:\n\n```python\n\"exampleexample\"\n```\n\nOther than parentheses only letters and spaces can occur in the string. Don't worry about other brackets like ```\"[]\"``` and ```\"{}\"``` as these will never appear.", "starter_code": "\ndef remove_parentheses(s):\n\t", "test_cases": {"inputs": [["example(unwanted thing)example"], ["example (unwanted thing) example"], ["a (bc d)e"], ["a(b(c))"], ["hello example (words(more words) here) something"], ["(first group) (second group) (third group)"]], "outputs": [["exampleexample"], ["example  example"], ["a e"], ["a"], ["hello example  something"], ["  "]], "fn_name": "remove_parentheses"}, "test_case_format": "function_call", "n_test_cases_total": 6, "n_test_cases_kept": 6, "test_cases_truncated": false, "problem_sha1": "e2e66aea93d1491e711b2c8a3f7611e3dbb3c2d8", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "remove_parentheses"}
{"seed_id": "apps-01531", "original_id": null, "source": "apps", "domain": "code", "problem": "# Task\n The string is called `prime` if it cannot be constructed by concatenating some (more than one) equal strings together.\n\n For example, \"abac\" is prime, but \"xyxy\" is not(\"xyxy\"=\"xy\"+\"xy\").\n \n Given a string determine if it is prime or not.\n\n# Input/Output\n\n\n - `[input]` string `s`\n\n  string containing only lowercase English letters\n\n - `[output]` a boolean value\n\n  `true` if the string is prime, `false` otherwise", "starter_code": "\ndef prime_string(s):\n\t", "test_cases": {"inputs": [["abac"], ["abab"], ["aaaa"], ["x"], ["abc"], ["fdsyffdsyffdsyffdsyffdsyf"], ["utdutdtdutd"], ["abba"]], "outputs": [[true], [false], [false], [true], [true], [false], [true], [true]], "fn_name": "prime_string"}, "test_case_format": "function_call", "n_test_cases_total": 8, "n_test_cases_kept": 8, "test_cases_truncated": false, "problem_sha1": "77245bf171cd877c34c406f8f6f740b4ac39838a", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "prime_string"}
{"seed_id": "apps-01536", "original_id": null, "source": "apps", "domain": "code", "problem": "Complete the square sum function so that it squares each number passed into it and then sums the results together.\n\nFor example, for `[1, 2, 2]` it should return `9` because `1^2 + 2^2 + 2^2 = 9`.\n\n```if:racket\nIn Racket, use a list instead of an array, so '(1 2 3) should return 9.\n```", "starter_code": "\ndef square_sum(numbers):\n\t", "test_cases": {"inputs": [[[1, 2]], [[0, 3, 4, 5]], [[]], [[-1, -2]], [[-1, 0, 1]]], "outputs": [[5], [50], [0], [5], [2]], "fn_name": "square_sum"}, "test_case_format": "function_call", "n_test_cases_total": 5, "n_test_cases_kept": 5, "test_cases_truncated": false, "problem_sha1": "d602f24f1cfa3e40758be9ca8051577269ab9e78", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "square_sum"}
{"seed_id": "apps-01541", "original_id": null, "source": "apps", "domain": "code", "problem": "Write a function `take_umbrella()` that takes two arguments: a string representing the current weather and a float representing the chance of rain today.\n\nYour function should return `True` or `False` based on the following criteria.\n\n* You should take an umbrella if it's currently raining or if it's cloudy and the chance of rain is over `0.20`.\n* You shouldn't take an umbrella if it's sunny unless it's more likely to rain than not.\n\nThe options for the current weather are `sunny`, `cloudy`, and `rainy`.\n\nFor example, `take_umbrella('sunny', 0.40)` should return `False`.\n\nAs an additional challenge, consider solving this kata using only logical operaters and not using any `if` statements.", "starter_code": "\ndef take_umbrella(weather, rain_chance):\n\t", "test_cases": {"inputs": [["sunny", 0.4], ["rainy", 0.0], ["cloudy", 0.2]], "outputs": [[false], [true], [false]], "fn_name": "take_umbrella"}, "test_case_format": "function_call", "n_test_cases_total": 3, "n_test_cases_kept": 3, "test_cases_truncated": false, "problem_sha1": "0f5f0fb45858569f548c82045bf43de47bf88623", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "take_umbrella"}
{"seed_id": "apps-01546", "original_id": null, "source": "apps", "domain": "code", "problem": "**Step 1:** Create a function called `encode()` to replace all the lowercase vowels in a given string with numbers according to the following pattern:\n```\na -> 1\ne -> 2\ni -> 3\no -> 4\nu -> 5\n```\n\nFor example, `encode(\"hello\")` would return `\"h2ll4\"`. There is no need to worry about uppercase vowels in this kata.\n\n**Step 2:** Now create a function called `decode()` to turn the numbers back into vowels according to the same pattern shown above.\n\nFor example, `decode(\"h3 th2r2\")` would return `\"hi there\"`.\n\nFor the sake of simplicity, you can assume that any numbers passed into the function will correspond to vowels.", "starter_code": "\ndef encode(st):\n\t", "test_cases": {"inputs": [["hello"], ["How are you today?"], ["This is an encoding test."]], "outputs": [["h2ll4"], ["H4w 1r2 y45 t4d1y?"], ["Th3s 3s 1n 2nc4d3ng t2st."]], "fn_name": "encode"}, "test_case_format": "function_call", "n_test_cases_total": 3, "n_test_cases_kept": 3, "test_cases_truncated": false, "problem_sha1": "0a6fbc732f7bb81f455091807a78fada597a1cc8", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "encode"}
{"seed_id": "apps-01551", "original_id": null, "source": "apps", "domain": "code", "problem": "The task is very simple.\n\nYou must to return pyramids. Given a number ```n```  you print a pyramid with ```n``` floors\n\nFor example , given a ```n=4``` you must to print this pyramid:\n\n```\n   /\\\n  /  \\\n /    \\\n/______\\ \n   \n```\n\nOther example, given a ```n=6``` you must to print this pyramid:\n\n```  \n     /\\\n    /  \\\n   /    \\\n  /      \\\n /        \\\n/__________\\\n\n```\n\nAnother example, given a ```n=10```, you must to print this pyramid:\n\n```\n         /\\\n        /  \\\n       /    \\\n      /      \\\n     /        \\\n    /          \\\n   /            \\\n  /              \\\n /                \\\n/__________________\\\n\n```\n\nNote: an extra line feed character is needed at the end of the string. Case `n=0` should so return `\"\\n\"`.", "starter_code": "\ndef pyramid(n):\n\t", "test_cases": {"inputs": [[4], [6], [10]], "outputs": [["   /\\\n  /  \\\n /    \\\n/______\\\n"], ["     /\\\n    /  \\\n   /    \\\n  /      \\\n /        \\\n/__________\\\n"], ["         /\\\n        /  \\\n       /    \\\n      /      \\\n     /        \\\n    /          \\\n   /            \\\n  /              \\\n /                \\\n/__________________\\\n"]], "fn_name": "pyramid"}, "test_case_format": "function_call", "n_test_cases_total": 3, "n_test_cases_kept": 3, "test_cases_truncated": false, "problem_sha1": "eb350e4c14fbdcd421e5d1bb59d2279e7b133d85", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "pyramid"}
{"seed_id": "apps-01556", "original_id": null, "source": "apps", "domain": "code", "problem": "# Task\n Given string `s`, which contains only letters from `a to z` in lowercase.\n\n A set of alphabet is given by `abcdefghijklmnopqrstuvwxyz`.\n \n 2 sets of alphabets mean 2 or more alphabets.\n \n Your task is to find the missing letter(s). You may need to output them by the order a-z. It is possible that there is more than one missing letter from more than one set of alphabet.\n\n If the string contains all of the letters in the alphabet, return an empty string `\"\"`\n\n# Example\n\n For `s='abcdefghijklmnopqrstuvwxy'`\n\n The result should be `'z'`\n\n For `s='aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyy'`\n \n The result should be `'zz'`\n\n For `s='abbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxy'`\n \n The result should be `'ayzz'`\n\n For `s='codewars'`\n \n The result should be `'bfghijklmnpqtuvxyz'`\n\n# Input/Output\n\n\n - `[input]` string `s`\n\n  Given string(s) contains one or more set of alphabets in lowercase.\n\n\n - `[output]` a string\n\n  Find the letters contained in each alphabet but not in the string(s). Output them by the order `a-z`. If missing alphabet is repeated, please repeat them like `\"bbccdd\"`, not `\"bcdbcd\"`", "starter_code": "\ndef missing_alphabets(s):\n\t", "test_cases": {"inputs": [["abcdefghijklmnopqrstuvwxy"], ["abcdefghijklmnopqrstuvwxyz"], ["aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyy"], ["abbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxy"], ["codewars"]], "outputs": [["z"], [""], ["zz"], ["ayzz"], ["bfghijklmnpqtuvxyz"]], "fn_name": "missing_alphabets"}, "test_case_format": "function_call", "n_test_cases_total": 5, "n_test_cases_kept": 5, "test_cases_truncated": false, "problem_sha1": "3c149af884f9fc4e2637157a4d3641a3d2923914", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "missing_alphabets"}
{"seed_id": "apps-01561", "original_id": null, "source": "apps", "domain": "code", "problem": "## The story you are about to hear is true\nOur cat, Balor, sadly died of cancer in 2015.\n\nWhile he was alive, the three neighborhood cats Lou, Mustache Cat, and Raoul all recognized our house and yard as Balor's territory, and would behave respectfully towards him and each other when they would visit. \n\nBut after Balor died, gradually each of these three neighborhood cats began trying to claim his territory as their own, trying to drive the others away by growling, yowling, snarling, chasing, and even fighting, when one came too close to another, and no human was right there to distract or extract one of them before the situation could escalate. \n\nIt is sad that these otherwise-affectionate animals, who had spent many afternoons peacefully sitting and/or lying near Balor and each other on our deck or around our yard, would turn on each other like that. However, sometimes, if they are far enough away from each other, especially on a warm day when all they really want to do is pick a spot in the sun and lie in it, they will ignore each other, and once again there will be a Peaceable Kingdom.\n\n## Your Mission\nIn this, the first and simplest of a planned trilogy of cat katas :-), all you have to do is determine whether the distances between any visiting cats are large enough to make for a peaceful afternoon, or whether there is about to be an altercation someone will need to deal with by carrying one of them into the house or squirting them with water or what have you.\n\nAs input your function will receive a list of strings representing the yard as a grid, and an integer representing the minimum distance needed to prevent problems (considering the cats' current states of sleepiness). A point with no cat in it will be represented by a \"-\" dash. Lou, Mustache Cat, and Raoul will be represented by an upper case L, M, and R respectively. At any particular time all three cats may be in the yard, or maybe two, one, or even none. \n\nIf the number of cats in the yard is one or none, or if the distances between all cats are at least the minimum distance, your function should return True/true/TRUE (depending on what language you're using), but if there are two or three cats, and the distance between at least two of them is smaller than the minimum distance, your function should return False/false/FALSE.\n\n## Some examples\n(The yard will be larger in the random test cases, but a smaller yard is easier to see and fit into the instructions here.)\n\nIn this first example, there is only one cat, so your function should return True.\n```\n[\"------------\",\n \"------------\",\n \"-L----------\",\n \"------------\",\n \"------------\",\n \"------------\"], 10\n```\nIn this second example, Mustache Cat is at the point yard[1][3] and Raoul is at the point yard[4][7] -- a distance of 5, so because the distance between these two points is smaller than the specified minimum distance of 6, there will be trouble, and your function should return False. \n```\n[\"------------\",\n \"---M--------\",\n \"------------\",\n \"------------\",\n \"-------R----\",\n \"------------\"], 6\n```\nIn this third example, Lou is at yard[0][11], Raoul is at yard[1][2], and Mustache Cat at yard[5][2]. The distance between Lou and Raoul is 9.05538513814, the distance between Raoul and Mustache Cat is 4, and the distance between Mustache Cat and Lou is 10.295630141 -- all greater than or equal to the specified minimum distance of 4, so the three cats will nap peacefully, and your function should return True.\n```\n[\"-----------L\",\n \"--R---------\",\n \"------------\",\n \"------------\",\n \"------------\",\n \"--M---------\"], 4\n```\nHave fun!", "starter_code": "\ndef peaceful_yard(yard, min_distance):\n\t", "test_cases": {"inputs": [[["------------", "------------", "-L----------", "------------", "------------", "------------"], 10], [["------------", "---M--------", "------------", "------------", "-------R----", "------------"], 6], [["-----------L", "--R---------", "------------", "------------", "------------", "--M---------"], 4], [["------------", "--L-------R-", "----M-------", "------------", "------------", "------------"], 6], [["-----------R", "--L---------", "------------", "------------", "------------", "----------M-"], 4], [["------------", "--L---R-----", "------------", "------------", "------M-----", "------------"], 6], [["------------", "--L---R---M-", "------------", "------------", "------------", "------------"], 6], [["------------", "--L---R---M-", "------------", "------------", "------------", "------------"], 2]], "outputs": [[true], [false], [true], [false], [true], [false], [false], [true]], "fn_name": "peaceful_yard"}, "test_case_format": "function_call", "n_test_cases_total": 8, "n_test_cases_kept": 8, "test_cases_truncated": false, "problem_sha1": "c2d6825b6d5c5719ff1881ce3ea86cf0e212f4a5", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "peaceful_yard"}
{"seed_id": "apps-01566", "original_id": null, "source": "apps", "domain": "code", "problem": "The \"Russian Peasant Method\" is an old algorithm used by Russian peasants (and before them ancient Egyptians) to perform multiplication.  Consider that X and Y are two numbers.  X can be any number but Y must be a positive integer. To multiply X and Y:\n\n1. Let the product = 0\n2. If Y is odd, then the product = product + X\n3. X = X + X\n4. Y = integer part of Y / 2 \n5. if Y is nonzero, repeat from step 2; otherwise the algorithm terminates and returns the product.\n\nFor example:\n\nLet X = 10\n\nLet Y = 5\n\nX: 10 20 40 80\n\nY: 5  2  1  0\n\nproduct = 10 + 40 = 50\n\nNote: usage of multiplication is of course forbidden...", "starter_code": "\ndef russian_peasant_multiplication(x, y):\n\t", "test_cases": {"inputs": [[10, 5], [1.001, 2], [175, 18], [-2, 2], [2500, 123]], "outputs": [[50], [2.002], [3150], [-4], [307500]], "fn_name": "russian_peasant_multiplication"}, "test_case_format": "function_call", "n_test_cases_total": 5, "n_test_cases_kept": 5, "test_cases_truncated": false, "problem_sha1": "0d54ec3072548c1377a5d64ef1cbc78a07285e3d", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "russian_peasant_multiplication"}
{"seed_id": "apps-01571", "original_id": null, "source": "apps", "domain": "code", "problem": "Check if it is a vowel(a, e, i, o, u,) on the ```n``` position in a string (the first argument). Don't forget about uppercase.\n\nA few cases:\n\n```\n{\ncheckVowel('cat', 1)  ->   true // 'a' is a vowel\ncheckVowel('cat', 0)  ->   false // 'c' is not a vowel\ncheckVowel('cat', 4)  ->   false // this position doesn't exist\n}\n```\nP.S. If n < 0, return false", "starter_code": "\ndef check_vowel(string, position):\n\t", "test_cases": {"inputs": [["cat", 1], ["cat", 0], ["cat", 4], ["Amanda", -2], ["Amanda", 0], ["Amanda", 2]], "outputs": [[true], [false], [false], [false], [true], [true]], "fn_name": "check_vowel"}, "test_case_format": "function_call", "n_test_cases_total": 6, "n_test_cases_kept": 6, "test_cases_truncated": false, "problem_sha1": "16b72e24489ee7d08b8f5108ec33d9251238dd2c", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "check_vowel"}
{"seed_id": "apps-01576", "original_id": null, "source": "apps", "domain": "code", "problem": "Write a method that will search an array of strings for all strings that contain another string, ignoring capitalization. Then return an array of the found strings. \n\nThe method takes two parameters, the query string and the array of strings to search, and returns an array. \n\nIf the string isn't contained in any of the strings in the array, the method returns an array containing a single string: \"Empty\" (or `Nothing` in Haskell, or \"None\" in Python and C)\n\n### Examples\nIf the string to search for is \"me\", and the array to search is [\"home\", \"milk\", \"Mercury\", \"fish\"], the method should return [\"home\", \"Mercury\"].", "starter_code": "\ndef word_search(query, seq):\n\t", "test_cases": {"inputs": [["ab", ["za", "ab", "abc", "zab", "zbc"]], ["aB", ["za", "ab", "abc", "zab", "zbc"]], ["ab", ["za", "aB", "Abc", "zAB", "zbc"]], ["abcd", ["za", "aB", "Abc", "zAB", "zbc"]]], "outputs": [[["ab", "abc", "zab"]], [["ab", "abc", "zab"]], [["aB", "Abc", "zAB"]], [["None"]]], "fn_name": "word_search"}, "test_case_format": "function_call", "n_test_cases_total": 4, "n_test_cases_kept": 4, "test_cases_truncated": false, "problem_sha1": "816f9cb41ff7aea9d6ac58e183f9e3ce9e31c2da", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "word_search"}
{"seed_id": "apps-01581", "original_id": null, "source": "apps", "domain": "code", "problem": "Your users passwords were all stole in the Yahoo! hack, and it turns out they have been lax in creating secure passwords.  Create a function that checks their new password (passed as a string) to make sure it meets the following requirements:\n\n\nBetween 8 - 20 characters\n\nContains only the following characters: (and at least one character from each category): uppercase letters, lowercase letters, digits, and the special characters !@#$%^&*?\n\n\n\n\nReturn \"valid\" if passed or else \"not valid\"", "starter_code": "\ndef check_password(s):\n\t", "test_cases": {"inputs": [[""], ["password"], ["P1@p"], ["P1@pP1@p"], ["P1@pP1@pP1@pP1@pP1@pP1@p"]], "outputs": [["not valid"], ["not valid"], ["not valid"], ["valid"], ["not valid"]], "fn_name": "check_password"}, "test_case_format": "function_call", "n_test_cases_total": 5, "n_test_cases_kept": 5, "test_cases_truncated": false, "problem_sha1": "1b6bce4640b4a0c4ff70ee2cde910471707c3d59", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "check_password"}
{"seed_id": "apps-01586", "original_id": null, "source": "apps", "domain": "code", "problem": "You are working at a lower league football stadium and you've been tasked with automating the scoreboard.\n\nThe referee will shout out the score, you have already set up the voice recognition module which turns the ref's voice into a string, but the spoken score needs to be converted into a pair for the scoreboard!\n\ne.g. `\"The score is four nil\"` should return `[4,0]`\n\nEither teams score has a range of 0-9, and the ref won't say the same string every time e.g. \n      \n    \"new score: two three\"\n      \n    \"two two\"\n      \n    \"Arsenal just conceded another goal, two nil\"\n    \nNote:\n```python\nPlease return an array\n```\n\nPlease rate and enjoy!", "starter_code": "\ndef scoreboard(string):\n\t", "test_cases": {"inputs": [["The score is four nil"], ["new score: two three"], ["two two"], ["Arsenal just conceded another goal, two nil"]], "outputs": [[[4, 0]], [[2, 3]], [[2, 2]], [[2, 0]]], "fn_name": "scoreboard"}, "test_case_format": "function_call", "n_test_cases_total": 4, "n_test_cases_kept": 4, "test_cases_truncated": false, "problem_sha1": "1740c14eb2064ad0e359c45bbac8279a2bc491a4", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "scoreboard"}
{"seed_id": "apps-01591", "original_id": null, "source": "apps", "domain": "code", "problem": "DNA sequencing data can be stored in many different formats. In this Kata, we will be looking at SAM formatting. It is a plain text file where every line (excluding the first header lines) contains data about a \"read\" from whatever sample the file comes from. Rather than focusing on the whole read, we will take two pieces of information: the cigar string and the nucleotide sequence.\n\nThe cigar string is composed of numbers and flags. It represents how the read aligns to what is known as a reference genome. A reference genome is an accepted standard for mapping the DNA. \n\nThe nucleotide sequence shows us what bases actually make up that section of DNA. They can be represented with the letters A, T, C, or G.\n\nExample Read: ('36M', 'ACTCTTCTTGCGAAAGTTCGGTTAGTAAAGGGGATG')\n\nThe M in the above cigar string stands for \"match\", and the 36 stands for the length of the nucleotide sequence. Since all 36 bases are given the 'M' distinction, we know they all matched the reference.\n\nExample Read: ('20M10S',  'ACTCTTCTTGCGAAAGTTCGGTTAGTAAAG')\n\nIn the above cigar string, only 20 have the \"M\" distinction, but the length of the actual string of nucleotides is 30. Therefore we know that read did not match the reference. (Don't worry about what the other letters mean. That will be covered in a later kata.)\n\nYour job for this kata is to create a function that determines whether a cigar string fully matches the reference and accounts for all bases. If it does fully match, return True. If the numbers in the string do not match the full length of the string, return 'Invalid cigar'. If it does not fully match, return False.\n\n*Note for C++: Return True, False, or Invalid cigar as strings*", "starter_code": "\ndef is_matched(read):\n\t", "test_cases": {"inputs": [[["36M", "CATAATACTTTACCTACTCTCAACAAATGCGGGAGA"]], [["10M6H", "GAGCGAGTGCGCCTTAC"]], [["12S", "TGTTTCTCCAAG"]]], "outputs": [[true], ["Invalid cigar"], [false]], "fn_name": "is_matched"}, "test_case_format": "function_call", "n_test_cases_total": 3, "n_test_cases_kept": 3, "test_cases_truncated": false, "problem_sha1": "ab36d74b42a455acb1ac5d75135b53d5cdef955f", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "is_matched"}
{"seed_id": "apps-01596", "original_id": null, "source": "apps", "domain": "code", "problem": "Mr. Scrooge has a sum of money 'P' that he wants to invest. Before he does, he wants to know how many years 'Y' this sum 'P' has to be kept in the bank in order for it to amount to a desired sum of money 'D'.\n\nThe sum is kept for 'Y' years in the bank where interest 'I' is paid yearly. After paying taxes 'T' for the year the new sum is re-invested.\n\nNote to Tax: not the invested principal is taxed, but only the year's accrued interest\n\nExample:\n\n      Let P be the Principal = 1000.00      \n      Let I be the Interest Rate = 0.05      \n      Let T be the Tax Rate = 0.18      \n      Let D be the Desired Sum = 1100.00\n\n\n    After 1st Year -->\n      P = 1041.00\n    After 2nd Year -->\n      P = 1083.86\n    After 3rd Year -->\n      P = 1128.30\n  \nThus Mr. Scrooge has to wait for 3 years for the initial principal to amount to the desired sum.\n \nYour task is to complete the method provided and return the number of years 'Y' as a whole in order for Mr. Scrooge to get the desired sum.  \n\nAssumption: Assume that Desired Principal 'D' is always greater than the initial principal. However it is best to take into consideration that if Desired Principal 'D' is equal to Principal 'P' this should return 0 Years.", "starter_code": "\ndef calculate_years(principal, interest, tax, desired):\n\t", "test_cases": {"inputs": [[1000, 0.05, 0.18, 1100], [1000, 0.01625, 0.18, 1200], [1000, 0.05, 0.18, 1000]], "outputs": [[3], [14], [0]], "fn_name": "calculate_years"}, "test_case_format": "function_call", "n_test_cases_total": 3, "n_test_cases_kept": 3, "test_cases_truncated": false, "problem_sha1": "71d38ea3fce991037f213271e973ee956c0fd991", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "calculate_years"}
{"seed_id": "apps-01601", "original_id": null, "source": "apps", "domain": "code", "problem": "## Grade book\n\nComplete the function so that it finds the mean of the three scores passed to it and returns the letter value associated with that grade.\n\nNumerical Score    | Letter Grade\n---                | ---\n90 <= score <= 100 | 'A'\n80 <= score < 90   | 'B'\n70 <= score < 80   | 'C'\n60 <= score < 70   | 'D'\n 0 <= score < 60   | 'F'\n\nTested values are all between 0 and 100. Theres is no need to check for negative values or values greater than 100.", "starter_code": "\ndef get_grade(s1, s2, s3):\n\t", "test_cases": {"inputs": [[95, 90, 93], [100, 85, 96], [92, 93, 94], [100, 100, 100], [70, 70, 100], [82, 85, 87], [84, 79, 85], [70, 70, 70], [75, 70, 79], [60, 82, 76], [65, 70, 59], [66, 62, 68], [58, 62, 70], [44, 55, 52], [48, 55, 52], [58, 59, 60], [0, 0, 0]], "outputs": [["A"], ["A"], ["A"], ["A"], ["B"], ["B"], ["B"], ["C"], ["C"], ["C"], ["D"], ["D"], ["D"], ["F"], ["F"], ["F"], ["F"]], "fn_name": "get_grade"}, "test_case_format": "function_call", "n_test_cases_total": 17, "n_test_cases_kept": 17, "test_cases_truncated": false, "problem_sha1": "408c7300241242d90436b2ac24043db2c5bccfa3", "leakage_note": "question_and_tests_only_no_solution_or_reasoning; test_cases are the VERIFIER not an answer", "do_not_use_fields": ["ground_truth_solution", "deepseek_solution", "deepseek_reasoning"], "reference_passed": true, "fn_name": "get_grade"}