Score : 200 points
\n\n\n \n
\nProblem Statement
Takahashi is competing in a sumo tournament.\nThe tournament lasts for 15 days, during which he performs in one match per day.\nIf he wins 8 or more matches, he can also participate in the next tournament.
\nThe matches for the first k days have finished.\nYou are given the results of Takahashi's matches as a string S consisting of o and x.\nIf the i-th character in S is o, it means that Takahashi won the match on the i-th day; if that character is x, it means that Takahashi lost the match on the i-th day.
Print YES if there is a possibility that Takahashi can participate in the next tournament, and print NO if there is no such possibility.
\n\n \n
\nConstraints
- \n
- 1 \\leq k \\leq 15 \n
- S is a string of length k consisting of
oandx. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nS\n\n
\n\n \n
\nOutput
Print YES if there is a possibility that Takahashi can participate in the next tournament, and print NO otherwise.
\n
\n\n \n
\nSample Input 1
oxoxoxoxoxoxox\n\n
\n\n \n
\nSample Output 1
YES\n\n
Takahashi has 7 wins and 7 losses before the last match. If he wins that match, he will have 8 wins.
\n\n
\n\n \n
\nSample Input 2
xxxxxxxx\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int cnt = 15;\n int s = 0;\n char i;\n char *mes = \"YES\";\n while (1) {\n scanf(\"%c\", &i);\n if (i == '\\n') {\n break;\n }\n if (i == 'o') {\n s++;\n }\n cnt--;\n }\n if (cnt + s < 8) {\n mes = \"NO\";\n }\n printf(\"%s\\n\", mes);\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n let chars: VecSample Output 2
NO\n
Score : 100 points
\n\n\n \n
\nProblem Statement
Ringo is giving a present to Snuke.
\nRingo has found out that Snuke loves yakiniku (a Japanese term meaning grilled meat. yaki: grilled, niku: meat). He supposes that Snuke likes grilled things starting with YAKI in Japanese, and does not like other things.
You are given a string S representing the Japanese name of Ringo's present to Snuke. Determine whether S starts with YAKI.
\n\n \n
\nConstraints
- \n
- 1 \\leq |S| \\leq 10 \n
- S consists of uppercase English letters. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nS\n\n
\n\n \n
\nOutput
If S starts with YAKI, print Yes; otherwise, print No.
\n
\n\n \n
\nSample Input 1
YAKINIKU\n\n
\n\n \n
\nSample Output 1
Yes\n\n
YAKINIKU starts with YAKI.
\n
\n\n \n
\nSample Input 2
TAKOYAKI\n\n
\n\n \n
\nSample Output 2
No\n\n
TAKOYAKI (a Japanese snack. tako: octopus) does not start with YAKI.
\n
\n\n \n
\nSample Input 3
YAK\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n char po[114];\n scanf(\"%s\", po);\n if (strlen(po) >= 4 && po[0] == 'Y' && po[1] == 'A' && po[2] == 'K' &&\n po[3] == 'I') {\n printf(\"Yes\");\n } else {\n printf(\"No\");\n }\n return 0;\n}", "rust_code": "fn solution() {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).ok();\n if s.chars().take(4).collect::Sample Output 3
No\n
Score : 300 points
\n\n\n \n
\nProblem Statement
Hearing that energy drinks increase rating in those sites, Takahashi decides to buy up M cans of energy drinks.
\nThere are N stores that sell energy drinks. In the i-th store, he can buy at most B_i cans of energy drinks for A_i yen (the currency of Japan) each.
\nWhat is the minimum amount of money with which he can buy M cans of energy drinks?
\nIt is guaranteed that, in the given inputs, a sufficient amount of money can always buy M cans of energy drinks.
\n\n\n \n
\nConstraints
- \n
- All values in input are integers. \n
- 1 \\leq N, M \\leq 10^5 \n
- 1 \\leq A_i \\leq 10^9 \n
- 1 \\leq B_i \\leq 10^5 \n
- B_1 + ... + B_N \\geq M \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN M\nA_1 B_1\nA_2 B_2\n\\vdots\nA_N B_N\n\n
\n\n \n
\nOutput
Print the minimum amount of money with which Takahashi can buy M cans of energy drinks.
\n\n
\n\n \n
\nSample Input 1
2 5\n4 9\n2 4\n\n
\n\n \n
\nSample Output 1
12\n\n
With 12 yen, we can buy one drink at the first store and four drinks at the second store, for the total of five drinks. However, we cannot buy 5 drinks with 11 yen or less.
\n\n
\n\n \n
\nSample Input 2
4 30\n6 18\n2 5\n3 10\n7 9\n\n
\n\n \n
\nSample Output 2
130\n\n
\n
\n\n \n
\nSample Input 3
1 100000\n1000000000 100000\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n long long int n;\n long long int m;\n long long int i;\n long long int kei = 0;\n long long int a[100000];\n long long int b[100000];\n scanf(\"%lld %lld\", &n, &m);\n for (i = 0; i < n; i++) {\n scanf(\"%lld %lld\", &a[i], &b[i]);\n }\n\n int j;\n int increment;\n int temp;\n int temp_b;\n increment = 4;\n int array_size = n;\n while (increment > 0) {\n for (i = 0; i < array_size; i++) {\n j = i;\n temp = a[i];\n temp_b = b[i];\n while ((j >= increment) && (a[j - increment] > temp)) {\n a[j] = a[j - increment];\n b[j] = b[j - increment];\n j = j - increment;\n }\n a[j] = temp;\n b[j] = temp_b;\n }\n if (increment / 2 != 0) {\n increment = increment / 2;\n } else if (increment == 1) {\n increment = 0;\n } else {\n increment = 1;\n }\n }\n for (i = 0; i < n; i++) {\n if (m >= b[i]) {\n kei = (a[i] * b[i]) + kei;\n } else if (m == 0) {\n break;\n } else {\n kei = kei + (a[i] * m);\n break;\n }\n m = m - b[i];\n }\n printf(\"%lld\", kei);\n return 0;\n}", "rust_code": "fn solution() {\n let mut nm = String::new();\n stdin().read_line(&mut nm).unwrap();\n let nm: VecSample Output 3
100000000000000\n\n
The output may not fit into a 32-bit integer type.
Score : 400 points
\n\n\n \n
\nProblem Statement
For an integer N, we will choose a permutation \\{P_1, P_2, ..., P_N\\} of \\{1, 2, ..., N\\}.
\nThen, for each i=1,2,...,N, let M_i be the remainder when i is divided by P_i.
\nFind the maximum possible value of M_1 + M_2 + \\cdots + M_N.
\n\n\n \n
\nConstraints
- \n
- N is an integer satisfying 1 \\leq N \\leq 10^9. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\n\n
\n\n \n
\nOutput
Print the maximum possible value of M_1 + M_2 + \\cdots + M_N.
\n\n
\n\n \n
\nSample Input 1
2\n\n
\n\n \n
\nSample Output 1
1\n\n
When the permutation \\{P_1, P_2\\} = \\{2, 1\\} is chosen, M_1 + M_2 = 1 + 0 = 1.
\n\n
\n\n \n
\nSample Input 2
13\n\n
\n\n \n
\nSample Output 2
78\n\n
\n
\n\n \n
\nSample Input 3
1\n\n
\n\n \n
\n", "c_code": "int solution() {\n long long n = 0;\n long long result = 0;\n scanf(\"%lld\", &n);\n result = n * (n - 1) / 2;\n printf(\"%lld\", result);\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = io::stdin();\n let mut input = String::new();\n stdin.lock().read_line(&mut input).expect(\"read line!\");\n let input: String = input;\n let n: u64 = input.trim().parse().unwrap();\n println!(\"{}\", (n * (n - 1)) / 2);\n}", "difficulty": "easy"}
{"problem_id": "0011", "problem_description": "Okabe and Super Hacker Daru are stacking and removing boxes. There are n boxes numbered from 1 to n. Initially there are no boxes on the stack.Okabe, being a control freak, gives Daru 2n commands: n of which are to add a box to the top of the stack, and n of which are to remove a box from the top of the stack and throw it in the trash. Okabe wants Daru to throw away the boxes in the order from 1 to n. Of course, this means that it might be impossible for Daru to perform some of Okabe's remove commands, because the required box is not on the top of the stack.That's why Daru can decide to wait until Okabe looks away and then reorder the boxes in the stack in any way he wants. He can do it at any point of time between Okabe's commands, but he can't add or remove boxes while he does it.Tell Daru the minimum number of times he needs to reorder the boxes so that he can successfully complete all of Okabe's commands. It is guaranteed that every box is added before it is required to be removed.", "c_code": "int solution(void) {\n int n = 0;\n int num = 0;\n int cnt = 0;\n int top = -1;\n int target = 1;\n char cmd[20] = {\n 0,\n };\n int stack[300001] = {\n 0,\n };\n\n scanf(\"%d\", &n);\n n *= 2;\n\n while (n--) {\n scanf(\"%s\", cmd);\n if (cmd[0] == 'a') {\n scanf(\"%d\", &num);\n stack[++top] = num;\n } else {\n if (top >= 0) {\n if (stack[top] != target) {\n top = -1;\n cnt++;\n } else {\n top--;\n }\n }\n\n target++;\n }\n }\n\n printf(\"%d\\n\", cnt);\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut n = String::new();\n stdin().read_line(&mut n).unwrap();\n let n = n.trim().parse::Sample Output 3
0\n
Score : 200 points
\n\n\n \n
\nProblem Statement
There are N apple trees in a row. People say that one of them will bear golden apples.
\nWe want to deploy some number of inspectors so that each of these trees will be inspected.
\nEach inspector will be deployed under one of the trees. For convenience, we will assign numbers from 1 through N to the trees. An inspector deployed under the i-th tree (1 \\leq i \\leq N) will inspect the trees with numbers between i-D and i+D (inclusive).
\nFind the minimum number of inspectors that we need to deploy to achieve the objective.
\n\n\n \n
\nConstraints
- \n
- All values in input are integers. \n
- 1 \\leq N \\leq 20 \n
- 1 \\leq D \\leq 20 \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN D\n\n
\n\n \n
\nOutput
Print the minimum number of inspectors that we need to deploy to achieve the objective.
\n\n
\n\n \n
\nSample Input 1
6 2\n\n
\n\n \n
\nSample Output 1
2\n\n
We can achieve the objective by, for example, placing an inspector under Tree 3 and Tree 4.
\n\n
\n\n \n
\nSample Input 2
14 3\n\n
\n\n \n
\nSample Output 2
2\n\n
\n
\n\n \n
\nSample Input 3
20 4\n\n
\n\n \n
\n", "c_code": "int solution() {\n int N = 0;\n int D = 0;\n int c = 0;\n scanf(\"%d %d\", &N, &D);\n while (N > 0) {\n N = N - (2 * D + 1);\n c++;\n }\n printf(\"%d\\n\", c);\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut nd = String::new();\n stdin().read_line(&mut nd).unwrap();\n let nd: VecSample Output 3
3\n
Naive String Search
\n\n\n Find places where a string P is found within a text T.\n \n Print all indices of T where P found. The indices of T start with 0.\n
\n\nInput
\n\n\n In the first line, a text T is given. In the second line, a string P is given.\n
\n\noutput
\n\n\n Print an index of T where P found in a line. Print the indices in ascending order.\n
\n\nConstraints
\n\n- \n
- 1 ≤ length of T ≤ 1000 \n
- 1 ≤ length of P ≤ 1000 \n
- The input consists of alphabetical characters and digits \n
Sample Input 1
\n\naabaaa\naa\n\n\n
Sample Output 1
\n\n0\n3\n4\n\n\n
Sample Input 2
\n\nxyzz\nyz\n\n\n
Sample Output 2
\n\n1\n\n\n\n\n
Sample Input 3
\n\nabc\nxyz\n\n\n
Sample Output3
\n\n\n
\nThe ouput should be empty.\n
", "c_code": "int solution(void) {\n char t[1000];\n char p[1000];\n int n;\n int m;\n scanf(\"%s\", t);\n scanf(\"%s\", p);\n for (n = 0; t[n] != '\\0'; n++) {\n ;\n }\n for (m = 0; p[m] != '\\0'; m++) {\n ;\n }\n\n int i = 0;\n int j = 0;\n while (i <= n - m) {\n while (j < m && t[i + j] == p[j]) {\n\n j++;\n }\n if (j == m) {\n printf(\"%d\\n\", i);\n }\n i++;\n j = 0;\n }\n return 0;\n}", "rust_code": "fn solution() {\n let mut read = String::new();\n std::io::stdin().read_line(&mut read).expect(\"\");\n let mut s = read.clone();\n s = s.trim().to_string();\n read = String::new();\n std::io::stdin().read_line(&mut read).expect(\"\");\n let f = read.trim();\n if f.len() > s.len() {\n std::process::exit(0);\n }\n for i in 0..(s.len() - f.len() + 1) {\n if &s[i..i + f.len()] == f {\n println!(\"{}\", i);\n }\n }\n}", "difficulty": "medium"} {"problem_id": "0014", "problem_description": "\nScore : 300 points
\n\n\n \n
\nProblem Statement
Takahashi has N balls. Initially, an integer A_i is written on the i-th ball.
\nHe would like to rewrite the integer on some balls so that there are at most K different integers written on the N balls.
\nFind the minimum number of balls that Takahashi needs to rewrite the integers on them.
\n\n\n \n
\nConstraints
- \n
- 1 \\leq K \\leq N \\leq 200000 \n
- 1 \\leq A_i \\leq N \n
- All input values are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN K\nA_1 A_2 ... A_N\n\n
\n\n \n
\nOutput
Print the minimum number of balls that Takahashi needs to rewrite the integers on them.
\n\n
\n\n \n
\nSample Input 1
5 2\n1 1 2 2 5\n\n
\n\n \n
\nSample Output 1
1\n\n
For example, if we rewrite the integer on the fifth ball to 2, there are two different integers written on the balls: 1 and 2.\nOn the other hand, it is not possible to rewrite the integers on zero balls so that there are at most two different integers written on the balls, so we should print 1.
\n\n
\n\n \n
\nSample Input 2
4 4\n1 1 2 2\n\n
\n\n \n
\nSample Output 2
0\n\n
Already in the beginning, there are two different integers written on the balls, so we do not need to rewrite anything.
\n\n
\n\n \n
\nSample Input 3
10 3\n5 1 3 2 4 1 1 2 3 4\n\n
\n\n \n
\n", "c_code": "int solution() {\n int N;\n int K;\n int i;\n int tmp;\n int count = 0;\n int ans = 0;\n\n scanf(\"%d %d\", &N, &K);\n\n int A[N + 1];\n int d[N + 1];\n for (i = 0; i <= N; i++) {\n A[i] = 0;\n d[i] = 0;\n }\n for (i = 0; i < N; i++) {\n scanf(\"%d\", &tmp);\n A[tmp]++;\n }\n\n for (i = 0; i <= N; i++) {\n d[A[i]]++;\n }\n\n for (i = N; i > 0; i--) {\n if (count >= K) {\n ans += i * d[i];\n } else if (count + d[i] > K) {\n ans += i * (count + d[i] - K);\n }\n count += d[i];\n }\n\n printf(\"%d\\n\", ans);\n\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = io::stdin();\n let mut stdin = stdin.lock();\n stdin.read_until(b' ', &mut Vec::new()).unwrap();\n let mut k = String::new();\n stdin.read_line(&mut k).unwrap();\n let k: usize = k.trim_end().parse().unwrap();\n\n let mut amt: VecSample Output 3
3\n
Score : 300 points
\n\n\n \n
\nProblem Statement
A company has N members, who are assigned ID numbers 1, ..., N.
\nEvery member, except the member numbered 1, has exactly one immediate boss with a smaller ID number.
\nWhen a person X is the immediate boss of a person Y, the person Y is said to be an immediate subordinate of the person X.
\nYou are given the information that the immediate boss of the member numbered i is the member numbered A_i. For each member, find how many immediate subordinates it has.
\n\n\n \n
\nConstraints
- \n
- 2 \\leq N \\leq 2 \\times 10^5 \n
- 1 \\leq A_i < i \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\nA_2 ... A_N\n\n
\n\n \n
\nOutput
For each of the members numbered 1, 2, ..., N, print the number of immediate subordinates it has, in its own line.
\n\n
\n\n \n
\nSample Input 1
5\n1 1 2 2\n\n
\n\n \n
\nSample Output 1
2\n2\n0\n0\n0\n\n
The member numbered 1 has two immediate subordinates: the members numbered 2 and 3.
\nThe member numbered 2 has two immediate subordinates: the members numbered 4 and 5.
\nThe members numbered 3, 4, and 5 do not have immediate subordinates.
\n\n
\n\n \n
\nSample Input 2
10\n1 1 1 1 1 1 1 1 1\n\n
\n\n \n
\nSample Output 2
9\n0\n0\n0\n0\n0\n0\n0\n0\n0\n\n
\n
\n\n \n
\nSample Input 3
7\n1 2 3 4 5 6\n\n
\n\n \n
\n", "c_code": "int solution() {\n int n = 0;\n int m = 0;\n scanf(\"%d\", &n);\n int t[200005] = {0};\n for (int i = 0; i < n - 1; i++) {\n scanf(\"%d\", &m);\n t[m - 1]++;\n }\n for (int i = 0; i < n; i++) {\n printf(\"%d\\n\", t[i]);\n }\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n\n std::io::stdin().read_to_string(&mut buf).unwrap();\n\n let mut iter = buf.split_whitespace();\n let n: usize = iter.next().unwrap().parse().unwrap();\n let a: VecSample Output 3
1\n1\n1\n1\n1\n1\n0\n
Score : 300 points
\n\n\n \n
\nProblem Statement
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is YES or NO.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
\nThen, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
\nNow, he goes through the following process:
\n- \n
- Submit the code. \n
- Wait until the code finishes execution on all the cases. \n
- If the code fails to correctly solve some of the M cases, submit it again. \n
- Repeat until the code correctly solve all the cases in one submission. \n
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
\n\n\n \n
\nConstraints
- \n
- All input values are integers. \n
- 1 \\leq N \\leq 100 \n
- 1 \\leq M \\leq {\\rm min}(N, 5) \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN M\n\n
\n\n \n
\nOutput
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
\n\n
\n\n \n
\nSample Input 1
1 1\n\n
\n\n \n
\nSample Output 1
3800\n\n
In this input, there is only one case. Takahashi will repeatedly submit the code that correctly solves this case with 1/2 probability in 1900 milliseconds.
\nThe code will succeed in one attempt with 1/2 probability, in two attempts with 1/4 probability, and in three attempts with 1/8 probability, and so on.
\nThus, the answer is 1900 \\times 1/2 + (2 \\times 1900) \\times 1/4 + (3 \\times 1900) \\times 1/8 + ... = 3800.
\n\n
\n\n \n
\nSample Input 2
10 2\n\n
\n\n \n
\nSample Output 2
18400\n\n
The code will take 1900 milliseconds in each of the 2 cases, and 100 milliseconds in each of the 10-2=8 cases. The probability of the code correctly solving all the cases is 1/2 \\times 1/2 = 1/4.
\n\n
\n\n \n
\nSample Input 3
100 5\n\n
\n\n \n
\n", "c_code": "int solution() {\n double N;\n double M;\n scanf(\"%lf %lf\", &N, &M);\n int i = 1;\n double exp = 0.0;\n while (i * ((N - M) * 100.0 + 1900.0 * M) * pow(1 - pow(0.50, M), i - 1) *\n pow(0.50, M) >\n 0.01) {\n exp += i * ((N - M) * 100.0 + 1900.0 * M) * pow(1 - pow(0.50, M), i - 1) *\n pow(0.50, M);\n i++;\n }\n\n printf(\"%.0f\", exp);\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).unwrap();\n let v: VecSample Output 3
608000\n
ゼッケンの交換 (Swapping Bibs)
\n\n\n問題
\n\nJOI 高校の N 人の生徒が東西に一列に並んでいる．列の西の端から i 番目の生徒が生徒 i である．それぞれの生徒は整数が 1 つ書かれたゼッケンを付けている．最初，生徒 i のゼッケンには整数 Ai が書かれている．\n
\n\n\nバトンが M 個あり，バトンには 1 から M までの番号が付けられている．k = 1, 2, ..., M に対し，以下の操作を行う．バトン k (2 ≦ k ≦ M) に関する操作は，バトン k - 1 に関する操作が終わってから行う．\n
\n\n- \n
- \n先生がバトン k を生徒 1 に渡す．\n \n
- \nバトンを受け取った生徒は，以下のルールに従ってバトンを渡す．\n\n
- \n
- \nルール：生徒 i がバトン k を受け取ったとする．\n
- \n
- 1 ≦ i ≦ N - 1 のとき: 生徒 i のゼッケンの整数を k で割った余りが，生徒 i + 1 のゼッケンの整数を k で割った余りよりも大きいとき，生徒 i と生徒 i + 1 がゼッケンを交換し，生徒 i は生徒 i + 1 にバトンを渡す．そうでないときは，ゼッケンを交換せずに，生徒 i は生徒 i + 1 にバトンを渡す． \n
- i = N のとき: 生徒 N はバトンを先生に渡す． \n
\n - \nルール：生徒 i がバトン k を受け取ったとする．\n
- 先生が生徒 N からバトン k を受け取ったら，バトン k に関する操作は終わりである．\n \n\n
\n生徒のゼッケンに最初に書かれていた整数とバトンの個数 M が与えられたとき，先生が生徒 N からバトン M を受け取った後の，それぞれの生徒のゼッケンの整数を求めるプログラムを作成せよ．\n
\n\n入力
\n\n入力は 1 + N 行からなる．\n
\n\n\n1 行目には整数 N, M (1 ≦ N ≦ 100, 1 ≦ M ≦ 100) が空白を区切りとして書かれており，それぞれ生徒の人数とバトンの個数を表す．\n
\n\n\n続く N 行のうちの i 行目 (1 ≦ i ≦ N) には整数 Ai (1 ≦ Ai ≦ 1000) が書かれており，生徒 i のゼッケンに最初に書かれている整数 Ai を表す．\n
\n\n出力
\n\n出力は N 行からなる．i 行目 (1 ≦ i ≦ N) には，先生が生徒 N からバトン M を受け取った後の，生徒 i のゼッケンの整数を出力せよ．\n
\n\n入出力例
\n\n\n入力例 1
\n\n\n6 4\n3\n2\n8\n3\n1\n5\n\n\n
出力例 1
\n\n\n2\n3\n1\n8\n5\n3\n\n\n
入力例 2
\n\n\n10 6\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n\n\n\n
出力例 2
\n\n\n6\n1\n2\n3\n10\n4\n8\n7\n9\n5\n\n\n\n
\n入出力例 1 では 6 人の生徒がいる．最初，生徒のゼッケンは順に 3， 2， 8， 3， 1， 5 である．バトンは 4 個ある．\n
\n- \n
- \nバトン 1 に関する操作が終了した時点での生徒のゼッケンは順に 3， 2， 8， 3， 1， 5 である．\n \n
- \nバトン 2 に関する操作が終了した時点での生徒のゼッケンは順に 2， 8， 3， 3， 1， 5 である．\n \n
- \nバトン 3 に関する操作が終了した時点での生徒のゼッケンは順に 2， 3， 3， 1， 8， 5 である．\n \n
- \nバトン 4 に関する操作が終了した時点での生徒のゼッケンは順に 2， 3， 1， 8， 5， 3 である．\n \n
\n
", "c_code": "int solution(void) {\n int n;\n int m;\n int bib[128] = {0};\n int swh;\n int i;\n int j;\n scanf(\"%d%d\", &n, &m);\n for (i = 1; i <= n; i++) {\n scanf(\"%d\", &bib[i]);\n }\n for (i = 1; i <= m; i++) {\n for (j = 1; j < n; j++) {\n if (bib[j] % i > bib[j + 1] % i) {\n swh = bib[j];\n bib[j] = bib[j + 1];\n bib[j + 1] = swh;\n }\n }\n }\n for (i = 1; i <= n; i++) {\n printf(\"%d\\n\", bib[i]);\n }\n return 0;\n}", "rust_code": "fn solution() {\n let input = {\n let mut buf = vec![];\n stdin().read_to_end(&mut buf);\n unsafe { String::from_utf8_unchecked(buf) }\n };\n let mut lines = input.split('\\n');\n\n let (n, m) = {\n let line = lines.next().unwrap();\n let mut iter = line.split(' ').map(|s| s.parse().unwrap());\n\n (iter.next().unwrap(), iter.next().unwrap())\n };\n\n let mut vec = Vec::with_capacity(n);\n vec.extend(lines.take(n).map(|l| l.parse::\n![\"クリエイティブ・コモンズ・ライセンス\"](\"https://i.creativecommons.org/l/by-sa/4.0/80x15.png\"/)
\n
\n情報オリンピック日本委員会作 『第 15 回日本情報オリンピック JOI 2015/2016 予選競技課題』\n\n
\nScore : 300 points
\n\n\n \n
\nProblem Statement
Joisino is planning to open a shop in a shopping street.
\nEach of the five weekdays is divided into two periods, the morning and the evening. For each of those ten periods, a shop must be either open during the whole period, or closed during the whole period. Naturally, a shop must be open during at least one of those periods.
\nThere are already N stores in the street, numbered 1 through N.
\nYou are given information of the business hours of those shops, F_{i,j,k}. If F_{i,j,k}=1, Shop i is open during Period k on Day j (this notation is explained below); if F_{i,j,k}=0, Shop i is closed during that period. Here, the days of the week are denoted as follows. Monday: Day 1, Tuesday: Day 2, Wednesday: Day 3, Thursday: Day 4, Friday: Day 5. Also, the morning is denoted as Period 1, and the afternoon is denoted as Period 2.
\nLet c_i be the number of periods during which both Shop i and Joisino's shop are open. Then, the profit of Joisino's shop will be P_{1,c_1}+P_{2,c_2}+...+P_{N,c_N}.
\nFind the maximum possible profit of Joisino's shop when she decides whether her shop is open during each period, making sure that it is open during at least one period.
\n\n\n \n
\nConstraints
- \n
- 1≤N≤100 \n
- 0≤F_{i,j,k}≤1 \n
- For every integer i such that 1≤i≤N, there exists at least one pair (j,k) such that F_{i,j,k}=1. \n
- -10^7≤P_{i,j}≤10^7 \n
- All input values are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\nF_{1,1,1} F_{1,1,2} ... F_{1,5,1} F_{1,5,2}\n:\nF_{N,1,1} F_{N,1,2} ... F_{N,5,1} F_{N,5,2}\nP_{1,0} ... P_{1,10}\n:\nP_{N,0} ... P_{N,10}\n\n\n\n \n
\nOutput
Print the maximum possible profit of Joisino's shop.
\n\n
\n\n \n
\nSample Input 1
1\n1 1 0 1 0 0 0 1 0 1\n3 4 5 6 7 8 9 -2 -3 4 -2\n\n
\n\n \n
\nSample Output 1
8\n\n
If her shop is open only during the periods when Shop 1 is opened, the profit will be 8, which is the maximum possible profit.
\n\n
\n\n \n
\nSample Input 2
2\n1 1 1 1 1 0 0 0 0 0\n0 0 0 0 0 1 1 1 1 1\n0 -2 -2 -2 -2 -2 -1 -1 -1 -1 -1\n0 -2 -2 -2 -2 -2 -1 -1 -1 -1 -1\n\n
\n\n \n
\nSample Output 2
-2\n\n
Note that a shop must be open during at least one period, and the profit may be negative.
\n\n
\n\n \n
\nSample Input 3
3\n1 1 1 1 1 1 0 0 1 1\n0 1 0 1 1 1 1 0 1 0\n1 0 1 1 0 1 0 1 0 1\n-8 6 -2 -8 -8 4 8 7 -6 2 2\n-9 2 0 1 7 -5 0 -2 -6 5 5\n6 -6 7 -9 6 -5 8 0 -9 -7 -7\n\n
\n\n \n
\n", "c_code": "int solution() {\n int N;\n scanf(\"%d\", &N);\n\n int F[100][14];\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < 10; j++) {\n scanf(\"%d\", &F[i][j]);\n }\n }\n\n int P[100][15];\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < 11; j++) {\n scanf(\"%d\", &P[i][j]);\n }\n }\n\n int res = -(1 << 30);\n for (int b = 1; b < (1 << 10); b++) {\n int cc = 0;\n for (int i = 0; i < N; i++) {\n int c = 0;\n for (int j = 0; j < 10; j++) {\n if ((b >> j & 1) && F[i][j]) {\n c++;\n }\n }\n\n cc += P[i][c];\n }\n if (res < cc) {\n res = cc;\n }\n }\n\n printf(\"%d\\n\", res);\n return 0;\n}", "rust_code": "fn solution() {\n input! {\n N: usize,\n F: [ [usize; 10]; N],\n P: [ [i64; 11]; N],\n }\n\n let mut max = std::i64::MIN;\n for ind in 1..(1 << 10) {\n let mut c = vec![0_usize; N];\n let mut res = ind;\n let mut count = 0;\n while res > 0 {\n let is = res & 1;\n for i in 0..N {\n c[i] += F[i][count] * is;\n }\n res >>= 1;\n count += 1;\n }\n let mut sum = 0;\n for (ind, cc) in c.iter().enumerate() {\n sum += P[ind][*cc];\n }\n max = cmp::max(max, sum);\n }\n println!(\"{}\", max);\n}", "difficulty": "medium"}
{"problem_id": "0031", "problem_description": "The time on the planet Lapituletti goes the same way it goes on Earth but a day lasts $$$h$$$ hours and each hour lasts $$$m$$$ minutes. The inhabitants of that planet use digital clocks similar to earth ones. Clocks display time in a format HH:MM (the number of hours in decimal is displayed first, then (after the colon) follows the number of minutes in decimal; the number of minutes and hours is written with leading zeros if needed to form a two-digit number). Hours are numbered from $$$0$$$ to $$$h-1$$$ and minutes are numbered from $$$0$$$ to $$$m-1$$$. That's how the digits are displayed on the clock. Please note that digit $$$1$$$ is placed in the middle of its position. A standard mirror is in use on the planet Lapituletti. Inhabitants often look at the reflection of the digital clocks in the mirror and feel happy when what you see on the reflected clocks is a valid time (that means that you see valid digits in the reflection and this time can be seen on the normal clocks at some moment of a day).The image of the clocks in the mirror is reflected against a vertical axis. The reflection is not a valid time.The reflection is a valid time with $$$h=24$$$, $$$m = 60$$$. However, for example, if $$$h=10$$$, $$$m=60$$$, then the reflection is not a valid time. An inhabitant of the planet Lapituletti begins to look at a mirrored image of the clocks at some time moment $$$s$$$ and wants to know the nearest future time moment (which can possibly happen on the next day), when the reflected clock time is valid.It can be shown that with any $$$h$$$, $$$m$$$, $$$s$$$ such a moment exists. If the reflected time is correct at the moment the inhabitant began to look at the clock, that moment is considered the nearest.You are asked to solve the problem for several test cases.", "c_code": "int solution() {\n int t;\n scanf(\"%d\", &t);\n for (int i = 1; i <= t; i++) {\n int h;\n int m;\n int flag = 0;\n char c;\n scanf(\"%d%d\", &h, &m);\n getchar();\n int arr[4];\n for (int j = 0; j < 4; j++) {\n if (j == 2) {\n getchar();\n }\n scanf(\"%c\", &c);\n arr[j] = c - '0';\n }\n while (1) {\n flag = 0;\n for (int j = 0; j < 4; j++) {\n if (arr[j] == 3 || arr[j] == 4 || arr[j] == 6 || arr[j] == 7 ||\n arr[j] == 9) {\n flag = 1;\n }\n if (flag == 0) {\n int a[4];\n for (int k = 0; k < 4; k++) {\n if (arr[k] == 2) {\n a[k] = 5;\n } else if (arr[k] == 5) {\n a[k] = 2;\n } else {\n a[k] = arr[k];\n }\n }\n if (a[3] * 10 + a[2] >= h || a[1] * 10 + a[0] >= m) {\n flag = 1;\n }\n }\n }\n if (flag == 1) {\n if (arr[3] + 1 < 10 && arr[2] * 10 + arr[3] + 1 < m) {\n arr[3]++;\n } else if (arr[2] * 10 + arr[3] + 1 < m) {\n arr[3] = 0;\n arr[2]++;\n } else if (arr[0] * 10 + arr[1] + 1 < h) {\n if (arr[1] + 1 < 10) {\n arr[1]++;\n arr[2] = arr[3] = 0;\n } else {\n arr[0]++;\n arr[1] = arr[2] = arr[3] = 0;\n }\n } else {\n arr[0] = arr[1] = arr[2] = arr[3] = 0;\n }\n } else {\n for (int j = 0; j < 4; j++) {\n if (j == 2) {\n printf(\":\");\n }\n printf(\"%d\", arr[j]);\n }\n printf(\"\\n\");\n break;\n }\n }\n }\n}", "rust_code": "fn solution() {\n let mut input = String::new();\n stdin().read_to_string(&mut input).unwrap();\n\n let mut it = input.split_whitespace();\n\n let _t = it.next().unwrap();\n\n let a = [\n Some(0),\n Some(1),\n Some(5),\n None,\n None,\n Some(2),\n None,\n None,\n Some(8),\n None,\n ];\n\n while let Some(h) = it.next().map(|x| x.parse::Sample Output 3
23\n
Score : 200 points
\n\n\n \n
\nProblem Statement
Find the sum of the integers between 1 and N (inclusive), whose sum of digits written in base 10 is between A and B (inclusive).
\n\n\n \n
\nConstraints
- \n
- 1 \\leq N \\leq 10^4 \n
- 1 \\leq A \\leq B \\leq 36 \n
- All input values are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN A B\n\n
\n\n \n
\nOutput
Print the sum of the integers between 1 and N (inclusive), whose sum of digits written in base 10 is between A and B (inclusive).
\n\n
\n\n \n
\nSample Input 1
20 2 5\n\n
\n\n \n
\nSample Output 1
84\n\n
Among the integers not greater than 20, the ones whose sums of digits are between 2 and 5, are: 2,3,4,5,11,12,13,14 and 20. We should print the sum of these, 84.
\n\n
\n\n \n
\nSample Input 2
10 1 2\n\n
\n\n \n
\nSample Output 2
13\n\n
\n
\n\n \n
\nSample Input 3
100 4 16\n\n
\n\n \n
\n", "c_code": "int solution() {\n int N = 0;\n int A = 0;\n int B = 0;\n int i = 0;\n int ans = 0;\n scanf(\"%d %d %d\", &N, &A, &B);\n for (i = 1; i <= N; i++) {\n int val = 0;\n val = (i / 10000) + ((i % 10000) / 1000) + ((i % 1000) / 100) +\n ((i % 100) / 10) + (i % 10);\n if ((A <= val) && (val <= B)) {\n\n ans += i;\n }\n }\n printf(\"%d\\n\", ans);\n return 0;\n}", "rust_code": "fn solution() {\n let scan = std::io::stdin();\n let mut line = String::new();\n let _ = scan.read_line(&mut line);\n let vec: Vec<&str> = line.split_whitespace().collect();\n\n let mut n: VecSample Output 3
4554\n
Score : 700 points
\n\n\n \n
\nProblem Statement
Takahashi is hosting an sports meet.\nThere are N people who will participate. These people are conveniently numbered 1 through N.\nAlso, there are M options of sports for this event. These sports are numbered 1 through M.\nAmong these options, Takahashi will select one or more sports (possibly all) to be played in the event.
\nTakahashi knows that Person i's j-th favorite sport is Sport A_{ij}.\nEach person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
\nTakahashi is worried that one of the sports will attract too many people.\nTherefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized.\nFind the minimum possible number of the participants in the sport with the largest number of participants.
\n\n\n \n
\nConstraints
- \n
- 1 \\leq N \\leq 300 \n
- 1 \\leq M \\leq 300 \n
- A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN M\nA_{11} A_{12} ... A_{1M}\nA_{21} A_{22} ... A_{2M}\n:\nA_{N1} A_{N2} ... A_{NM}\n\n\n\n \n
\nOutput
Print the minimum possible number of the participants in the sport with the largest number of participants.
\n\n
\n\n \n
\nSample Input 1
4 5\n5 1 3 4 2\n2 5 3 1 4\n2 3 1 4 5\n2 5 4 3 1\n\n
\n\n \n
\nSample Output 1
2\n\n
Assume that Sports 1, 3 and 4 are selected to be played. In this case, Person 1 will participate in Sport 1, Person 2 in Sport 3, Person 3 in Sport 3 and Person 4 in Sport 4.\nHere, the sport with the largest number of participants is Sport 3, with two participants.\nThere is no way to reduce the number of participants in the sport with the largest number of participants to 1. Therefore, the answer is 2.
\n\n
\n\n \n
\nSample Input 2
3 3\n2 1 3\n2 1 3\n2 1 3\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int N;\n int M;\n scanf(\"%d %d\", &N, &M);\n int A[N][M];\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < M; j++) {\n scanf(\"%d\", &A[i][j]);\n }\n }\n int kibousya[M];\n int nozoki[M];\n for (int i = 0; i < M; i++) {\n kibousya[i] = 0;\n nozoki[i] = 0;\n }\n int ans = 114514;\n for (int i = 0; i < M; i++) {\n for (int j = 0; j < N; j++) {\n for (int k = 0; k < M; k++) {\n if (nozoki[A[j][k] - 1] == 0) {\n kibousya[A[j][k] - 1]++;\n break;\n }\n }\n }\n int maxkibou = 0;\n for (int j = 0; j < M; j++) {\n if (nozoki[j] == 0 && kibousya[j] >= kibousya[maxkibou]) {\n maxkibou = j;\n }\n }\n if (ans > kibousya[maxkibou]) {\n ans = kibousya[maxkibou];\n }\n nozoki[maxkibou] = 1;\n for (int i = 0; i < M; i++) {\n kibousya[i] = 0;\n }\n }\n printf(\"%d\", ans);\n return 0;\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n std::io::stdin().read_to_string(&mut buf).unwrap();\n let mut buf_it = buf.split_whitespace();\n\n let N = buf_it.next().unwrap().parse::Sample Output 2
3\n\n
Since all the people have the same taste in sports, there will be a sport with three participants, no matter what sports are selected.\nTherefore, the answer is 3.
Score: 100 points
\n\n\n \n
\nProblem Statement
\nWe held two competitions: Coding Contest and Robot Maneuver.
\nIn each competition, the contestants taking the 3-rd, 2-nd, and 1-st places receive 100000, 200000, and 300000 yen (the currency of Japan), respectively. Furthermore, a contestant taking the first place in both competitions receives an additional 400000 yen.
\nDISCO-Kun took the X-th place in Coding Contest and the Y-th place in Robot Maneuver.\nFind the total amount of money he earned.
\n\n\n \n
\nConstraints
\n- \n
- 1 \\leq X \\leq 205 \n
- 1 \\leq Y \\leq 205 \n
- X and Y are integers. \n
\n
\n
\n\n\n \n
\nInput
\nInput is given from Standard Input in the following format:
\nX Y\n\n
\n\n \n
\nOutput
\nPrint the amount of money DISCO-Kun earned, as an integer.
\n\n
\n\n \n
\nSample Input 1
1 1\n\n
\n\n \n
\nSample Output 1
1000000\n\n
In this case, he earned 300000 yen in Coding Contest and another 300000 yen in Robot Maneuver. Furthermore, as he won both competitions, he got an additional 400000 yen.\nIn total, he made 300000 + 300000 + 400000 = 1000000 yen.
\n\n
\n\n \n
\nSample Input 2
3 101\n\n
\n\n \n
\nSample Output 2
100000\n\n
In this case, he earned 100000 yen in Coding Contest.
\n\n
\n\n \n
\nSample Input 3
4 4\n\n
\n\n \n
\n", "c_code": "int solution() {\n int x = 0;\n int y = 0;\n int money = 0;\n scanf(\"%d %d\", &x, &y);\n if (x == 3) {\n money += 100000;\n } else if (x == 2) {\n money += 200000;\n } else if (x == 1) {\n money += 300000;\n }\n if (y == 3) {\n money += 100000;\n } else if (y == 2) {\n money += 200000;\n } else if (y == 1) {\n money += 300000;\n }\n if (x == 1 && y == 1) {\n money += 400000;\n }\n printf(\"%d\", money);\n return 0;\n}", "rust_code": "fn solution() {\n let (X, Y): (usize, usize) = {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n iter.next().unwrap().parse().unwrap(),\n iter.next().unwrap().parse().unwrap(),\n )\n };\n\n let x = if X == 1 {\n 300000\n } else if X == 2 {\n 200000\n } else if X == 3 {\n 100000\n } else {\n 0\n };\n let y = if Y == 1 {\n 300000\n } else if Y == 2 {\n 200000\n } else if Y == 3 {\n 100000\n } else {\n 0\n };\n\n let ans = if X == 1 && Y == 1 {\n x + y + 400000\n } else {\n x + y\n };\n\n println!(\"{}\", ans);\n}", "difficulty": "easy"}
{"problem_id": "0043", "problem_description": "\nSample Output 3
0\n\n
In this case, unfortunately, he was the highest-ranked contestant without prize money in both competitions.
Score : 200 points
\n\n\n \n
\nProblem Statement
Given N integers A_1, ..., A_N, compute A_1 \\times ... \\times A_N.
\nHowever, if the result exceeds 10^{18}, print -1 instead.
\n\n \n
\nConstraints
- \n
- 2 \\leq N \\leq 10^5 \n
- 0 \\leq A_i \\leq 10^{18} \n
- All values in input are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\nA_1 ... A_N\n\n
\n\n \n
\nOutput
Print the value A_1 \\times ... \\times A_N as an integer, or -1 if the value exceeds 10^{18}.
\n
\n\n \n
\nSample Input 1
2\n1000000000 1000000000\n\n
\n\n \n
\nSample Output 1
1000000000000000000\n\n
We have 1000000000 \\times 1000000000 = 1000000000000000000.
\n\n
\n\n \n
\nSample Input 2
3\n101 9901 999999000001\n\n
\n\n \n
\nSample Output 2
-1\n\n
We have 101 \\times 9901 \\times 999999000001 = 1000000000000000001, which exceeds 10^{18}, so we should print -1 instead.
\n
\n\n \n
\nSample Input 3
31\n4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5 0\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int i = 0;\n int N = 0;\n scanf(\"%d\", &N);\n\n long long A[N];\n long long ans = 1;\n long long x = (pow(10, 18.0));\n\n if (2 <= N && N <= (pow(10, 5.0))) {\n for (i = 0; i < N; i++) {\n scanf(\"%lld\", &A[i]);\n }\n for (i = 0; i < N; i++) {\n if (A[i] == 0) {\n printf(\"0\");\n return 0;\n }\n }\n } else {\n return 0;\n }\n\n for (i = 0; i < N; i++) {\n if (A[i] <= x / ans) {\n\n ans = ans * A[i];\n\n } else {\n printf(\"-1\\n\");\n return 0;\n }\n }\n\n printf(\"%lld\\n\", ans);\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut is = String::new();\n stdin().read_line(&mut is).ok();\n is.clear();\n stdin().read_line(&mut is).ok();\n let itr = is.split_whitespace().map(|e| e.parse::Sample Output 3
0\n
Score : 400 points
\n\n\n \n
\nProblem Statement
You have N items and a bag of strength W.\nThe i-th item has a weight of w_i and a value of v_i.
\nYou will select some of the items and put them in the bag.\nHere, the total weight of the selected items needs to be at most W.
\nYour objective is to maximize the total value of the selected items.
\n\n\n \n
\nConstraints
- \n
- 1 ≤ N ≤ 100 \n
- 1 ≤ W ≤ 10^9 \n
- 1 ≤ w_i ≤ 10^9 \n
- For each i = 2,3,...,N, w_1 ≤ w_i ≤ w_1 + 3. \n
- 1 ≤ v_i ≤ 10^7 \n
- W, each w_i and v_i are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN W\nw_1 v_1\nw_2 v_2\n:\nw_N v_N\n\n
\n\n \n
\nOutput
Print the maximum possible total value of the selected items.
\n\n
\n\n \n
\nSample Input 1
4 6\n2 1\n3 4\n4 10\n3 4\n\n
\n\n \n
\nSample Output 1
11\n\n
The first and third items should be selected.
\n\n
\n\n \n
\nSample Input 2
4 6\n2 1\n3 7\n4 10\n3 6\n\n
\n\n \n
\nSample Output 2
13\n\n
The second and fourth items should be selected.
\n\n
\n\n \n
\nSample Input 3
4 10\n1 100\n1 100\n1 100\n1 100\n\n
\n\n \n
\nSample Output 3
400\n\n
You can take everything.
\n\n
\n\n \n
\nSample Input 4
4 1\n10 100\n10 100\n10 100\n10 100\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n\n int N;\n\n long long W;\n\n scanf(\"%d%lld\", &N, &W);\n\n long long dp[N + 1][N + 1][301];\n\n long long w[N];\n long long v[N];\n\n for (int i = 0; i < N; i++) {\n scanf(\"%lld%lld\", &w[i], &v[i]);\n }\n\n for (int i = 0; i <= N; i++) {\n for (int j = 0; j <= N; j++) {\n for (int k = 0; k <= 300; k++) {\n dp[i][j][k] = 0;\n }\n }\n }\n\n long long b = w[0];\n\n for (int i = 1; i <= N; i++) {\n long long t = w[i - 1] - b;\n for (int j = 1; j <= N; j++) {\n for (int k = 0; k <= 300; k++) {\n dp[i][j][k] = dp[i - 1][j][k];\n if (t <= k && dp[i][j][k] < dp[i - 1][j - 1][k - t] + v[i - 1]) {\n dp[i][j][k] = dp[i - 1][j - 1][k - t] + v[i - 1];\n }\n }\n }\n }\n\n long long ans = 0;\n\n for (int i = 1; i <= N; i++) {\n for (int j = 0; j <= 300; j++) {\n if (b * i + j <= W && ans < dp[N][i][j]) {\n ans = dp[N][i][j];\n }\n }\n }\n\n printf(\"%lld\\n\", ans);\n\n return 0;\n}", "rust_code": "fn solution() {\n input! {\n N: usize,\n W: u64,\n WV: [(u64,u64); N],\n }\n\n let mut V = vec![vec![0; 0]; 4];\n let mut w0 = 0;\n for i in 0..N {\n let (w, v) = WV[i];\n if i == 0 {\n V[0].push(v);\n w0 = w;\n } else {\n V[(w - w0) as usize].push(v);\n }\n }\n\n for i in 0..4 {\n V[i].sort();\n V[i].reverse();\n }\n\n let mut S = vec![vec![0; 1]; 4];\n for i in 0..4 {\n let mut tmp = 0;\n for v in V[i].iter() {\n tmp += *v;\n S[i].push(tmp);\n }\n }\n\n let mut ans = 0;\n for i0 in 0..S[0].len() {\n for i1 in 0..S[1].len() {\n for i2 in 0..S[2].len() {\n for i3 in 0..S[3].len() {\n if w0 * i0 as u64\n + (w0 + 1) * i1 as u64\n + (w0 + 2) * i2 as u64\n + (w0 + 3) * i3 as u64\n <= W\n {\n ans = max(ans, S[0][i0] + S[1][i1] + S[2][i2] + S[3][i3]);\n }\n }\n }\n }\n }\n println!(\"{}\", ans);\n}", "difficulty": "hard"}
{"problem_id": "0046", "problem_description": "There are $$$n$$$ block towers in a row, where tower $$$i$$$ has a height of $$$a_i$$$. You're part of a building crew, and you want to make the buildings look as nice as possible. In a single day, you can perform the following operation: Choose two indices $$$i$$$ and $$$j$$$ ($$$1 \\leq i, j \\leq n$$$; $$$i \\neq j$$$), and move a block from tower $$$i$$$ to tower $$$j$$$. This essentially decreases $$$a_i$$$ by $$$1$$$ and increases $$$a_j$$$ by $$$1$$$. You think the ugliness of the buildings is the height difference between the tallest and shortest buildings. Formally, the ugliness is defined as $$$\\max(a)-\\min(a)$$$. What's the minimum possible ugliness you can achieve, after any number of days?", "c_code": "int solution() {\n int n;\n int x = 0;\n scanf(\"%d\", &n);\n int arr_1[n];\n int result[n];\n for (int i = 0; i < n; i++) {\n scanf(\"%d\", &arr_1[i]);\n int arr_2[arr_1[i]];\n for (int j = 0; j < arr_1[i]; j++) {\n scanf(\"%d\", &arr_2[j]);\n x = x + arr_2[j];\n }\n if (x % arr_1[i] == 0) {\n result[i] = 0;\n } else {\n result[i] = 1;\n }\n x = 0;\n }\n for (int i = 0; i < n; i++) {\n printf(\"%d\\n\", result[i]);\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = stdin();\n let mut lines = stdin.lock().lines();\n let cases: u32 = lines.next().unwrap().unwrap().parse().unwrap();\n for _ in 0..cases {\n let buildings_count: u32 = lines.next().unwrap().unwrap().parse().unwrap();\n let buildings_line = lines.next().unwrap().unwrap();\n let buildings_line_split = buildings_line.split_ascii_whitespace();\n let mut block_sum: u32 = 0;\n for x in buildings_line_split {\n block_sum += x.parse::Sample Output 4
0\n\n
You can take nothing.
Score : 200 points
\n\n\n \n
\nProblem Statement
Takahashi and Aoki will have a battle using their monsters.
\nThe health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.
\nThe two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ...\nHere, an attack decreases the opponent's health by the value equal to the attacker's strength.\nThe monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.
\nIf Takahashi will win, print Yes; if he will lose, print No.
\n\n \n
\nConstraints
- \n
- 1 \\leq A,B,C,D \\leq 100 \n
- All values in input are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nA B C D\n\n
\n\n \n
\nOutput
If Takahashi will win, print Yes; if he will lose, print No.
\n
\n\n \n
\nSample Input 1
10 9 10 10\n\n
\n\n \n
\nSample Output 1
No\n\n
First, Takahashi's monster attacks Aoki's monster, whose health is now 10-9=1.
\nNext, Aoki's monster attacks Takahashi's monster, whose health is now 10-10=0.
\nTakahashi's monster is the first to have 0 or less health, so Takahashi loses.
\n\n
\n\n \n
\nSample Input 2
46 4 40 5\n\n
\n\n \n
\n", "c_code": "int solution() {\n int A = 0;\n int B = 0;\n int C = 0;\n int D = 0;\n scanf(\"%d %d %d %d\", &A, &B, &C, &D);\n while (1) {\n C = C - B;\n if (C <= 0) {\n printf(\"Yes\\n\");\n break;\n }\n A = A - D;\n if (A <= 0) {\n printf(\"No\\n\");\n break;\n }\n }\n return 0;\n}", "rust_code": "fn solution() {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).ok();\n let s: VecSample Output 2
Yes\n
Score : 300 points
\n\n\n \n
\nProblem Statement
There are N integers written on a blackboard. The i-th integer is A_i.
\nTakahashi will repeatedly perform the following operation on these numbers:
\n- \n
- Select a pair of integers, A_i and A_j, that have the same parity (that is, both are even or both are odd) and erase them. \n
- Then, write a new integer on the blackboard that is equal to the sum of those integers, A_i+A_j. \n
Determine whether it is possible to have only one integer on the blackboard.
\n\n\n \n
\nConstraints
- \n
- 2 ≦ N ≦ 10^5 \n
- 1 ≦ A_i ≦ 10^9 \n
- A_i is an integer. \n
\n
\n
\n\n\n \n
\nInput
The input is given from Standard Input in the following format:
\nN\nA_1 A_2 … A_N\n\n
\n\n \n
\nOutput
If it is possible to have only one integer on the blackboard, print YES. Otherwise, print NO.
\n
\n\n \n
\nSample Input 1
3\n1 2 3\n\n
\n\n \n
\nSample Output 1
YES\n\n
It is possible to have only one integer on the blackboard, as follows:
\n- \n
- Erase 1 and 3 from the blackboard, then write 4. Now, there are two integers on the blackboard: 2 and 4. \n
- Erase 2 and 4 from the blackboard, then write 6. Now, there is only one integer on the blackboard: 6. \n
\n
\n\n \n
\nSample Input 2
5\n1 2 3 4 5\n\n
\n\n \n
\n", "c_code": "int solution() {\n int N = 0;\n int count = 0;\n scanf(\"%d\", &N);\n int a[N];\n for (int i = 0; i < N; i++) {\n scanf(\"%d\", &a[i]);\n }\n for (int i = 0; i < N; i++) {\n count += a[i] % 2;\n }\n if (count % 2 == 0) {\n printf(\"YES\");\n } else {\n printf(\"NO\");\n }\n return 0;\n}", "rust_code": "fn solution() {\n let mut line = String::new();\n io::stdin()\n .read_line(&mut line)\n .expect(\"Failed to read line\");\n io::stdin()\n .read_line(&mut line)\n .expect(\"Failed to read line\");\n let mut vec: Vec<&str> = line.split_whitespace().collect();\n let n: u64 = vec.swap_remove(0).parse().expect(\"Failed to parse\");\n let mut odd_cnt = 0;\n let mut i = 0;\n for s in vec {\n let n2: u64 = s.parse().expect(\"Failed to parse\");\n if !n2.is_multiple_of(2) {\n odd_cnt += 1;\n }\n i += 1;\n if n <= i {\n break;\n }\n }\n println!(\"{}\", if odd_cnt % 2 == 0 { \"YES\" } else { \"NO\" });\n}", "difficulty": "medium"}
{"problem_id": "0049", "problem_description": "In a small restaurant there are a tables for one person and b tables for two persons. It it known that n groups of people come today, each consisting of one or two people. If a group consist of one person, it is seated at a vacant one-seater table. If there are none of them, it is seated at a vacant two-seater table. If there are none of them, it is seated at a two-seater table occupied by single person. If there are still none of them, the restaurant denies service to this group.If a group consist of two people, it is seated at a vacant two-seater table. If there are none of them, the restaurant denies service to this group.You are given a chronological order of groups coming. You are to determine the total number of people the restaurant denies service to.", "c_code": "int solution() {\n int i = 0;\n int a = 0;\n int b = 0;\n int n = 0;\n int c = 0;\n int count = 0;\n scanf(\"%d %d %d\", &n, &a, &b);\n int t[n];\n for (i = 0; i < n; i++) {\n scanf(\"%d\", &t[i]);\n if (t[i] == 1 && a != 0) {\n a--;\n } else if (t[i] == 2 && b != 0) {\n b--;\n } else if (t[i] == 1 && a == 0) {\n if (c != 0 && b == 0) {\n c--;\n } else if (b != 0) {\n b--;\n c++;\n } else {\n count++;\n }\n } else if (t[i] == 2 && b == 0) {\n count = count + t[i];\n }\n }\n\n printf(\"%d\\n\", count);\n return 0;\n}", "rust_code": "fn solution() {\n let (_, a, b) = {\n let mut input = String::new();\n stdin().read_line(&mut input).unwrap();\n let mut it = input\n .split_whitespace()\n .map(|k| k.parse::Sample Output 2
NO\n
Score : 200 points
\n\n\n \n
\nProblem Statement
There are N cities and M roads.\nThe i-th road (1≤i≤M) connects two cities a_i and b_i (1≤a_i,b_i≤N) bidirectionally.\nThere may be more than one road that connects the same pair of two cities.\nFor each city, how many roads are connected to the city?
\n\n\n \n
\nConstraints
- \n
- 2≤N,M≤50 \n
- 1≤a_i,b_i≤N \n
- a_i ≠ b_i \n
- All input values are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN M\na_1 b_1\n: \na_M b_M\n\n
\n\n \n
\nOutput
Print the answer in N lines.\nIn the i-th line (1≤i≤N), print the number of roads connected to city i.
\n\n
\n\n \n
\nSample Input 1
4 3\n1 2\n2 3\n1 4\n\n
\n\n \n
\nSample Output 1
2\n2\n1\n1\n\n
- \n
- City 1 is connected to the 1-st and 3-rd roads. \n
- City 2 is connected to the 1-st and 2-nd roads. \n
- City 3 is connected to the 2-nd road. \n
- City 4 is connected to the 3-rd road. \n
\n
\n\n \n
\nSample Input 2
2 5\n1 2\n2 1\n1 2\n2 1\n1 2\n\n
\n\n \n
\nSample Output 2
5\n5\n\n
\n
\n\n \n
\nSample Input 3
8 8\n1 2\n3 4\n1 5\n2 8\n3 7\n5 2\n4 1\n6 8\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int N;\n int M;\n scanf(\"%d\", &N);\n scanf(\"%d\", &M);\n int city[2 * M];\n int ans[N];\n\n for (int i = 0; i < N; i++) {\n ans[i] = 0;\n }\n\n for (int i = 0; i < 2 * M; i++) {\n scanf(\"%d\", &city[i]);\n }\n\n for (int i = 0; i < 2 * M; i++) {\n ans[city[i] - 1]++;\n }\n for (int i = 0; i < N; i++) {\n printf(\"%d\\n\", ans[i]);\n }\n return 0;\n}", "rust_code": "fn solution() {\n let (n, m) = {\n let mut b = String::new();\n std::io::stdin().read_line(&mut b).unwrap();\n let vec = b\n .split_whitespace()\n .map(|i| i.parse().unwrap())\n .collect::Sample Output 3
3\n3\n2\n2\n2\n1\n1\n2\n
Score : 300 points
\n\n\n \n
\nProblem Statement
1000000000000001 dogs suddenly appeared under the roof of Roger's house, all of which he decided to keep. The dogs had been numbered 1 through 1000000000000001, but he gave them new names, as follows:
\n- \n
- the dogs numbered 1,2,\\cdots,26 were respectively given the names
a,b, ...,z; \n - the dogs numbered 27,28,29,\\cdots,701,702 were respectively given the names
aa,ab,ac, ...,zy,zz; \n - the dogs numbered 703,704,705,\\cdots,18277,18278 were respectively given the names
aaa,aab,aac, ...,zzy,zzz; \n - the dogs numbered 18279,18280,18281,\\cdots,475253,475254 were respectively given the names
aaaa,aaab,aaac, ...,zzzy,zzzz; \n - the dogs numbered 475255,475256,\\cdots were respectively given the names
aaaaa,aaaab, ...; \n - and so on. \n
To sum it up, the dogs numbered 1, 2, \\cdots were respectively given the following names:
\na, b, ..., z, aa, ab, ..., az, ba, bb, ..., bz, ..., za, zb, ..., zz, aaa, aab, ..., aaz, aba, abb, ..., abz, ..., zzz, aaaa, ...
Now, Roger asks you:
\n\"What is the name for the dog numbered N?\"
\n\n\n \n
\nConstraints
- \n
- N is an integer. \n
- 1 \\leq N \\leq 1000000000000001 \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\n\n
\n\n \n
\nOutput
Print the answer to Roger's question as a string consisting of lowercase English letters.
\n\n
\n\n \n
\nSample Input 1
2\n\n
\n\n \n
\nSample Output 1
b\n\n
\n
\n\n \n
\nSample Input 2
27\n\n
\n\n \n
\nSample Output 2
aa\n\n
\n
\n\n \n
\nSample Input 3
123456789\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n long int dogn = 0;\n char name[16] = {0};\n int i = 0;\n\n scanf(\"%ld\", &dogn);\n dogn--;\n\n while (dogn > -1) {\n name[i] = dogn % 26 + 'a';\n dogn = dogn / 26;\n i++;\n dogn--;\n }\n\n while (i--) {\n printf(\"%c\", name[i]);\n }\n printf(\"\\n\");\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut is = String::new();\n stdin().read_line(&mut is).ok();\n let mut n: usize = is.trim().parse::Sample Output 3
jjddja\n
Search I
\n\n\nYou are given a sequence of n integers S and a sequence of different q integers T. Write a program which outputs C, the number of integers in T which are also in the set S.\n
\n\nInput
\n\n\nIn the first line n is given. In the second line, n integers are given. In the third line q is given. Then, in the fourth line, q integers are given.\n
\n\n\nOutput
\n\n\nPrint C in a line.\n
\n\nConstraints
\n\n\n- \n
- n ≤ 10000 \n
- q ≤ 500 \n
- 0 ≤ an element in S ≤ 109 \n
- 0 ≤ an element in T ≤ 109 \n
Sample Input 1
\n\n5\n1 2 3 4 5\n3\n3 4 1\n\n\n
Sample Output 1
\n\n3\n\n\n
Sample Input 2
\n\n3\n3 1 2\n1\n5\n\n
Sample Output 2
\n\n0\n\n\n
Sample Input 3
\n\n5\n1 1 2 2 3\n2\n1 2\n\n
Sample Output 3
\n\n2\n\n\n\n
Notes
\n", "c_code": "int solution(void) {\n int n = 0;\n int m = 0;\n int i = 0;\n int j = 0;\n int count = 0;\n scanf(\"%d\", &n);\n int a[n];\n for (i = 0; i < n; i++) {\n scanf(\"%d\", &a[i]);\n }\n\n scanf(\"%d\", &m);\n int b[m];\n for (i = 0; i < m; i++) {\n scanf(\"%d\", &b[i]);\n for (j = 0; j < n; j++) {\n if (a[j] == b[i]) {\n count++;\n break;\n }\n }\n }\n printf(\"%d\\n\", count);\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n std::io::stdin().read_to_string(&mut buf).unwrap();\n let mut buf_it = buf.split_whitespace();\n\n let N = buf_it.next().unwrap().parse::Score : 500 points
\n\n\n
", "c_code": "int solution() {\n int n;\n scanf(\"%d\", &n);\n long a[n];\n long sum = 0;\n long xor = 0;\n long ans = 0;\n int k = 0;\n int cnt = 0;\n for (int i = 0; i < n; i++) {\n scanf(\"%ld\", a + i);\n }\n for (int i = 0; i < n; i++) {\n while (k < n && (sum + a[k] == (xor^a[k]))) {\n sum += a[k];\n xor += a[k];\n k++;\n cnt++;\n }\n ans += cnt;\n cnt--;\n sum -= a[i];\n xor -= a[i];\n }\n printf(\"%ld\\n\", ans);\n return 0;\n}", "rust_code": "fn solution() {\n let mut s: String = String::new();\n std::io::stdin().read_to_string(&mut s).ok();\n let mut itr = s.split_whitespace();\n let n: usize = itr.next().unwrap().parse().unwrap();\n let a: VecProblem Statement
There is an integer sequence A of length N.
\nFind the number of the pairs of integers l and r (1 \\leq l \\leq r \\leq N) that satisfy the following condition:
\n- \n
- A_l\\ xor\\ A_{l+1}\\ xor\\ ...\\ xor\\ A_r = A_l\\ +\\ A_{l+1}\\ +\\ ...\\ +\\ A_r \n
Here, xor denotes the bitwise exclusive OR.
\n\nDefinition of XOR
The XOR of integers c_1, c_2, ..., c_m is defined as follows:
\n- \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. \n
For 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.
\nScore : 200 points
\n\n\n \n
\nProblem Statement
We ask you to select some number of positive integers, and calculate the sum of them.
\nIt is allowed to select as many integers as you like, and as large integers as you wish.\nYou have to follow these, however: each selected integer needs to be a multiple of A, and you need to select at least one integer.
\nYour objective is to make the sum congruent to C modulo B.\nDetermine whether this is possible.
\nIf the objective is achievable, print YES. Otherwise, print NO.
\n\n \n
\nConstraints
- \n
- 1 ≤ A ≤ 100 \n
- 1 ≤ B ≤ 100 \n
- 0 ≤ C < B \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nA B C\n\n
\n\n \n
\nOutput
Print YES or NO.
\n
\n\n \n
\nSample Input 1
7 5 1\n\n
\n\n \n
\nSample Output 1
YES\n\n
For example, if you select 7 and 14, the sum 21 is congruent to 1 modulo 5.
\n\n
\n\n \n
\nSample Input 2
2 2 1\n\n
\n\n \n
\nSample Output 2
NO\n\n
The sum of even numbers, no matter how many, is never odd.
\n\n
\n\n \n
\nSample Input 3
1 100 97\n\n
\n\n \n
\nSample Output 3
YES\n\n
You can select 97, since you may select multiples of 1, that is, all integers.
\n\n
\n\n \n
\nSample Input 4
40 98 58\n\n
\n\n \n
\nSample Output 4
YES\n\n
\n
\n\n \n
\nSample Input 5
77 42 36\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int a = 0;\n int b = 0;\n int c = 0;\n int x = 0;\n int i;\n\n scanf(\"%d\", &a);\n scanf(\"%d\", &b);\n scanf(\"%d\", &c);\n\n for (i = 1; i <= b; i++) {\n\n if (c == ((a * i) % b)) {\n printf(\"YES\");\n x = a % b;\n break;\n }\n }\n if (x == 0) {\n printf(\"NO\");\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n use std::io;\n let mut input = String::new();\n let _ = io::stdin().read_line(&mut input);\n let input_nums = input\n .split_whitespace()\n .map(|x| x.parse::Sample Output 5
NO\n
Prime Number
\n\n\nWrite a program which reads an integer n and prints the number of prime numbers which are less than or equal to n. A prime number is a natural number which has exactly two distinct natural number divisors: 1 and itself. For example, the first four prime numbers are: 2, 3, 5 and 7.\n
\n\nInput
\n\n\nInput consists of several datasets. Each dataset has an integer n (1 ≤ n ≤ 999,999) in a line.\n
\n\n\nThe number of datasets is less than or equal to 30.\n
\n\nOutput
\n\n\nFor each dataset, prints the number of prime numbers.\n
\n\nSample Input
\n\n\n10\n3\n11\n\n\n
Output for the Sample Input
\n\n\n4\n2\n5\n", "c_code": "int solution() {\n while (1) {\n int n;\n int i;\n int cnt = 0;\n int sw = 1;\n int sosuu[100000];\n int t;\n if (scanf(\"%d\", &n) == EOF) {\n break;\n }\n if (n <= 1) {\n cnt = 0;\n } else {\n sosuu[cnt] = 2;\n cnt++;\n for (i = 3; i <= n; i += 2) {\n sw = 1;\n for (t = 0; t < cnt && sosuu[t] * sosuu[t] <= i; t++) {\n if (i % sosuu[t] == 0) {\n sw = 0;\n break;\n }\n }\n if (sw == 1) {\n sosuu[cnt] = i;\n cnt++;\n }\n }\n }\n printf(\"%d\\n\", cnt);\n }\n return 0;\n}", "rust_code": "fn solution() {\n loop {\n let mut s = String::new();\n stdin().read_line(&mut s).unwrap();\n let end: i32 = match s.trim().parse() {\n Ok(end) => end,\n Err(_) => return,\n };\n if end < 2 {\n println!(\"{}\", 0);\n continue;\n }\n\n let mut flags = vec![true; ((end + 1) / 2) as usize];\n let flags_len = flags.len();\n flags[0] = false;\n for i in 1..flags_len {\n if !flags[i] {\n continue;\n }\n let n = i * 2 + 1;\n let mut j = 3;\n let mut comp_index = (n * j - 1) / 2;\n while comp_index < flags_len {\n flags[comp_index] = false;\n j += 2;\n comp_index = (n * j - 1) / 2;\n }\n }\n\n println!(\"{}\", flags.iter().filter(|x| **x).count() + 1);\n }\n}", "difficulty": "medium"} {"problem_id": "0061", "problem_description": "
博士が愛した２進数
\n\n\n 「君の靴のサイズはいくつかね」
\n
\n 初対面の私に、いきなり博士は尋ねました。
\n
\n 「 23.5 です」
\n\n 「ほお、実にきりのいい数字だ。2 の 4 乗に 2 の 2 乗と 2 の 1 乗と 2 の 0 乗と 2 の -1 乗を 加えた数だ」
\n
\n 続けて博士は尋ねました。
\n
\n 「君、身長はいくつかね」
\n\n 「はい、158.1 です」
\n
\n 博士は腕組みをして目を閉じました。しばらくの沈黙の後、口を開きました。
\n
\n 「ナァ~」
\n
\n その後一緒に過ごした時間の中で、博士の行動がだんだん理解できるようになりました。\n
\n まず、 私が博士の求めに応じて実数を言います。実数が整数部 8 桁以内で小数部 4 桁以内の 2 進数で表される場合、博士は 2 進数への変換結果を満足げに語ります。そうでない場合、悲しげに「ナァ~」 と鳴きます。これは、私が負の実数を言うまで繰り返されるのです。\n
\n\n\n さて、博士は年齢とともにだんだんに長い計算が難しくなってきました。そこで、みなさんが博士に代わって、実数を入力し 2 進数に変換・出力するプログラムを作ってあげてください。ただし、2 進表現が制限桁数 (整数部 8 桁以内 + 小数部 4 桁以内) に収まらない場合は、NA (半角英字) を出力してください。入力される実数は整数部 8 桁以内、小数部 4 桁以内に収まるものとし、出力する 2 進表現は整数部 8 桁、小数部 4 桁で出力してください。\n
\n\nInput
\n\n\n複数のデータセットの並びが入力として与えられます。入力の終わりは負の実数ひとつの行で示されます。\n各データセットとして１つの実数 n が１行に与えられます。\n
\n\n\nデータセットの数は 1200 を超えません。\n
\n\n\nOutput
\n\n\n入力データセットごとに 2 進数への変換結果を出力します。\n
\n\nSample Input
\n\n\n23.5\n158.1\n-1.0\n\n\n
Output for the Sample Input
\n\n\n00010111.1000\nNA\n", "c_code": "int solution() {\n double n;\n\n while (1) {\n scanf(\"%lf\", &n);\n\n if (n < 0) {\n return 0;\n }\n\n n *= 2 * 2 * 2 * 2;\n\n int m = (int)n;\n\n if (n - (double)m == 0 && (m >> 12) == 0) {\n int i = 0;\n for (; i < 12; ++i) {\n if (i == 8) {\n printf(\".\");\n }\n\n printf(\"%d\", (m >> (12 - i - 1) & 1));\n }\n\n puts(\"\");\n }\n\n else {\n puts(\"NA\");\n }\n }\n}", "rust_code": "fn solution() {\n let stdin = stdin();\n let lines = stdin.lock().lines();\n\n for line in lines {\n let n: f64 = line.unwrap().parse().unwrap();\n if n < 0. {\n return;\n }\n\n let nf = n * 16.;\n let ni = nf as u64;\n\n if ni > 0xfff || nf.fract() != 0. {\n println!(\"NA\");\n } else {\n println!(\"{:08b}.{:04b}\", ni >> 4, ni & 0b1111);\n }\n }\n}", "difficulty": "medium"} {"problem_id": "0062", "problem_description": "\n
Score : 200 points
\n\n\n \n
\nProblem Statement
\nThere are N people numbered 1 to N. Each person wears a red hat or a blue hat.
\nYou are given a string s representing the colors of the people. Person i wears a red hat if s_i is R, and a blue hat if s_i is B.
Determine if there are more people wearing a red hat than people wearing a blue hat.
\n\n\n \n
\nConstraints
- \n
- 1 \\leq N \\leq 100 \n
- |s| = N \n
- s_i is
RorB. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\ns\n\n
\n\n \n
\nOutput
If there are more people wearing a red hat than there are people wearing a blue hat, print Yes; otherwise, print No.
\n
\n\n \n
\nSample Input 1
4\nRRBR\n\n
\n\n \n
\nSample Output 1
Yes\n\n
- \n
- There are three people wearing a red hat, and one person wearing a blue hat. \n
- Since there are more people wearing a red hat than people wearing a blue hat, the answer is
Yes. \n
\n
\n\n \n
\nSample Input 2
4\nBRBR\n\n
\n\n \n
\n", "c_code": "int solution() {\n int n = 0;\n scanf(\"%d\", &n);\n char s[100];\n scanf(\"%s\", s);\n int i = 0;\n int countR = 0;\n while (i < n) {\n if (s[i] == 'R') {\n countR++;\n }\n i++;\n }\n if (countR > n - countR) {\n printf(\"Yes\");\n } else {\n printf(\"No\");\n }\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.clear();\n io::stdin().read_line(&mut buf).unwrap();\n\n let (r, b) = buf.chars().fold((0, 0), |(mut r, mut b), c| {\n match c {\n 'R' => r += 1,\n 'B' => b += 1,\n _ => (),\n }\n\n (r, b)\n });\n\n if r > b {\n println!(\"Yes\");\n } else {\n println!(\"No\");\n }\n}", "difficulty": "medium"}
{"problem_id": "0063", "problem_description": "\nSample Output 2
No\n\n
- \n
- There are two people wearing a red hat, and two people wearing a blue hat. \n
- Since there are as many people wearing a red hat as people wearing a blue hat, the answer is
No. \n
Day of Week
\n\n\n\n The 9th day of September 2017 is Saturday. Then, what day of the week is the X-th of September 2017? \n
\n\n\n Given a day in September 2017, write a program to report what day of the week it is.\n
\n\n\nInput
\n\n\n The input is given in the following format.\n
\n\n\nX\n\n
\n The input line specifies a day X (1 ≤ X ≤ 30) in September 2017.\n
\n\n\nOutput
\n\n\nOutput what day of the week it is in a line. Use the following conventions in your output: \"mon\" for Monday, \"tue\" for Tuesday, \"wed\" for Wednesday, \"thu\" for Thursday, \"fri\" for Friday, \"sat\" for Saturday, and \"sun\" for Sunday.\n
\n\nSample Input 1
\n\n\n1\n\n\n
Sample Output 1
\n\nfri\n\n\n
Sample Input 2
\n\n9\n\n\n
Sample Output 2
\n\nsat\n\n\n
Sample Input 3
\n\n30\n\n\n
Sample Output 3
\n\nsat\n", "c_code": "int solution(void) {\n char data[7][4] = {\"thu\", \"fri\", \"sat\", \"sun\", \"mon\", \"tue\", \"wed\"};\n int X = 0;\n scanf(\"%d\", &X);\n printf(\"%s\\n\", data[X % 7]);\n return 0;\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n std::io::stdin().read_to_string(&mut buf).unwrap();\n let mut iter = buf.split_whitespace();\n\n let a: usize = iter.next().unwrap().parse().unwrap();\n\n let days = [\"mon\", \"tue\", \"wed\", \"thu\", \"fri\", \"sat\", \"sun\"];\n\n let x = (a % 7 + 3) % 7;\n println!(\"{}\", days[x]);\n}", "difficulty": "easy"} {"problem_id": "0064", "problem_description": "\n
Score : 200 points
\n\n\n \n
\nProblem Statement
We will call a string that can be obtained by concatenating two equal strings an even string.\nFor example, xyzxyz and aaaaaa are even, while ababab and xyzxy are not.
You are given an even string S consisting of lowercase English letters.\nFind the length of the longest even string that can be obtained by deleting one or more characters from the end of S.\nIt is guaranteed that such a non-empty string exists for a given input.
\n\n\n \n
\nConstraints
- \n
- 2 \\leq |S| \\leq 200 \n
- S is an even string consisting of lowercase English letters. \n
- There exists a non-empty even string that can be obtained by deleting one or more characters from the end of S. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nS\n\n
\n\n \n
\nOutput
Print the length of the longest even string that can be obtained.
\n\n
\n\n \n
\nSample Input 1
abaababaab\n\n
\n\n \n
\nSample Output 1
6\n\n
- \n
abaababaabitself is even, but we need to delete at least one character. \nabaababaais not even. \nabaababais not even. \nabaababis not even. \nabaabais even. Thus, we should print its length, 6. \n
\n
\n\n \n
\nSample Input 2
xxxx\n\n
\n\n \n
\nSample Output 2
2\n\n
- \n
xxxis not even. \nxxis even. \n
\n
\n\n \n
\nSample Input 3
abcabcabcabc\n\n
\n\n \n
\nSample Output 3
6\n\n
The longest even string that can be obtained is abcabc, whose length is 6.
\n
\n\n \n
\nSample Input 4
akasakaakasakasakaakas\n\n
\n\n \n
\n", "c_code": "int solution() {\n char str[200] = {0};\n int len = 0;\n\n scanf(\"%s\", str);\n len = strlen(str);\n\n while (1) {\n char tmp1[100] = {0};\n char tmp2[100] = {0};\n\n if ((strlen(str) % 2) != 0) {\n len -= 1;\n } else {\n len -= 2;\n }\n\n strncpy(tmp1, &str[0], len / 2);\n strncpy(tmp2, &str[len / 2], len / 2);\n\n if (strcmp(tmp1, tmp2) == 0) {\n break;\n }\n }\n\n printf(\"%d\\n\", len);\n\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = io::stdin();\n let mut buf = String::new();\n stdin.read_line(&mut buf).ok();\n\n let mut it = buf.split_whitespace().map(|n| String::from_str(n).unwrap());\n let mut s = it.next().unwrap();\n\n while !s.is_empty() {\n s = s[0..s.len() - 2].to_string();\n if s.len() % 2 == 1 {\n continue;\n }\n if s[0..s.len() / 2 - 1] == s[s.len() / 2..s.len() - 1] {\n println!(\"{}\", s.len());\n return;\n }\n }\n}", "difficulty": "medium"}
{"problem_id": "0065", "problem_description": "\nSample Output 4
14\n\n
The longest even string that can be obtained is akasakaakasaka, whose length is 14.
Score : 300 points
\n\n\n \n
\nProblem Statement
There are N stones arranged in a row. Every stone is painted white or black.\nA string S represents the color of the stones. The i-th stone from the left is white if the i-th character of S is ., and the stone is black if the character is #.
Takahashi wants to change the colors of some stones to black or white so that there will be no white stone immediately to the right of a black stone.\nFind the minimum number of stones that needs to be recolored.
\n\n\n \n
\nConstraints
- \n
- 1 \\leq N \\leq 2\\times 10^5 \n
- S is a string of length N consisting of
.and#. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\nS\n\n
\n\n \n
\nOutput
Print the minimum number of stones that needs to be recolored.
\n\n
\n\n \n
\nSample Input 1
3\n#.#\n\n
\n\n \n
\nSample Output 1
1\n\n
It is enough to change the color of the first stone to white.
\n\n
\n\n \n
\nSample Input 2
5\n#.##.\n\n
\n\n \n
\nSample Output 2
2\n\n
\n
\n\n \n
\nSample Input 3
9\n.........\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int n;\n int i;\n char s[200002];\n int a[200001];\n scanf(\"%d%s\", &n, s + 1);\n\n a[0] = 0;\n for (i = 1; i <= n; i++) {\n a[i] = a[i - 1] + (s[i] == '#');\n }\n int min = INT_MAX;\n for (i = 0; i <= n; i++) {\n int now = a[i] + (n - i - a[n] + a[i]);\n if (now < min) {\n min = now;\n }\n }\n printf(\"%d\\n\", min);\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n let mut iter = buf.split_whitespace();\n let n: usize = iter.next().unwrap().parse().unwrap();\n\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n let s = buf.trim();\n\n let mut nr_wb = Vec::<(usize, usize)>::with_capacity(n);\n\n for c in s.chars() {\n let (w, b) = *nr_wb.last().unwrap_or(&(0usize, 0usize));\n if c == '.' {\n nr_wb.push((w + 1, b));\n } else {\n nr_wb.push((w, b + 1));\n }\n }\n\n let mut ans_wb: usize = n;\n let (all_w, _) = *nr_wb.last().unwrap();\n for i in 0..(n - 1) {\n let (cur_w, cur_b) = nr_wb[i];\n let rem_w = all_w - cur_w;\n ans_wb = std::cmp::min(ans_wb, cur_b + rem_w);\n }\n\n let ans_w: usize = nr_wb.last().unwrap().1;\n let ans_b: usize = nr_wb.last().unwrap().0;\n\n println!(\"{}\", std::cmp::min(std::cmp::min(ans_w, ans_b), ans_wb));\n}", "difficulty": "hard"}
{"problem_id": "0066", "problem_description": "Polycarp found under the Christmas tree an array $$$a$$$ of $$$n$$$ elements and instructions for playing with it: At first, choose index $$$i$$$ ($$$1 \\leq i \\leq n$$$) — starting position in the array. Put the chip at the index $$$i$$$ (on the value $$$a_i$$$). While $$$i \\leq n$$$, add $$$a_i$$$ to your score and move the chip $$$a_i$$$ positions to the right (i.e. replace $$$i$$$ with $$$i + a_i$$$). If $$$i > n$$$, then Polycarp ends the game. For example, if $$$n = 5$$$ and $$$a = [7, 3, 1, 2, 3]$$$, then the following game options are possible: Polycarp chooses $$$i = 1$$$. Game process: $$$i = 1 \\overset{+7}{\\longrightarrow} 8$$$. The score of the game is: $$$a_1 = 7$$$. Polycarp chooses $$$i = 2$$$. Game process: $$$i = 2 \\overset{+3}{\\longrightarrow} 5 \\overset{+3}{\\longrightarrow} 8$$$. The score of the game is: $$$a_2 + a_5 = 6$$$. Polycarp chooses $$$i = 3$$$. Game process: $$$i = 3 \\overset{+1}{\\longrightarrow} 4 \\overset{+2}{\\longrightarrow} 6$$$. The score of the game is: $$$a_3 + a_4 = 3$$$. Polycarp chooses $$$i = 4$$$. Game process: $$$i = 4 \\overset{+2}{\\longrightarrow} 6$$$. The score of the game is: $$$a_4 = 2$$$. Polycarp chooses $$$i = 5$$$. Game process: $$$i = 5 \\overset{+3}{\\longrightarrow} 8$$$. The score of the game is: $$$a_5 = 3$$$. Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.", "c_code": "int solution(void) {\n\n int *arr = malloc(200000 * sizeof(int));\n int *a = arr;\n\n int t;\n scanf(\"%d\", &t);\n\n while (t--) {\n int n;\n scanf(\"%d\", &n);\n\n for (int i = 0; i < n; i++) {\n scanf(\"%d\", &a[i]);\n }\n\n unsigned long long maximum_score = 0;\n\n for (int i = 0; i < n; i++) {\n int j = i;\n unsigned long long current_score = 0;\n\n while ((j < n) && (a[j])) {\n current_score += a[j];\n\n int temp = a[j];\n a[j] = 0;\n j += temp;\n }\n\n if (current_score > maximum_score) {\n maximum_score = current_score;\n }\n }\n\n printf(\"%llu\\n\", maximum_score);\n\n a += n;\n }\n\n free(arr);\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut t = String::new();\n stdin().read_line(&mut t).unwrap();\n let t: i32 = t.trim().parse().unwrap();\n\n let out = &mut BufWriter::new(stdout());\n\n for _i in 0..t {\n let mut n = String::new();\n stdin().read_line(&mut n).unwrap();\n let n: usize = n.trim().parse().unwrap();\n\n let mut a = String::new();\n stdin().read_line(&mut a).unwrap();\n let mut a: VecSample Output 3
0\n
Score : 200 points
\n\n\n \n
\nProblem Statement
Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each string is L.
\nShe will concatenate all of the strings in some order, to produce a long string.
\nAmong all strings that she can produce in this way, find the lexicographically smallest one.
\nHere, a string s=s_1s_2s_3...s_n is lexicographically smaller than another string t=t_1t_2t_3...t_m if and only if one of the following holds:\n
- \n
- There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i. \n
- s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m. \n
\n\n \n
\nConstraints
- \n
- 1 ≦ N, L ≦ 100 \n
- For each i, the length of S_i equals L. \n
- For each i, S_i consists of lowercase letters. \n
\n
\n
\n\n\n \n
\nInput
The input is given from Standard Input in the following format:
\nN L\nS_1\nS_2\n:\nS_N\n\n
\n\n \n
\nOutput
Print the lexicographically smallest string that Iroha can produce.
\n\n
\n\n \n
\nSample Input 1
3 3\ndxx\naxx\ncxx\n\n
\n\n \n
\n", "c_code": "int solution() {\n int n;\n int l;\n scanf(\"%d%d\", &n, &l);\n char str[n][l + 1];\n char a[(l * n) + 1];\n int ids[n];\n for (int i = 0; i < n; i++) {\n scanf(\"%s\", &str[i][0]);\n ids[i] = i;\n }\n for (int i = n - 1; i > 0; i--) {\n for (int j = 0; j < i; j++) {\n if (strcmp(&str[ids[j]][0], &str[ids[j + 1]][0]) > 0) {\n int buf = ids[j];\n ids[j] = ids[j + 1];\n ids[j + 1] = buf;\n }\n }\n }\n for (int i = 0; i < n; i++) {\n printf(\"%s\", &str[ids[i]][0]);\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n std::io::stdin().read_to_string(&mut buf).unwrap();\n\n let mut iter = buf.split_whitespace();\n\n iter.next();\n iter.next();\n let mut strings: Vec<&str> = iter.collect();\n\n strings.sort();\n println!(\"{}\", strings.concat());\n}", "difficulty": "hard"}
{"problem_id": "0069", "problem_description": "\nSample Output 1
axxcxxdxx\n\n
The following order should be used: axx, cxx, dxx.
Score : 200 points
\n\n\n \n
\nProblem Statement
There is a grid of squares with H horizontal rows and W vertical columns.\nThe square at the i-th row from the top and the j-th column from the left is represented as (i, j).\nEach square is black or white.\nThe color of the square is given as an H-by-W matrix (a_{i, j}).\nIf a_{i, j} is ., the square (i, j) is white; if a_{i, j} is #, the square (i, j) is black.
Snuke is compressing this grid.\nHe will do so by repeatedly performing the following operation while there is a row or column that consists only of white squares:
\n- \n
- Operation: choose any one row or column that consists only of white squares, remove it and delete the space between the rows or columns. \n
It can be shown that the final state of the grid is uniquely determined regardless of what row or column is chosen in each operation.\nFind the final state of the grid.
\n\n\n \n
\nConstraints
- \n
- 1 \\leq H, W \\leq 100 \n
- a_{i, j} is
.or#. \n - There is at least one black square in the whole grid. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nH W\na_{1, 1}...a_{1, W}\n:\na_{H, 1}...a_{H, W}\n\n\n\n \n
\nOutput
Print the final state of the grid in the same format as input (without the numbers of rows and columns); see the samples for clarity.
\n\n
\n\n \n
\nSample Input 1
4 4\n##.#\n....\n##.#\n.#.#\n\n
\n\n \n
\nSample Output 1
###\n###\n.##\n\n
The second row and the third column in the original grid will be removed.
\n\n
\n\n \n
\nSample Input 2
3 3\n#..\n.#.\n..#\n\n
\n\n \n
\nSample Output 2
#..\n.#.\n..#\n\n
As there is no row or column that consists only of white squares, no operation will be performed.
\n\n
\n\n \n
\nSample Input 3
4 5\n.....\n.....\n..#..\n.....\n\n
\n\n \n
\nSample Output 3
#\n\n
\n
\n\n \n
\nSample Input 4
7 6\n......\n....#.\n.#....\n..#...\n..#...\n......\n.#..#.\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int h;\n int w;\n scanf(\"%d %d\", &h, &w);\n char gazou[h][w + 1];\n\n for (int i = 0; i < h; i++) {\n scanf(\"%s\", gazou[i]);\n }\n\n for (int i = 0; i < h; i++) {\n for (int j = 0; j < w; j++) {\n for (int k = 0; k < h; k++) {\n if (strstr(gazou[i], \"#\") != NULL && gazou[k][j] != '.') {\n printf(\"%c\", gazou[i][j]);\n break;\n }\n }\n if (j == w - 1 && strstr(gazou[i], \"#\") != NULL) {\n printf(\"\\n\");\n }\n }\n }\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n\n std::io::stdin().read_to_string(&mut buf).unwrap();\n\n let mut iter = buf.split_whitespace();\n let h: usize = iter.next().unwrap().parse().unwrap();\n let w: usize = iter.next().unwrap().parse().unwrap();\n let a: VecSample Output 4
..#\n#..\n.#.\n.#.\n#.#\n
Score : 100 points
\n\n\n \n
\nProblem Statement
On some day in January 2018, Takaki is writing a document. The document has a column where the current date is written in yyyy/mm/dd format. For example, January 23, 2018 should be written as 2018/01/23.
After finishing the document, she noticed that she had mistakenly wrote 2017 at the beginning of the date column. Write a program that, when the string that Takaki wrote in the date column, S, is given as input, modifies the first four characters in S to 2018 and prints it.
\n\n \n
\nConstraints
- \n
- S is a string of length 10. \n
- The first eight characters in S are
2017/01/. \n - The last two characters in S are digits and represent an integer between 1 and 31 (inclusive). \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nS\n\n
\n\n \n
\nOutput
Replace the first four characters in S with 2018 and print it.
\n
\n\n \n
\nSample Input 1
2017/01/07\n\n
\n\n \n
\nSample Output 1
2018/01/07\n\n
\n
\n\n \n
\nSample Input 2
2017/01/31\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n char s[11];\n scanf(\"%s\", s);\n char *p = &s[4];\n printf(\"2018%s\\n\", p);\n return 0;\n}", "rust_code": "fn solution() {\n let mut s = String::new();\n io::stdin().read_line(&mut s).expect(\"failed to read line\");\n\n println!(\"2018{}\", &s[4..])\n}", "difficulty": "easy"}
{"problem_id": "0077", "problem_description": "\nSample Output 2
2018/01/31\n
Score : 500 points
\n\n\n \n
\nProblem Statement
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
\nTakahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
\nProcess the following Q queries:
\n- \n
- The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1. \n
\n\n \n
\nConstraints
- \n
- All values in input are integers. \n
- 2 \\leq N \\leq 300 \n
- 0 \\leq M \\leq \\frac{N(N-1)}{2} \n
- 1 \\leq L \\leq 10^9 \n
- 1 \\leq A_i, B_i \\leq N \n
- A_i \\neq B_i \n
- \\left(A_i, B_i\\right) \\neq \\left(A_j, B_j\\right) (if i \\neq j) \n
- \\left(A_i, B_i\\right) \\neq \\left(B_j, A_j\\right) (if i \\neq j) \n
- 1 \\leq C_i \\leq 10^9 \n
- 1 \\leq Q \\leq N\\left(N-1\\right) \n
- 1 \\leq s_i, t_i \\leq N \n
- s_i \\neq t_i \n
- \\left(s_i, t_i\\right) \\neq \\left(s_j, t_j\\right) (if i \\neq j) \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN M L\nA_1 B_1 C_1\n:\nA_M B_M C_M\nQ\ns_1 t_1\n:\ns_Q t_Q\n\n
\n\n \n
\nOutput
Print Q lines.
\nThe i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
\n\n
\n\n \n
\nSample Input 1
3 2 5\n1 2 3\n2 3 3\n2\n3 2\n1 3\n\n
\n\n \n
\nSample Output 1
0\n1\n\n
To travel from Town 3 to Town 2, we can use the second road to reach Town 2 without fueling the tank on the way.
\nTo travel from Town 1 to Town 3, we can first use the first road to get to Town 2, full the tank, and use the second road to reach Town 3.
\n\n
\n\n \n
\nSample Input 2
4 0 1\n1\n2 1\n\n
\n\n \n
\nSample Output 2
-1\n\n
There may be no road at all.
\n\n
\n\n \n
\nSample Input 3
5 4 4\n1 2 2\n2 3 2\n3 4 3\n4 5 2\n20\n2 1\n3 1\n4 1\n5 1\n1 2\n3 2\n4 2\n5 2\n1 3\n2 3\n4 3\n5 3\n1 4\n2 4\n3 4\n5 4\n1 5\n2 5\n3 5\n4 5\n\n
\n\n \n
\n", "c_code": "int solution() {\n int i;\n int u;\n int w;\n int c;\n int N;\n int M;\n int L;\n int dist[302][302] = {};\n scanf(\"%d %d %d\", &N, &M, &L);\n for (u = 1; u < N; u++) {\n for (w = u + 1; w <= N; w++) {\n if (dist[u][w] == 0) {\n dist[u][w] = L + 1;\n dist[w][u] = L + 1;\n }\n }\n }\n for (i = 1; i <= M; i++) {\n scanf(\"%d %d %d\", &u, &w, &c);\n if (c <= L) {\n dist[u][w] = c;\n dist[w][u] = c;\n }\n }\n\n int v;\n for (v = 1; v <= N; v++) {\n for (u = 1; u < N; u++) {\n for (w = u + 1; w <= N; w++) {\n if (dist[u][v] + dist[v][w] < dist[u][w]) {\n dist[u][w] = dist[u][v] + dist[v][w];\n dist[w][u] = dist[u][v] + dist[v][w];\n }\n }\n }\n }\n\n int ans[302][302] = {};\n int q[302];\n int head;\n int tail;\n for (v = 1; v <= N; v++) {\n q[0] = v;\n ans[v][v] = 1;\n for (head = 0, tail = 1; head < tail; head++) {\n u = q[head];\n for (w = 1; w <= N; w++) {\n if (ans[v][w] == 0 && dist[u][w] <= L) {\n ans[v][w] = ans[v][u] + 1;\n q[tail++] = w;\n }\n }\n }\n }\n\n int Q;\n int s;\n int t;\n scanf(\"%d\", &Q);\n for (i = 1; i <= Q; i++) {\n scanf(\"%d %d\", &s, &t);\n printf(\"%d\\n\", ((ans[s][t] > 0) ? ans[s][t] : 1) - 2);\n }\n fflush(stdout);\n return 0;\n}", "rust_code": "fn solution() {\n let (N, M, L): (usize, usize, i64) = {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n iter.next().unwrap().parse().unwrap(),\n iter.next().unwrap().parse().unwrap(),\n iter.next().unwrap().parse().unwrap(),\n )\n };\n let (A, B, C): (VecSample Output 3
0\n0\n1\n2\n0\n0\n1\n2\n0\n0\n0\n1\n1\n1\n0\n0\n2\n2\n1\n0\n
Card Game
\n\n
\n Taro and Hanako are playing card games. They have n cards each, and they compete n turns. At each turn Taro and Hanako respectively puts out a card.\n The name of the animal consisting of alphabetical letters is written on each card, and the bigger one in lexicographical order becomes the winner of that turn. The winner obtains 3 points. In the case of a draw, they obtain 1 point each.\n
\n\n\n Write a program which reads a sequence of cards Taro and Hanako have and reports the final scores of the game.\n
\n\nInput
\n\n\n In the first line, the number of cards n is given. In the following n lines, the cards for n turns are given respectively. For each line, the first string represents the Taro's card and the second one represents Hanako's card.\n
\n\n\nConstraints
\n- \n
- n ≤ 1000 \n
- The length of the string ≤ 100 \n
Output
\n\n\n Print the final scores of Taro and Hanako respectively. Put a single space character between them.\n
\n\nSample Input
\n\n\n3\ncat dog\nfish fish\nlion tiger\n\n\n
Sample Output
\n\n\n1 7\n", "c_code": "int solution(void) {\n#define WIN_POINT 3\n#define DRAW_POINT 1\n\n int n = 0;\n char t_card[101];\n char h_card[101];\n int i = 0;\n int check = 0;\n int t_point = 0;\n int h_point = 0;\n\n scanf(\"%d\", &n);\n for (i = 0; i < n; i++) {\n scanf(\"%s %s\", t_card, h_card);\n check = strcmp(t_card, h_card);\n if (check < 0) {\n h_point += WIN_POINT;\n } else if (check > 0) {\n t_point += WIN_POINT;\n } else {\n t_point += DRAW_POINT;\n h_point += DRAW_POINT;\n }\n }\n printf(\"%d %d\\n\", t_point, h_point);\n\n#undef WIN_POINT\n#undef DRAW_POINT\n\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = std::io::stdin();\n let mut buf = String::new();\n stdin.read_line(&mut buf).unwrap();\n let n = buf.trim().parse::
Score : 100 points
\n\n\n \n
\nProblem Statement
X and A are integers between 0 and 9 (inclusive).
\nIf X is less than A, print 0; if X is not less than A, print 10.
\n\n\n \n
\nConstraints
- \n
- 0 \\leq X, A \\leq 9 \n
- All values in input are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nX A\n\n
\n\n \n
\nOutput
If X is less than A, print 0; if X is not less than A, print 10.
\n\n
\n\n \n
\nSample Input 1
3 5\n\n
\n\n \n
\nSample Output 1
0\n\n
3 is less than 5, so we should print 0.
\n\n
\n\n \n
\nSample Input 2
7 5\n\n
\n\n \n
\nSample Output 2
10\n\n
7 is not less than 5, so we should print 10.
\n\n
\n\n \n
\nSample Input 3
6 6\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n\n int x = 0;\n int a = 0;\n scanf(\"%d %d\", &x, &a);\n\n printf(\"%d\", x < a ? 0 : 10);\n}", "rust_code": "fn solution() {\n let mut xa = String::new();\n stdin().read_line(&mut xa).unwrap();\n let xa: VecSample Output 3
10\n\n
6 is not less than 6, so we should print 10.
Cake Party
\n\n\n I’m planning to have a party on my birthday. Many of my friends will come to the party. Some of them will come with one or more pieces of cakes, but it is not certain if the number of the cakes is a multiple of the number of people coming.\n
\n\n I wish to enjoy the cakes equally among the partiers. So, I decided to apply the following rules. First, all the party attendants are given the same number of cakes. If some remainder occurs, a piece goes on a priority basis to the party host (that’s me!). How many pieces of cake can I enjoy?\n
\n\n\n\n Given the number of my friends and cake information, make a program to calculate how many pieces of cake I can enjoy. Note that I am not counted in the number of my friends.\n
\n\nInput
\n\nThe input is given in the following format.\n
\n\n$N$ $C$\n$p_1$ $p_2$ ... $p_C$\n\n\n
\nThe first line provides the number of my friends $N$ ($1 \\leq N \\leq 100$) and the number of those among them who brought one or more pieces of cake with them $C$ ($1 \\leq C \\leq N$). The second line provides an array of integers $p_i$ ($1 \\leq p_i \\leq100$), each of which shows the number of cakes of the $i$-th friend of mine who was willing to come up with one or more pieces of cake.\n
\n\nOutput
\n\n Output the number of cakes I can enjoy.\n
\n\nSample Input 1
\n\n5 4\n5 5 6 5\n\n
Sample Output 1
\n\n4\n\n\n
Sample Input 2
\n\n7 5\n8 8 8 8 8\n\n\n
Sample Output 2
\n\n5\n\n\n
Sample Input 3
\n\n100 3\n3 3 3\n\n\n
Sample Output 3
\n\n1\n", "c_code": "int solution(void) {\n\n int i = 0;\n\n int n = 0;\n\n int c = 0;\n\n int p[100];\n\n int total = 0;\n\n int count = 0;\n\n int Surplus = 0;\n\n for (i = 0; i < 100; i++) {\n p[i] = 0;\n }\n\n scanf(\"%d %d\", &n, &c);\n\n for (i = 0; i < c; i++) {\n scanf(\"%d\", &p[i]);\n total = total + p[i];\n }\n\n count = total / (n + 1);\n\n Surplus = total % (n + 1);\n\n if (Surplus == 0) {\n printf(\"%d\\n\", count);\n }\n\n else {\n printf(\"%d\\n\", count + 1);\n }\n}", "rust_code": "fn solution() {\n let stdin = stdin();\n let mut lines = stdin.lock().lines().map(|l| l.unwrap());\n\n let n: u32 = {\n let line = lines.next().unwrap();\n let mut iter = line.split_whitespace().map(|s| s.parse().unwrap());\n\n iter.next().unwrap()\n };\n\n let sum_p: u32 = {\n let line = lines.next().unwrap();\n line.split_whitespace()\n .map(|s| s.parse::
Swapping Two Numbers
\n\n\n Write a program which reads two integers x and y, and prints them in ascending order. \n
\n\n\nInput
\n\n\nThe input consists of multiple datasets. Each dataset consists of two integers x and y separated by a single space.\n
\n\n\nThe input ends with two 0 (when both x and y are zero). Your program should not process for these terminal symbols.\n
\n\nOutput
\n\n\nFor each dataset, print x and y in ascending order in a line. Put a single space between x and y.\n
\n\nConstraints
\n\n- \n
- 0 ≤ x, y ≤ 10000 \n
- the number of datasets ≤ 3000 \n
Sample Input
\n\n3 2\n2 2\n5 3\n0 0\n\n
Sample Output
\n\n2 3\n2 2\n3 5\n", "c_code": "int solution(void) {\n\n int i = 0;\n int x = 0;\n int y = 0;\n\n for (i = 1;; i++) {\n scanf(\"%d %d\", &x, &y);\n\n if (x <= 0 && x > 10000 && y <= 0 && y > 10000) {\n\n printf(\"Invalid Input\\n\");\n return 0;\n }\n\n if (x != 0 || y != 0) {\n if (x < y) {\n printf(\"%d %d\\n\", x, y);\n } else {\n printf(\"%d %d\\n\", y, x);\n }\n } else {\n break;\n }\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n loop {\n let mut v: Vec
Score : 200 points
\n\n\n \n
\nProblem Statement
In some other world, today is the day before Christmas Eve.
\nMr. Takaha is buying N items at a department store. The regular price of the i-th item (1 \\leq i \\leq N) is p_i yen (the currency of Japan).
\nHe has a discount coupon, and can buy one item with the highest price for half the regular price. The remaining N-1 items cost their regular prices. What is the total amount he will pay?
\n\n\n \n
\nConstraints
- \n
- 2 \\leq N \\leq 10 \n
- 100 \\leq p_i \\leq 10000 \n
- p_i is an even number. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\np_1\np_2\n:\np_N\n\n
\n\n \n
\nOutput
Print the total amount Mr. Takaha will pay.
\n\n
\n\n \n
\nSample Input 1
3\n4980\n7980\n6980\n\n
\n\n \n
\nSample Output 1
15950\n\n
The 7980-yen item gets the discount and the total is 4980 + 7980 / 2 + 6980 = 15950 yen.
\nNote that outputs such as 15950.0 will be judged as Wrong Answer.
\n
\n\n \n
\nSample Input 2
4\n4320\n4320\n4320\n4320\n\n
\n\n \n
\n", "c_code": "int solution() {\n int n = 0;\n scanf(\"%d\\n\", &n);\n int max = 0;\n int sum = 0;\n int buf = 0;\n for (int i = 0; i < n; i++) {\n scanf(\"%d\", &buf);\n sum += buf;\n if (buf > max) {\n max = buf;\n }\n }\n printf(\"%d\\n\", sum - (max / 2));\n return 0;\n}", "rust_code": "fn solution() {\n let N: usize = {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().parse().unwrap()\n };\n let p: VecSample Output 2
15120\n\n
Only one of the four items gets the discount and the total is 4320 / 2 + 4320 + 4320 + 4320 = 15120 yen.
Score : 400 points
\n\n\n \n
\nProblem Statement
Takahashi will play a game using a piece on an array of squares numbered 1, 2, \\cdots, N. Square i has an integer C_i written on it. Also, he is given a permutation of 1, 2, \\cdots, N: P_1, P_2, \\cdots, P_N.
\nNow, he will choose one square and place the piece on that square. Then, he will make the following move some number of times between 1 and K (inclusive):
\n- \n
- In one move, if the piece is now on Square i (1 \\leq i \\leq N), move it to Square P_i. Here, his score increases by C_{P_i}. \n
Help him by finding the maximum possible score at the end of the game. (The score is 0 at the beginning of the game.)
\n\n\n \n
\nConstraints
- \n
- 2 \\leq N \\leq 5000 \n
- 1 \\leq K \\leq 10^9 \n
- 1 \\leq P_i \\leq N \n
- P_i \\neq i \n
- P_1, P_2, \\cdots, P_N are all different. \n
- -10^9 \\leq C_i \\leq 10^9 \n
- All values in input are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN K\nP_1 P_2 \\cdots P_N\nC_1 C_2 \\cdots C_N\n\n
\n\n \n
\nOutput
Print the maximum possible score at the end of the game.
\n\n
\n\n \n
\nSample Input 1
5 2\n2 4 5 1 3\n3 4 -10 -8 8\n\n
\n\n \n
\nSample Output 1
8\n\n
When we start at some square of our choice and make at most two moves, we have the following options:
\n- \n
- If we start at Square 1, making one move sends the piece to Square 2, after which the score is 4. Making another move sends the piece to Square 4, after which the score is 4 + (-8) = -4. \n
- If we start at Square 2, making one move sends the piece to Square 4, after which the score is -8. Making another move sends the piece to Square 1, after which the score is -8 + 3 = -5. \n
- If we start at Square 3, making one move sends the piece to Square 5, after which the score is 8. Making another move sends the piece to Square 3, after which the score is 8 + (-10) = -2. \n
- If we start at Square 4, making one move sends the piece to Square 1, after which the score is 3. Making another move sends the piece to Square 2, after which the score is 3 + 4 = 7. \n
- If we start at Square 5, making one move sends the piece to Square 3, after which the score is -10. Making another move sends the piece to Square 5, after which the score is -10 + 8 = -2. \n
The maximum score achieved is 8.
\n\n
\n\n \n
\nSample Input 2
2 3\n2 1\n10 -7\n\n
\n\n \n
\nSample Output 2
13\n\n
\n
\n\n \n
\nSample Input 3
3 3\n3 1 2\n-1000 -2000 -3000\n\n
\n\n \n
\nSample Output 3
-1000\n\n
We have to make at least one move.
\n\n
\n\n \n
\nSample Input 4
10 58\n9 1 6 7 8 4 3 2 10 5\n695279662 988782657 -119067776 382975538 -151885171 -177220596 -169777795 37619092 389386780 980092719\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int N;\n int K = 0;\n scanf(\"%d %d\", &N, &K);\n int PList[N];\n int CList[N];\n int i = 0;\n for (i = 0; i < N; i++) {\n scanf(\"%d\", &PList[i]);\n }\n for (i = 0; i < N; i++) {\n scanf(\"%d\", &CList[i]);\n }\n long long ans = -1e18;\n int si = 0;\n for (si = 0; si < N; si++) {\n int x = si;\n int s[N];\n long long total = 0;\n long long l = 0;\n int idx = -1;\n while (1) {\n x = PList[x] - 1;\n s[++idx] = CList[x];\n l += 1;\n total += CList[x];\n if (x == si) {\n break;\n }\n }\n long long t = 0;\n for (i = 0; i < l; i++) {\n t += s[i];\n if (i + 1 > K) {\n break;\n }\n long long now = t;\n if (total > 0) {\n long long e = (K - (i + 1)) / l;\n now += total * e;\n }\n if (ans < now) {\n ans = now;\n }\n }\n }\n printf(\"%lld\", ans);\n return 0;\n}", "rust_code": "fn solution() {\n let (n, k): (usize, usize) = {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n let mut iter = buf.split_whitespace();\n (\n iter.next().unwrap().parse().unwrap(),\n iter.next().unwrap().parse().unwrap(),\n )\n };\n\n let p: VecSample Output 4
29507023469\n\n
The absolute value of the answer may be enormous.
Score : 300 points
\n\n\n \n
\nProblem Statement
You are given a string s.\nAmong the different substrings of s, print the K-th lexicographically smallest one.
\nA substring of s is a string obtained by taking out a non-empty contiguous part in s.\nFor example, if s = ababc, a, bab and ababc are substrings of s, while ac, z and an empty string are not.\nAlso, we say that substrings are different when they are different as strings.
Let X = x_{1}x_{2}...x_{n} and Y = y_{1}y_{2}...y_{m} be two distinct strings. X is lexicographically larger than Y if and only if Y is a prefix of X or x_{j} > y_{j} where j is the smallest integer such that x_{j} \\neq y_{j}.
\n\n\n \n
\nConstraints
- \n
- 1 ≤ |s| ≤ 5000 \n
- s consists of lowercase English letters. \n
- 1 ≤ K ≤ 5 \n
- s has at least K different substrings. \n
\n\n \n
\nPartial Score
- \n
- 200 points will be awarded as a partial score for passing the test set satisfying |s| ≤ 50. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\ns\nK\n\n
\n\n \n
\nOutput
Print the K-th lexicographically smallest substring of K.
\n\n
\n\n \n
\nSample Input 1
aba\n4\n\n
\n\n \n
\nSample Output 1
b\n\n
s has five substrings: a, b, ab, ba and aba.\nAmong them, we should print the fourth smallest one, b.\nNote that we do not count a twice.
\n
\n\n \n
\nSample Input 2
atcoderandatcodeer\n5\n\n
\n\n \n
\nSample Output 2
andat\n\n
\n
\n\n \n
\nSample Input 3
z\n1\n\n
\n\n \n
\n", "c_code": "int solution() {\n char s[5001];\n scanf(\"%s\", s);\n int K;\n scanf(\"%d\", &K);\n\n int l = strlen(s);\n int c = 0;\n for (int i = 0; i < K; i++) {\n c += l - i;\n }\n\n char sub[c][K + 1];\n\n int cc = 0;\n for (int i = 1; i <= K; i++) {\n for (int j = 0; j < l - i + 1; j++) {\n for (int k = 0; k < i; k++) {\n sub[cc][k] = s[j + k];\n if (k == i - 1) {\n for (k; k < K; k++) {\n sub[cc][k + 1] = '\\0';\n }\n }\n }\n cc++;\n }\n }\n\n int r = c;\n int swapped = 0;\n while (r > 1 || swapped == 1) {\n if (r > 1) {\n r = r * 10 / 13;\n }\n swapped = 0;\n for (int i = 0; i + r < c; i++) {\n if (strcmp(sub[i], sub[i + r]) > 0) {\n char tmp[K + 1];\n for (int j = 0; j < K + 1; j++) {\n tmp[j] = sub[i][j];\n }\n for (int j = 0; j < K + 1; j++) {\n sub[i][j] = sub[i + r][j];\n }\n for (int j = 0; j < K + 1; j++) {\n sub[i + r][j] = tmp[j];\n }\n swapped = 1;\n }\n }\n }\n\n int k = 1;\n for (int i = 0; i < c; i++) {\n if (i > 0 && strcmp(sub[i - 1], sub[i]) != 0) {\n k++;\n }\n if (k == K) {\n printf(\"%s\\n\", sub[i]);\n return 0;\n }\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = io::stdin();\n let mut lines = stdin.lock().lines();\n let s = lines.next().unwrap().unwrap();\n let k: usize = lines.next().unwrap().unwrap().parse().unwrap();\n let mut ss: BTreeSet<&str> = BTreeSet::new();\n for i in 0..s.len() {\n let len = min(5, s.len() - i);\n for j in 0..len {\n ss.insert(&s[i..(i + j + 1)]);\n }\n }\n let mut it = ss.iter();\n for _ in 0..(k - 1) {\n it.next();\n }\n println!(\"{}\", it.next().unwrap());\n}", "difficulty": "medium"}
{"problem_id": "0096", "problem_description": "You are given a table $$$a$$$ of size $$$n \\times m$$$. We will consider the table rows numbered from top to bottom from $$$1$$$ to $$$n$$$, and the columns numbered from left to right from $$$1$$$ to $$$m$$$. We will denote a cell that is in the $$$i$$$-th row and in the $$$j$$$-th column as $$$(i, j)$$$. In the cell $$$(i, j)$$$ there is written a number $$$(i - 1) \\cdot m + j$$$, that is $$$a_{ij} = (i - 1) \\cdot m + j$$$.A turtle initially stands in the cell $$$(1, 1)$$$ and it wants to come to the cell $$$(n, m)$$$. From the cell $$$(i, j)$$$ it can in one step go to one of the cells $$$(i + 1, j)$$$ or $$$(i, j + 1)$$$, if it exists. A path is a sequence of cells in which for every two adjacent in the sequence cells the following satisfies: the turtle can reach from the first cell to the second cell in one step. A cost of a path is the sum of numbers that are written in the cells of the path. For example, with $$$n = 2$$$ and $$$m = 3$$$ the table will look as shown above. The turtle can take the following path: $$$(1, 1) \\rightarrow (1, 2) \\rightarrow (1, 3) \\rightarrow (2, 3)$$$. The cost of such way is equal to $$$a_{11} + a_{12} + a_{13} + a_{23} = 12$$$. On the other hand, the paths $$$(1, 1) \\rightarrow (1, 2) \\rightarrow (2, 2) \\rightarrow (2, 1)$$$ and $$$(1, 1) \\rightarrow (1, 3)$$$ are incorrect, because in the first path the turtle can't make a step $$$(2, 2) \\rightarrow (2, 1)$$$, and in the second path it can't make a step $$$(1, 1) \\rightarrow (1, 3)$$$.You are asked to tell the turtle a minimal possible cost of a path from the cell $$$(1, 1)$$$ to the cell $$$(n, m)$$$. Please note that the cells $$$(1, 1)$$$ and $$$(n, m)$$$ are a part of the way.", "c_code": "int solution(void) {\n int test = 0;\n\n scanf(\"%d\", &test);\n\n while (test--) {\n int a;\n int b;\n scanf(\"%d %d\", &a, &b);\n long long n = a;\n long long m = b;\n long long r = (m * n * (n + 1) + m * m - m) / 2;\n\n printf(\"%lld\\n\", r);\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut round = String::new();\n io::stdin().read_line(&mut round).expect(\"inputing\");\n\n let round: usize = round.trim().parse().expect(\"parsing\");\n let mut i = 1;\n\n while i <= round {\n let mut size = String::new();\n io::stdin().read_line(&mut size).expect(\"loop input\");\n\n let space_index = size.find(\" \").expect(\" \");\n let n: usize = size[..space_index].trim().parse().expect(\"loop parsing\");\n let m: usize = size[space_index..].trim().parse().expect(\"loop parsing\");\n\n let mut sum = 0;\n let mut j = 1;\n let mut k = 2;\n\n while j <= m {\n sum += j;\n j += 1;\n }\n\n while k <= n {\n sum += k * m;\n k += 1;\n }\n\n println!(\"{}\", sum);\n i += 1;\n }\n}", "difficulty": "hard"}
{"problem_id": "0097", "problem_description": "You have an array $$$a$$$ of length $$$n$$$. For every positive integer $$$x$$$ you are going to perform the following operation during the $$$x$$$-th second: Select some distinct indices $$$i_{1}, i_{2}, \\ldots, i_{k}$$$ which are between $$$1$$$ and $$$n$$$ inclusive, and add $$$2^{x-1}$$$ to each corresponding position of $$$a$$$. Formally, $$$a_{i_{j}} := a_{i_{j}} + 2^{x-1}$$$ for $$$j = 1, 2, \\ldots, k$$$. Note that you are allowed to not select any indices at all. You have to make $$$a$$$ nondecreasing as fast as possible. Find the smallest number $$$T$$$ such that you can make the array nondecreasing after at most $$$T$$$ seconds.Array $$$a$$$ is nondecreasing if and only if $$$a_{1} \\le a_{2} \\le \\ldots \\le a_{n}$$$.You have to answer $$$t$$$ independent test cases.", "c_code": "int solution() {\n int t;\n scanf(\"%d\", &t);\n for (int i = 0; i < t; i++) {\n int c;\n scanf(\"%d\", &c);\n long long a;\n long long cMax = 9223372036854775807 * -1;\n int bitMax = 0;\n for (int j = 0; j < c; j++) {\n scanf(\"%lli\", &a);\n if (a >= cMax) {\n cMax = a;\n } else {\n long long diff = cMax - a;\n int bitDiff = (int)log2(diff) + 1;\n\n if (bitDiff > bitMax) {\n bitMax = bitDiff;\n }\n }\n }\n printf(\"%d\\n\", bitMax);\n }\n}", "rust_code": "fn solution() {\n let stdin = io::stdin();\n let mut lines = stdin.lock().lines();\n let t: usize = lines.next().unwrap().unwrap().parse().unwrap();\n for _ in 0..t {\n let n: usize = lines.next().unwrap().unwrap().parse().unwrap();\n let mut xs: VecSample Output 3
z\n
Score : 200 points
\n\n\n \n
\nProblem Statement
Takahashi received otoshidama (New Year's money gifts) from N of his relatives.
\nYou are given N values x_1, x_2, ..., x_N and N strings u_1, u_2, ..., u_N as input. Each string u_i is either JPY or BTC, and x_i and u_i represent the content of the otoshidama from the i-th relative.
For example, if x_1 = 10000 and u_1 = JPY, the otoshidama from the first relative is 10000 Japanese yen; if x_2 = 0.10000000 and u_2 = BTC, the otoshidama from the second relative is 0.1 bitcoins.
If we convert the bitcoins into yen at the rate of 380000.0 JPY per 1.0 BTC, how much are the gifts worth in total?
\n\n\n \n
\nConstraints
- \n
- 2 \\leq N \\leq 10 \n
- u_i =
JPYorBTC. \n - If u_i =
JPY, x_i is an integer such that 1 \\leq x_i \\leq 10^8. \n - If u_i =
BTC, x_i is a decimal with 8 decimal digits, such that 0.00000001 \\leq x_i \\leq 100.00000000. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\nx_1 u_1\nx_2 u_2\n:\nx_N u_N\n\n
\n\n \n
\nOutput
If the gifts are worth Y yen in total, print the value Y (not necessarily an integer).
\nOutput will be judged correct when the absolute or relative error from the judge's output is at most 10^{-5}.
\n\n
\n\n \n
\nSample Input 1
2\n10000 JPY\n0.10000000 BTC\n\n
\n\n \n
\nSample Output 1
48000.0\n\n
The otoshidama from the first relative is 10000 yen. The otoshidama from the second relative is 0.1 bitcoins, which is worth 38000.0 yen if converted at the rate of 380000.0 JPY per 1.0 BTC. The sum of these is 48000.0 yen.
\nOutputs such as 48000 and 48000.1 will also be judged correct.
\n
\n\n \n
\nSample Input 2
3\n100000000 JPY\n100.00000000 BTC\n0.00000001 BTC\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int N = 0;\n scanf(\"%d\", &N);\n double x = 0;\n char u[4];\n double sum = 0;\n for (int i = 0; i < N; i++) {\n scanf(\"%lf %s\", &x, u);\n if (u[0] == 'J' && u[1] == 'P' && u[2] == 'Y') {\n sum += x;\n } else {\n sum += 380000.0 * x;\n }\n }\n printf(\"%f\\n\", sum);\n return 0;\n}", "rust_code": "fn solution() {\n let input = {\n use std::io::*;\n let mut input = String::new();\n let _ = stdin().read_to_string(&mut input);\n input\n .replace(\"JPY\", \"1.0\")\n .replace(\"BTC\", \"380000.0\")\n .split_whitespace()\n .skip(1)\n .map(|w| w.parse::Sample Output 2
138000000.0038\n\n
In this case, outputs such as 138001000 and 1.38e8 will also be judged correct.
Score : 200 points
\n\n\n \n
\nProblem Statement
You are given an image A composed of N rows and N columns of pixels, and a template image B composed of M rows and M columns of pixels.
\nA pixel is the smallest element of an image, and in this problem it is a square of size 1×1.
\nAlso, the given images are binary images, and the color of each pixel is either white or black.
In the input, every pixel is represented by a character: . corresponds to a white pixel, and # corresponds to a black pixel.
\nThe image A is given as N strings A_1,...,A_N.
\nThe j-th character in the string A_i corresponds to the pixel at the i-th row and j-th column of the image A (1≦i,j≦N).
\nSimilarly, the template image B is given as M strings B_1,...,B_M.
\nThe j-th character in the string B_i corresponds to the pixel at the i-th row and j-th column of the template image B (1≦i,j≦M).
Determine whether the template image B is contained in the image A when only parallel shifts can be applied to the images.
\n\n\n \n
\nConstraints
- \n
- 1≦M≦N≦50 \n
- A_i is a string of length N consisting of
#and.. \n - B_i is a string of length M consisting of
#and.. \n
\n
\n
\n\n\n \n
\nInput
The input is given from Standard Input in the following format:
\nN M\nA_1\nA_2\n: \nA_N\nB_1\nB_2\n: \nB_M\n\n
\n\n \n
\nOutput
Print Yes if the template image B is contained in the image A. Print No otherwise.
\n
\n\n \n
\nSample Input 1
3 2\n#.#\n.#.\n#.#\n#.\n.#\n\n
\n\n \n
\nSample Output 1
Yes\n\n
The template image B is identical to the upper-left 2 × 2 subimage and the lower-right 2 × 2 subimage of A. Thus, the output should be Yes.
\n
\n\n \n
\nSample Input 2
4 1\n....\n....\n....\n....\n#\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n\n int m = 1;\n int n = 1;\n int dif = 0;\n int match = 0;\n scanf(\"%d %d\", &n, &m);\n\n dif = n - m;\n char a[n][51];\n char b[m][51];\n\n for (int i = 0; i < n; i++) {\n scanf(\"%s\", a[i]);\n }\n for (int i = 0; i < m; i++) {\n scanf(\"%s\", b[i]);\n }\n\n for (int i = 0; i <= dif; i++) {\n for (int j = 0; j <= dif; j++) {\n for (int k = 0; k < m; k++) {\n for (int l = 0; l < m; l++) {\n if (a[i + k][j + l] == b[k][l]) {\n match++;\n } else {\n match = 0;\n break;\n }\n if (match == (m * m)) {\n break;\n }\n }\n if (match == 0 || match == (m * m)) {\n break;\n }\n }\n if (match == (m * m)) {\n break;\n }\n }\n if (match == (m * m)) {\n break;\n }\n }\n\n if (match == (m * m)) {\n printf(\"Yes\");\n } else {\n printf(\"No\");\n }\n return 0;\n}", "rust_code": "fn solution() {\n let mut stdin = io::stdin();\n let mut lines = String::new();\n let _ = stdin.read_to_string(&mut lines);\n let vec = lines.lines().collect::Sample Output 2
No\n\n
The template image B, composed of a black pixel, is not contained in the image A composed of white pixels.
マルバツスタンプ (Circle Cross Stamps)
\n\n\n問題文
\n\n\nJOI 君はマルスタンプ，バツスタンプ，マルバツスタンプの3種類のスタンプをそれぞれ 0 個以上持っている．これらはマルやバツのマークを紙に印字することができるスタンプである．\n
\n\n\nマルスタンプを使うとマルが 1 つ印字され，バツスタンプを使うとバツが 1 つ印字される．マルバツスタンプを使うとマルとバツが横一列に 1 つずつ印字され，スタンプの向きを変えることで，マルの右にバツが来るようにも，バツの右にマルが来るようにも印字できる．\n
\n\n\nJOI 君は，持っているスタンプをそれぞれちょうど 1 回ずつ適当な順番で使い，紙に横一列にマルとバツを印字した．印字されたマルとバツの列は文字列 S で表される．S は O と X から構成された長さ N の文字列であり，S_i = O ならば JOI 君が印字したマークのうち左から i 番目のものがマルであることを表し，S_i = X ならばそれがバツであることを表す (1 ≦ i ≦ N)．\n
\nあなたは，JOI 君が持っているスタンプの個数は分からないが，JOI 君が印字したマルとバツの列は知っている．印字されたマルとバツの列から，JOI 君が持っているマルバツスタンプの個数としてあり得るもののうち最大値を求めよ．\n
\n\n制約
\n\n- \n
- 1 ≦ N ≦ 100000 (= 10^5) \n
- S は長さ N の文字列である． \n
- S の各文字は
OかXである． \n
入力・出力
\n\n\n入力
\n入力は以下の形式で標準入力から与えられる．
\nN
\nS\n
\n出力
\nJOI 君が持っているマルバツスタンプの個数としてあり得るもののうち最大値を出力せよ．\n
入出力例
\n\n入力例 1
\n\n5\nOXXOX\n\n\n
出力例 1
\n\n2\n\n\n
\nJOI 君が印字したマークは，左から順に，マル，バツ，バツ，マル，バツである．JOI 君がマルスタンプ，バツスタンプ，マルバツスタンプをそれぞれ 0, 1, 2 個持っているとすると，以下の順番でスタンプを使えば，そのようにマークを印字することができる．\n
\n\n- \n
- 1 つ目のマルバツスタンプを使ってマルとバツをこの順に印字する． \n
- この右に，2 つ目のマルバツスタンプを使ってバツとマルをこの順に印字する． \n
- 最後に，この右に，バツスタンプを使ってバツを印字する． \n
\nマルバツスタンプを 3 個以上持っているケースは考えられないので，2 を出力する．\n
\n\n入力例 2
\n\n14\nOXOXOXOXXOXOXO\n\n\n
出力例 2
\n\n7\n\n\n
入力例 3
\n\n10\nOOOOOOOOOO\n\n\n
出力例 3
\n\n0\n\n\n
\n
\n
", "c_code": "int solution(void) {\n int N;\n char S[1000 * 100];\n int res = 0;\n\n scanf(\"%d\", &N);\n scanf(\"%s\", S);\n\n for (int i = 0; i < N;) {\n if ((S[i] == 'O' && S[i + 1] == 'X') || (S[i] == 'X' && S[i + 1] == 'O')) {\n res++;\n i++;\n i++;\n } else {\n i++;\n }\n }\n\n printf(\"%d\\n\", res);\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n let stdin = io::stdin();\n let mut lock = stdin.lock();\n\n lock.read_to_string(&mut buf);\n\n let mut iter = buf.split_whitespace();\n let n: usize = iter.next().unwrap().parse().unwrap();\n let s: Vec\n\n
Score : 200 points
\n\n\n \n
\nProblem Statement
Takahashi has N days of summer vacation.
\nHis teacher gave him M summer assignments. It will take A_i days for him to do the i-th assignment.
\nHe cannot do multiple assignments on the same day, or hang out on a day he does an assignment.
\nWhat is the maximum number of days Takahashi can hang out during the vacation if he finishes all the assignments during this vacation?
\nIf Takahashi cannot finish all the assignments during the vacation, print -1 instead.
\n\n \n
\nConstraints
- \n
- 1 \\leq N \\leq 10^6 \n
- 1 \\leq M \\leq 10^4 \n
- 1 \\leq A_i \\leq 10^4 \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN M\nA_1 ... A_M\n\n
\n\n \n
\nOutput
Print the maximum number of days Takahashi can hang out during the vacation, or -1.
\n
\n\n \n
\nSample Input 1
41 2\n5 6\n\n
\n\n \n
\nSample Output 1
30\n\n
For example, he can do the first assignment on the first 5 days, hang out on the next 30 days, and do the second assignment on the last 6 days of the vacation. In this way, he can safely spend 30 days hanging out.
\n\n
\n\n \n
\nSample Input 2
10 2\n5 6\n\n
\n\n \n
\nSample Output 2
-1\n\n
He cannot finish his assignments.
\n\n
\n\n \n
\nSample Input 3
11 2\n5 6\n\n
\n\n \n
\nSample Output 3
0\n\n
He can finish his assignments, but he will have no time to hang out.
\n\n
\n\n \n
\nSample Input 4
314 15\n9 26 5 35 8 9 79 3 23 8 46 2 6 43 3\n\n
\n\n \n
\n", "c_code": "int solution() {\n int time = 0;\n int NumTask = 0;\n scanf(\"%d %d\", &time, &NumTask);\n int temp = 0;\n for (int i = 0; i < NumTask; i++) {\n scanf(\"%d\", &temp);\n time -= temp;\n }\n if (time >= 0) {\n printf(\"%d\", time);\n } else {\n printf(\"-1\");\n }\n}", "rust_code": "fn solution() {\n let mut st = String::new();\n stdin().read_line(&mut st).unwrap();\n let (n, _m) = {\n let nm: Vec<_> = st\n .trim()\n .split(\" \")\n .map(|x| x.parse::Sample Output 4
9\n
Score : 300 points
\n\n\n \n
\nProblem Statement
There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N.
\nOn this sequence, Snuke can perform the following operation:
\n- \n
- Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen elements. \n
Snuke would like to make all the elements in this sequence equal by repeating the operation above some number of times.\nFind the minimum number of operations required.\nIt can be proved that, Under the constraints of this problem, this objective is always achievable.
\n\n\n \n
\nConstraints
- \n
- 2 \\leq K \\leq N \\leq 100000 \n
- A_1, A_2, ..., A_N is a permutation of 1, 2, ..., N. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN K\nA_1 A_2 ... A_N\n\n
\n\n \n
\nOutput
Print the minimum number of operations required.
\n\n
\n\n \n
\nSample Input 1
4 3\n2 3 1 4\n\n
\n\n \n
\nSample Output 1
2\n\n
One optimal strategy is as follows:
\n- \n
- \n
In the first operation, choose the first, second and third elements. The sequence A becomes 1, 1, 1, 4.
\n \n - \n
In the second operation, choose the second, third and fourth elements. The sequence A becomes 1, 1, 1, 1.
\n \n
\n
\n\n \n
\nSample Input 2
3 3\n1 2 3\n\n
\n\n \n
\nSample Output 2
1\n\n
\n
\n\n \n
\nSample Input 3
8 3\n7 3 1 8 4 6 2 5\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int n = 0;\n int k = 0;\n int count = 0;\n scanf(\"%d %d\", &n, &k);\n while (n > 0) {\n count++;\n n -= k;\n if (n) {\n n++;\n }\n }\n printf(\"%d\\n\", count);\n return 0;\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n let mut iter = buf.split_whitespace();\n let n: u32 = iter.next().unwrap().parse().unwrap();\n let k: u32 = iter.next().unwrap().parse().unwrap();\n let ans = (n - 1) / (k - 1) + if (n - 1).is_multiple_of(k - 1) { 0 } else { 1 };\n println!(\"{}\", ans);\n}", "difficulty": "hard"}
{"problem_id": "0105", "problem_description": "\nSample Output 3
4\n
Score : 300 points
\n\n\n \n
\nProblem Statement
Two foxes Jiro and Saburo are playing a game called 1D Reversi. This game is played on a board, using black and white stones. On the board, stones are placed in a row, and each player places a new stone to either end of the row. Similarly to the original game of Reversi, when a white stone is placed, all black stones between the new white stone and another white stone, turn into white stones, and vice versa.
\nIn the middle of a game, something came up and Saburo has to leave the game. The state of the board at this point is described by a string S. There are |S| (the length of S) stones on the board, and each character in S represents the color of the i-th (1 ≦ i ≦ |S|) stone from the left. If the i-th character in S is B, it means that the color of the corresponding stone on the board is black. Similarly, if the i-th character in S is W, it means that the color of the corresponding stone is white.
Jiro wants all stones on the board to be of the same color. For this purpose, he will place new stones on the board according to the rules. Find the minimum number of new stones that he needs to place.
\n\n\n \n
\nConstraints
- \n
- 1 ≦ |S| ≦ 10^5 \n
- Each character in S is
BorW. \n
\n
\n
\n\n\n \n
\nInput
The input is given from Standard Input in the following format:
\nS\n\n
\n\n \n
\nOutput
Print the minimum number of new stones that Jiro needs to place for his purpose.
\n\n
\n\n \n
\nSample Input 1
BBBWW\n\n
\n\n \n
\nSample Output 1
1\n\n
By placing a new black stone to the right end of the row of stones, all white stones will become black. Also, by placing a new white stone to the left end of the row of stones, all black stones will become white.
\nIn either way, Jiro's purpose can be achieved by placing one stone.
\n\n
\n\n \n
\nSample Input 2
WWWWWW\n\n
\n\n \n
\nSample Output 2
0\n\n
If all stones are already of the same color, no new stone is necessary.
\n\n
\n\n \n
\nSample Input 3
WBWBWBWBWB\n\n
\n\n \n
\n", "c_code": "int solution() {\n char S[100000];\n int i = 0;\n int count = 0;\n while (1) {\n scanf(\"%c\", &S[i]);\n if (S[i] == '\\n') {\n break;\n }\n\n if (i != 0 && S[i - 1] != S[i]) {\n count++;\n }\n i++;\n }\n\n printf(\"%d\\n\", count);\n\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = std::io::stdin();\n let mut reader = std::io::BufReader::new(stdin.lock());\n\n let mut s = String::new();\n reader.read_line(&mut s).unwrap();\n let mut s: VecSample Output 3
9\n
Maximum Profit
\n\n\nYou can obtain profits from foreign exchange margin transactions. For example, if you buy 1000 dollar at a rate of 100 yen per dollar, and sell them at a rate of 108 yen per dollar, you can obtain (108 - 100) × 1000 = 8000 yen.\n
\n\n\n Write a program which reads values of a currency $R_t$ at a certain time $t$ ($t = 0, 1, 2, ... n-1$), and reports the maximum value of $R_j - R_i$ where $j > i$ .\n
\n\nInput
\n\n\nThe first line contains an integer $n$. In the following $n$ lines, $R_t$ ($t = 0, 1, 2, ... n-1$) are given in order.\n
\n\nOutput
\n\n\nPrint the maximum value in a line.\n
\n\nConstraints
\n\n- \n
- $2 \\leq n \\leq 200,000$ \n
- $1 \\leq R_t \\leq 10^9$ \n
Sample Input 1
\n\n6\n5\n3\n1\n3\n4\n3\n\n
Sample Output 1
\n\n3\n\n\n
Sample Input 2
\n\n3\n4\n3\n2\n\n
Sample Output 2
\n\n-1\n", "c_code": "int solution(void) {\n int i = 0;\n\n int n = 0;\n\n int maxv = 0;\n int minv = 0;\n\n int buf = 0;\n\n scanf(\"%d\", &n);\n\n scanf(\"%d\", &minv);\n\n for (i = 1; i < n; i++) {\n scanf(\"%d\", &buf);\n\n if (i == 1) {\n maxv = buf - minv;\n }\n\n maxv = maxv > buf - minv ? maxv : buf - minv;\n minv = minv < buf ? minv : buf;\n }\n\n printf(\"%d\\n\", maxv);\n\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = std::io::stdin();\n\n let mut buf: String = String::new();\n\n stdin.lock().read_line(&mut buf).expect(\"read_line()\");\n stdin.lock().read_line(&mut buf).expect(\"read_line()\");\n let vec: Vec<&str> = buf.split_whitespace().collect();\n\n let n = vec[0].parse().unwrap();\n\n let mut r_old: i32 = vec[1].parse().unwrap();\n\n let mut min = r_old;\n\n let mut gain_max: i32 = -1000000000;\n\n let mut gain = 0;\n\n let mut buf = String::new();\n for _t in 1..n {\n stdin.lock().read_line(&mut buf).expect(\"read_line()\");\n }\n let r_series: Vec<&str> = buf.split_whitespace().collect();\n for t in 1..n {\n let rt = r_series[t - 1].parse().unwrap();\n let diff = rt - r_old;\n if min > rt {\n min = rt;\n if gain_max < diff {\n gain_max = diff;\n }\n gain = 0;\n } else {\n gain += diff;\n if gain_max < gain {\n gain_max = gain;\n }\n }\n r_old = rt;\n }\n println!(\"{}\", gain_max);\n}", "difficulty": "medium"} {"problem_id": "0107", "problem_description": "\n
Score : 300 points
\n\n\n \n
\nProblem Statement
You are given three integers A, B and C. Find the minimum number of operations required to make A, B and C all equal by repeatedly performing the following two kinds of operations in any order:
\n- \n
- Choose two among A, B and C, then increase both by 1. \n
- Choose one among A, B and C, then increase it by 2. \n
It can be proved that we can always make A, B and C all equal by repeatedly performing these operations.
\n\n\n \n
\nConstraints
- \n
- 0 \\leq A,B,C \\leq 50 \n
- All values in input are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nA B C\n\n
\n\n \n
\nOutput
Print the minimum number of operations required to make A, B and C all equal.
\n\n
\n\n \n
\nSample Input 1
2 5 4\n\n
\n\n \n
\nSample Output 1
2\n\n
We can make A, B and C all equal by the following operations:
\n- \n
- Increase A and C by 1. Now, A, B, C are 3, 5, 5, respectively. \n
- Increase A by 2. Now, A, B, C are 5, 5, 5, respectively. \n
\n
\n\n \n
\nSample Input 2
2 6 3\n\n
\n\n \n
\nSample Output 2
5\n\n
\n
\n\n \n
\nSample Input 3
31 41 5\n\n
\n\n \n
\n", "c_code": "int solution() {\n int x[3];\n int count = 0;\n scanf(\"%d %d %d\", &x[0], &x[1], &x[2]);\n for (int i = 0; i < 2; i++) {\n if (x[i] > x[i + 1]) {\n int t = x[i] + x[i + 1];\n x[i] = t - x[i];\n x[i + 1] = t - x[i + 1];\n }\n }\n for (int i = 0; i < 2; i++) {\n if (x[i] > x[i + 1]) {\n int t = x[i] + x[i + 1];\n x[i] = t - x[i];\n x[i + 1] = t - x[i + 1];\n }\n }\n int xa = x[0] % 2;\n int xb = x[1] % 2;\n int xc = x[2] % 2;\n if ((xa != xb) && ((xb == xc) || (xa == xc))) {\n count += 2;\n } else if ((xa == xb) && (xb == xc)) {\n\n } else {\n count++;\n }\n count += (x[2] - x[1]) / 2;\n count += (x[2] - x[0]) / 2;\n printf(\"%d\", count);\n return 0;\n}", "rust_code": "fn solution() {\n let mut s: String = String::new();\n std::io::stdin().read_to_string(&mut s).ok();\n let mut itr = s.split_whitespace();\n let mut a: VecSample Output 3
23\n
Score : 500 points
\n\n\n \n
\nProblem Statement
Let us denote by f(x, m) the remainder of the Euclidean division of x by m.
\nLet A be the sequence that is defined by the initial value A_1=X and the recurrence relation A_{n+1} = f(A_n^2, M).\nFind \\displaystyle{\\sum_{i=1}^N A_i}.
\n\n\n \n
\nConstraints
- \n
- 1 \\leq N \\leq 10^{10} \n
- 0 \\leq X < M \\leq 10^5 \n
- All values in input are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN X M\n\n
\n\n \n
\nOutput
Print \\displaystyle{\\sum_{i=1}^N A_i}.
\n\n
\n\n \n
\nSample Input 1
6 2 1001\n\n
\n\n \n
\nSample Output 1
1369\n\n
The sequence A begins 2,4,16,256,471,620,\\ldots Therefore, the answer is 2+4+16+256+471+620=1369.
\n\n
\n\n \n
\nSample Input 2
1000 2 16\n\n
\n\n \n
\nSample Output 2
6\n\n
The sequence A begins 2,4,0,0,\\ldots Therefore, the answer is 6.
\n\n
\n\n \n
\nSample Input 3
10000000000 10 99959\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n\n long long N;\n long long X;\n long long M;\n\n scanf(\"%lld%lld%lld\", &N, &X, &M);\n\n long long c[M];\n\n for (long long i = 0; i < M; i++) {\n c[i] = 0;\n }\n\n long long x = X;\n long long f = 0;\n long long t = 0;\n long long a = 1;\n long long s;\n\n while (1) {\n if (c[x % M] > 0) {\n t = a - 1;\n s = x % M;\n break;\n }\n a++;\n c[x % M] = 1;\n x = (x * x) % M;\n }\n\n long long y = X;\n a = 1;\n\n while (1) {\n if (y % M == s) {\n f = a - 1;\n break;\n }\n a++;\n y = (y * y) % M;\n }\n\n long long ans = 0;\n\n for (long long i = 0; i < f; i++) {\n ans += X % M;\n X = (X * X) % M;\n }\n\n long long z = X;\n\n long long k = 0;\n for (long long i = f; i < t; i++) {\n k += X % M;\n X = (X * X) % M;\n }\n\n ans += k * ((N - f) / (t - f));\n\n for (long long j = 1; j <= (N - f) % (t - f); j++) {\n ans += z % M;\n z = (z * z) % M;\n }\n\n printf(\"%lld\\n\", ans);\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut s: String = String::new();\n std::io::stdin().read_to_string(&mut s).ok();\n let mut itr = s.split_whitespace();\n let n: usize = itr.next().unwrap().parse().unwrap();\n let x: usize = itr.next().unwrap().parse().unwrap();\n let m: usize = itr.next().unwrap().parse().unwrap();\n\n let mut used: VecSample Output 3
492443256176507\n
Score : 300 points
\n\n\n \n
\nProblem Statement
There are N people standing in a row from west to east.\nEach person is facing east or west.\nThe directions of the people is given as a string S of length N.\nThe i-th person from the west is facing east if S_i = E, and west if S_i = W.
You will appoint one of the N people as the leader, then command the rest of them to face in the direction of the leader.\nHere, we do not care which direction the leader is facing.
\nThe people in the row hate to change their directions, so you would like to select the leader so that the number of people who have to change their directions is minimized.\nFind the minimum number of people who have to change their directions.
\n\n\n \n
\nConstraints
- \n
- 2 \\leq N \\leq 3 \\times 10^5 \n
- |S| = N \n
- S_i is
EorW. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\nS\n\n
\n\n \n
\nOutput
Print the minimum number of people who have to change their directions.
\n\n
\n\n \n
\nSample Input 1
5\nWEEWW\n\n
\n\n \n
\nSample Output 1
1\n\n
Assume that we appoint the third person from the west as the leader.\nThen, the first person from the west needs to face east and has to turn around.\nThe other people do not need to change their directions, so the number of people who have to change their directions is 1 in this case.\nIt is not possible to have 0 people who have to change their directions, so the answer is 1.
\n\n
\n\n \n
\nSample Input 2
12\nWEWEWEEEWWWE\n\n
\n\n \n
\nSample Output 2
4\n\n
\n
\n\n \n
\nSample Input 3
8\nWWWWWEEE\n\n
\n\n \n
\n", "c_code": "int solution() {\n int Num = 0;\n char chara[3 * 100000];\n int Sum[3 * 100000] = {0};\n scanf(\"%d\", &Num);\n scanf(\"%s\", chara);\n for (int i = 0; i < Num; i++) {\n if (i == 0) {\n for (int j = 1; j < Num; j++) {\n if (chara[j] == 'E') {\n Sum[i]++;\n }\n }\n } else {\n Sum[i] = Sum[i - 1];\n if (chara[i - 1] == 'W') {\n Sum[i]++;\n }\n if (chara[i] == 'E') {\n Sum[i]--;\n }\n }\n }\n\n int minimum = 3 * 100000;\n\n for (int i = 0; i < Num; i++) {\n if (minimum > Sum[i]) {\n minimum = Sum[i];\n }\n }\n printf(\"%d\\n\", minimum);\n return 0;\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n let _: usize = buf.trim().parse().unwrap();\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n let mut s = buf.trim().chars().collect::Sample Output 3
3\n
How many ways?
\n\n
\n Write a program which identifies the number of combinations of three integers which satisfy the following conditions:\n
\n- \n
- You should select three distinct integers from 1 to n. \n
- A total sum of the three integers is x. \n
\n For example, there are two combinations for n = 5 and x = 9.\n
\n\n- \n
- 1 + 3 + 5 = 9 \n
- 2 + 3 + 4 = 9 \n
Input
\n\n The input consists of multiple datasets. For each dataset, two integers n and x are given in a line.\n
\n\n\n The input ends with two zeros for n and x respectively. Your program should not process for these terminal symbols.\n
\n\nConstraints
\n- \n
- 3 ≤ n ≤ 100 \n
- 0 ≤ x ≤ 300 \n
Output
\n\n\n For each dataset, print the number of combinations in a line.\n
\n\nSample Input
\n\n\n5 9\n0 0\n\n\n
Sample Output
\n\n\n2\n\n\n
Note
\n\n\nScore : 400 points
\n\n\n \n
\nProblem Statement
Give a pair of integers (A, B) such that A^5-B^5 = X.\nIt is guaranteed that there exists such a pair for the given integer X.
\n\n\n \n
\nConstraints
- \n
- 1 \\leq X \\leq 10^9 \n
- X is an integer. \n
- There exists a pair of integers (A, B) satisfying the condition in Problem Statement. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nX\n\n
\n\n \n
\nOutput
Print A and B, with space in between.\nIf there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
\nA B\n\n
\n
\n\n \n
\nSample Input 1
33\n\n
\n\n \n
\nSample Output 1
2 -1\n\n
For A=2 and B=-1, A^5-B^5 = 33.
\n\n
\n\n \n
\nSample Input 2
1\n\n
\n\n \n
\n", "c_code": "int solution() {\n long long x;\n scanf(\"%lld\", &x);\n\n for (long long a = 0; a >= 0; a++) {\n if (a < 64) {\n for (long long b = -64; b <= a; b++) {\n if (a * a * a * a * a - b * b * b * b * b == x) {\n printf(\"%lld %lld\", a, b);\n return 0;\n }\n }\n }\n if (a >= 64) {\n for (long long b = 1; b <= 2 * a; b++) {\n if (a * a * a * a * a - b * b * b * b * b == x) {\n printf(\"%lld %lld\", a, b);\n return 0;\n }\n }\n }\n }\n}", "rust_code": "fn solution() {\n let mut s = String::new();\n stdin().read_line(&mut s).ok();\n let x: i128 = s.trim().parse().unwrap();\n\n 'outer: for i in -10000i128..=10000 {\n let mut l: i128 = -10000;\n let mut r: i128 = 10000;\n let mut m: i128;\n while l < r {\n m = (l + r) / 2;\n let t = i.pow(5) - m.pow(5);\n if t == x {\n println!(\"{} {}\", i, m);\n\n break 'outer;\n } else if m == r || m == l {\n break;\n } else if t < x {\n r = m;\n } else {\n l = m;\n }\n }\n }\n}", "difficulty": "hard"}
{"problem_id": "0120", "problem_description": "This problem is interactive.We decided to play a game with you and guess the number $$$x$$$ ($$$1 \\le x < n$$$), where you know the number $$$n$$$.You can make queries like this: + c: this command assigns $$$x = x + c$$$ ($$$1 \\le c < n$$$) and then returns you the value $$$\\lfloor\\frac{x}{n}\\rfloor$$$ ($$$x$$$ divide by $$$n$$$ and round down).You win if you guess the current number with no more than $$$10$$$ queries.", "c_code": "int solution() {\n int i;\n int n;\n int ask;\n int ans1;\n int ans2;\n int lower;\n int upper;\n int middle;\n int sum;\n scanf(\"%d\", &n);\n lower = 1;\n upper = n;\n ans1 = sum = 0;\n for (i = 0; i < 11; i++) {\n if (upper == lower + 1) {\n printf(\"! %d\\n\", lower + sum);\n fflush(stdout);\n break;\n }\n\n middle = (upper + lower) / 2;\n ask = (ans1 + 1) * n - sum - middle;\n sum += ask;\n\n printf(\"+ %d\\n\", ask);\n fflush(stdout);\n scanf(\"%d\", &ans2);\n if (ans2 == ans1 + 1) {\n lower = middle;\n } else {\n upper = middle;\n }\n ans1 = ans2;\n }\n}", "rust_code": "fn solution() {\n let stdin = io::stdin();\n let mut lines = stdin.lock().lines();\n let n = lines.next().unwrap().unwrap().parse::Sample Output 2
0 -1\n
気象予報士 (Weather Forecaster)
\n\n問題
\n\n\nJOI 市は南北方向に H キロメートル，東西方向に W キロメートルの長方形の形をしており，H × W 個の 1 キロメートル四方の小区画に区切られている．北から i 番目，西から j 番目の小区画を (i, j) と表す．\n
\n\n\n各小区画は上空に雲があるか雲がないかのどちらかである．すべての雲は，1 分経つごとに 1 キロメートル東に移動する．今日は実に天気が良いため，JOI 市の外から JOI 市内に雲が移動してくることはない．\n
\n\n\n今，各小区画の上空に雲があるかないかがわかっている．気象予報士であるあなたは，各小区画について，今から何分後に初めてその小区画の上空に雲が来るかを予測することになった．\n
\n\n\n各小区画について，今から何分後に初めてその小区画の上空に雲が来るか求めよ．\n
\n\n入力
\n\n\n入力は 1 + H 行からなる．\n
\n\n\n1 行目には，整数 H, W (1 ≤ H ≤ 100, 1 ≤ W ≤ 100) が空白を区切りとして書かれている．これは，JOI 市が H × W 個の 1 キロメートル四方の小区画に区切られていることを表す．\n
\n\n\n続く H 行のうちの i 行目 (1 ≤ i ≤ H) には W 文字からなる文字列が書かれている．W 文字のうちの j 文字目 (1 ≤ j ≤ W) は，小区画 (i, j) の上空に，今，雲があるかどうかを表す．雲がある場合は文字 'c' (英小文字) が，雲がない場合は文字 '.' (ピリオド) が書かれている．\n
\n\n出力
\n\n出力は H 行からなり，それぞれの行は空白を区切りとした W 個の整数からなる．出力の i 行目の j 番目の整数 (1 ≤ i ≤ H, 1 ≤ j ≤ W) は，今から何分後に初めて小区画 (i, j) の上空に雲が来るかを表さなければならない．ただし，今すでに小区画 (i, j) の上空に雲がある場合は 0 を，何分経っても小区画 (i, j) の上空に雲が来ない場合は -1 を出力せよ．\n
\n\n\n出力の各行の行頭と行末には余計な空白を入れないこと．\n
\n\n入出力例
\n\n入力例 1
\n\n\n3 4\nc..c\n..c.\n....\n\n
出力例 1
\n\n0 1 2 0\n-1 -1 0 1\n-1 -1 -1 -1\n\n\n
入力例 2
\n\n6 8\n.c......\n........\n.ccc..c.\n....c...\n..c.cc..\n....c...\n\n\n
出力例 2
\n\n\n-1 0 1 2 3 4 5 6\n-1 -1 -1 -1 -1 -1 -1 -1\n-1 0 0 0 1 2 0 1\n-1 -1 -1 -1 0 1 2 3\n-1 -1 0 1 0 0 1 2\n-1 -1 -1 -1 0 1 2 3\n\n\n\n\n
\n入出力例 1 では，JOI 市は 3 × 4 個の小区画に区切られている．今の JOI 市の雲の状況は以下の通りである．図の上が北を表す．\n
\n\n![](\"https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE2_JOI2014_2015-yo-t3-fig01\")
\n\nこの後，1 分ごとに雲は以下のように移動する．\n
\n\n![](\"https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE2_JOI2014_2015-yo-t3-fig02\")
\n
![](\"https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE2_JOI2014_2015-yo-t3-fig03\")
\n
![](\"https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE2_JOI2014_2015-yo-t3-fig04\")
\n\n\n\n\n
", "c_code": "int solution(void) {\n int H;\n int W;\n scanf(\"%d %d\\n\", &H, &W);\n\n char weather;\n\n int i;\n int j;\n for (i = 0; i < H; ++i) {\n scanf(\"%c\", &weather);\n\n int out = -1;\n for (j = 1; j <= W; ++j) {\n if (weather == 'c') {\n out = 0;\n }\n\n else {\n ++out;\n\n if (out < 1) {\n out = -1;\n }\n }\n\n printf(\"%d\", out);\n\n if (j == W) {\n printf(\"\\n\");\n } else {\n printf(\" \");\n }\n\n scanf(\"%c\", &weather);\n }\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n let input = {\n let mut buf = vec![];\n stdin().read_to_end(&mut buf);\n unsafe { String::from_utf8_unchecked(buf) }\n };\n let mut lines = input.split('\\n');\n\n let (h, w) = {\n let line = lines.next().unwrap();\n let mut iter = line.split(' ').map(|s| s.parse::\n問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。\n
\nScore : 100 points
\n\n\n \n
\nProblem Statement
Shichi-Go-San (literally \"Seven-Five-Three\") is a traditional event in a certain country to celebrate the growth of seven-, five- and three-year-old children.
\nTakahashi is now X years old. Will his growth be celebrated in Shichi-Go-San this time?
\n\n\n \n
\nConstraints
- \n
- 1 ≤ X ≤ 9 \n
- X is an integer. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nX\n\n
\n\n \n
\nOutput
If Takahashi's growth will be celebrated, print YES; if it will not, print NO.
\n
\n\n \n
\nSample Input 1
5\n\n
\n\n \n
\nSample Output 1
YES\n\n
The growth of a five-year-old child will be celebrated.
\n\n
\n\n \n
\nSample Input 2
6\n\n
\n\n \n
\n", "c_code": "int solution() {\n int X = 0;\n scanf(\"%d\", &X);\n if (((X / 3 == 1) && (X % 3 == 0)) || ((X / 5 == 1) && (X % 5 == 0)) ||\n ((X / 7 == 1) && (X % 7 == 0))) {\n printf(\"YES\");\n } else {\n printf(\"NO\");\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut x = String::new();\n stdin().read_line(&mut x).unwrap();\n println!(\n \"{}\",\n match x.trim() {\n \"7\" | \"5\" | \"3\" => \"YES\",\n _ => \"NO\",\n }\n );\n}", "difficulty": "easy"}
{"problem_id": "0126", "problem_description": "Burenka and Tonya are playing an old Buryat game with a chip on a board of $$$n \\times m$$$ cells.At the beginning of the game, the chip is located in the lower left corner of the board. In one move, the player can move the chip to the right or up by any odd number of cells (but you cannot move the chip both to the right and up in one move). The one who cannot make a move loses.Burenka makes the first move, the players take turns. Burenka really wants to win the game, but she is too lazy to come up with a strategy, so you are invited to solve the difficult task of finding it. Name the winner of the game (it is believed that Burenka and Tonya are masters of playing with chips, so they always move in the optimal way). Chip's starting cell is green, the only cell from which chip can't move is red. if the chip is in the yellow cell, then blue cells are all options to move the chip in one move.", "c_code": "int solution() {\n long long int t;\n long long int i;\n scanf(\"%lld\", &t);\n int n[t];\n int m[t];\n for (i = 0; i < t; i++) {\n scanf(\"%d%d\", &n[i], &m[i]);\n if ((n[i] % 2 == 0 && m[i] % 2 == 0) || (n[i] % 2 != 0 && m[i] % 2 != 0)) {\n printf(\"Tonya\\n\");\n } else {\n printf(\"Burenka\\n\");\n }\n }\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = io::stdin();\n let mut iterator = stdin.lock().lines();\n let line = iterator.next().unwrap().unwrap();\n let amount = line.parse::Sample Output 2
NO\n\n
See you next year.
Heat Stroke
\n\n\nWe have had record hot temperatures this summer. To avoid heat stroke, you decided to buy a quantity of drinking water at the nearby supermarket. Two types of bottled water, 1 and 0.5 liter, are on sale at respective prices there. You have a definite quantity in your mind, but are willing to buy a quantity larger than that if: no combination of these bottles meets the quantity, or, the total price becomes lower.\n
\n\n Given the prices for each bottle of water and the total quantity needed, make a program to seek the lowest price to buy greater than or equal to the quantity required.\n
\n\nInput
\n\nThe input is given in the following format.\n
\n\n$A$ $B$ $X$\n\n\n
\n The first line provides the prices for a 1-liter bottle $A$ ($1\\leq A \\leq 1000$), 500-milliliter bottle $B$ ($1 \\leq B \\leq 1000$), and the total water quantity needed $X$ ($1 \\leq X \\leq 20000$). All these values are given as integers, and the quantity of water in milliliters.\n
\n\n\nOutput
\n\n Output the total price.\n
\n\n\nSample Input 1
\n\n180 100 2400\n\n\n
Sample Output 1
\n\n460\n\n\n
Sample Input 2
\n\n200 90 2018\n\n\n
Sample Output 2
\n\n450\n", "c_code": "int solution() {\n int i = 0;\n int j = 0;\n\n int A = 0;\n int B = 0;\n int X = 0;\n\n int ans = 0;\n\n int MIN = 999999;\n\n scanf(\"%d %d %d\", &A, &B, &X);\n\n for (i = 0; i <= 20000 / 1000; i++) {\n for (j = 0; j <= 20000 / 500; j++) {\n\n ans = A * i + B * j;\n if (ans < MIN && 1000 * i + 500 * j >= X) {\n MIN = ans;\n }\n }\n }\n printf(\"%d\\n\", MIN);\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = stdin();\n let line = stdin.lock().lines().next().unwrap().unwrap();\n let mut iter = line.split_whitespace().map(|s| s.parse::
Graph
\n\n\nThere are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.\n
\n\n\n An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \\in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \\in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.\n
\n\n\n An adjacency-matrix representation consists of $|V| \\times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \\in E$, $a_{ij} = 0$ otherwise.\n
\n\n\n Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.\n
\n\n\nInput
\n\n\n In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:\n
\n\n\n$u$ $k$ $v_1$ $v_2$ ... $v_k$\n
\n\n\n\n $u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.\n
\n\nOutput
\n\n\n As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.\n
\n\nConstraints
\n\n- \n
- $1 \\leq n \\leq 100$ \n
Sample Input
\n\n4\n1 2 2 4\n2 1 4\n3 0\n4 1 3\n\n\n
Sample Output
\n\n0 1 0 1\n0 0 0 1\n0 0 0 0\n0 0 1 0\n", "c_code": "int solution(void) {\n int mp[105][105] = {0};\n int n = 0;\n scanf(\"%d\", &n);\n int i = 0;\n int j = 0;\n ;\n for (i = 0; i < n; i++) {\n int u = 0;\n int k = 0;\n scanf(\"%d%d\", &u, &k);\n int p = 0;\n int m = 0;\n for (p = 0; p < k; p++) {\n scanf(\"%d\", &m);\n mp[u - 1][m - 1] = 1;\n }\n }\n for (i = 0; i < n; i++) {\n printf(\"%d\", mp[i][0]);\n for (j = 1; j < n; j++) {\n printf(\"\\x0020%d\", mp[i][j]);\n }\n printf(\"\\n\");\n }\n return 0;\n}", "rust_code": "fn solution() {\n let stdin = io::stdin();\n let lock = stdin.lock();\n let mut lines = lock.lines();\n let n = lines.next().unwrap().unwrap().parse().unwrap();\n let mut a = vec![vec![0; n]; n];\n\n for line in lines {\n let parsed: Vec
Score : 200 points
\n\n\n \n
\nProblem Statement
Takahashi has A untasty cookies containing antidotes, B tasty cookies containing antidotes and C tasty cookies containing poison.
\nEating a cookie containing poison results in a stomachache, and eating a cookie containing poison while having a stomachache results in a death.\nAs he wants to live, he cannot eat one in such a situation.\nEating a cookie containing antidotes while having a stomachache cures it, and there is no other way to cure stomachaches.
\nFind the maximum number of tasty cookies that Takahashi can eat.
\n\n\n \n
\nConstraints
- \n
- 0 \\leq A,B,C \\leq 10^9 \n
- A,B and C are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nA B C\n\n
\n\n \n
\nOutput
Print the maximum number of tasty cookies that Takahashi can eat.
\n\n
\n\n \n
\nSample Input 1
3 1 4\n\n
\n\n \n
\nSample Output 1
5\n\n
We can eat all tasty cookies, in the following order:
\n- \n
- A tasty cookie containing poison \n
- An untasty cookie containing antidotes \n
- A tasty cookie containing poison \n
- A tasty cookie containing antidotes \n
- A tasty cookie containing poison \n
- An untasty cookie containing antidotes \n
- A tasty cookie containing poison \n
\n
\n\n \n
\nSample Input 2
5 2 9\n\n
\n\n \n
\nSample Output 2
10\n\n
\n
\n\n \n
\nSample Input 3
8 8 1\n\n
\n\n \n
\n", "c_code": "int solution() {\n int A = 0;\n int B = 0;\n int C = 0;\n scanf(\"%d%d%d\", &A, &B, &C);\n if (A + B >= C) {\n printf(\"%d\", B + C);\n }\n if (A + B < C) {\n printf(\"%d\", A + (2 * B) + 1);\n }\n}", "rust_code": "fn solution() {\n let mut buf = String::new();\n std::io::stdin().read_to_string(&mut buf).ok();\n let mut it = buf.split_whitespace();\n let a = it.next().unwrap().parse::Sample Output 3
9\n
Score : 200 points
\n\n\n \n
\nProblem Statement
There are N balls placed in a row.\nAtCoDeer the deer is painting each of these in one of the K colors of his paint cans.\nFor aesthetic reasons, any two adjacent balls must be painted in different colors.
\nFind the number of the possible ways to paint the balls.
\n\n\n \n
\nConstraints
- \n
- 1≦N≦1000 \n
- 2≦K≦1000 \n
- The correct answer is at most 2^{31}-1. \n
\n
\n
\n\n\n \n
\nInput
The input is given from Standard Input in the following format:
\nN K\n\n
\n\n \n
\nOutput
Print the number of the possible ways to paint the balls.
\n\n
\n\n \n
\nSample Input 1
2 2\n\n
\n\n \n
\nSample Output 1
2\n\n
We will denote the colors by 0 and 1. There are two possible ways: we can either paint the left ball in color 0 and the right ball in color 1, or paint the left in color 1 and the right in color 0.
\n\n
\n\n \n
\nSample Input 2
1 10\n\n
\n\n \n
\n", "c_code": "int solution() {\n\n int N = 0;\n int K = 0;\n int val = 0;\n scanf(\"%d %d\", &N, &K);\n\n if (N == 1) {\n val = K;\n } else if (N == 2) {\n val = K * (K - 1);\n } else {\n val = K * pow(K - 1, N - 1);\n }\n\n printf(\"%d\", val);\n\n return 0;\n}", "rust_code": "fn solution() {\n let (n, k): (u32, u32) = {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).ok();\n let nk: VecSample Output 2
10\n\n
Since there is only one ball, we can use any of the ten colors to paint it. Thus, the answer is ten.
問題 1
\n\n\n
\n\n n 分間にわたり，\nトンネルの入口と出口で，\n1分間に通過する車の数を数えたデータがある．\nそのデータは，\n全部で n+2 行からなり，\n各行には次の内容が書かれている．\n
\n- \n
- 第1行目には，正整数 n が書かれており，\n 調査時間が n 分間であったことを表している． \n
- 第2行目には，正整数 m が書かれており，\n 調査開始時におけるトンネル内の車の台数が m であったことを表している． \n
- 第(2+i)行目（ i = 1, 2, ... , n ) には，\n 調査開始後 (i-1) 分経過した時点から i 分経過するまでの1分間に，\n 入口を通過した車の台数と出口を通過した車の台数が\n １つの空白で区切られて書かれている． \n
\n調査開始後 j 分経過した時点 ( j=0, 1, 2, ... , n ) \nにおけるトンネル内の車の台数を Sj とする．\nSj の最大値を出力しなさい．\nまた，\nトンネル内の車の台数が負になることは考えられないので，\nSj が一度でも負になった場合は，\n「エラー」の意味で 0 を出力しなさい．\nただし，\nn は 10000 以下で，\nトンネルの入口および出口を1分間に通過する車の台数は 100 以下である．\n
\n\n\n\n 出力ファイルにおいては，\n出力の最後の行にも改行コードを入れること．\n
\n\n入出力例
\n\n\n入力例１
\n\n\n3\n2\n2 3\n2 3\n4 1\n\n\n
出力例１
\n\n\n3\n\n\n
\n\n
入力例２
\n\n\n3\n2\n2 3\n2 4\n4 1\n\n\n
出力例２
\n\n\n0\n\n\n
\n\n
入力例３
\n\n3\n2\n2 3\n2 3\n1 0\n\n\n
出力例３
\n\n\n2\n\n\n\n
\n
", "c_code": "int solution() {\n int n;\n int m;\n int i;\n scanf(\"%d%d\", &n, &m);\n int MAX = m;\n int a[2][n];\n for (i = 0; i < n; i++) {\n scanf(\"%d%d\", &a[0][i], &a[1][i]);\n }\n for (i = 0; i < n; i++) {\n m = m + a[0][i] - a[1][i];\n if (m > MAX) {\n MAX = m;\n }\n if (m < 0) {\n MAX = 0;\n break;\n }\n }\n printf(\"%d\\n\", MAX);\n return 0;\n}", "rust_code": "fn solution() {\n let input = {\n let mut buf = vec![];\n stdin().read_to_end(&mut buf);\n unsafe { String::from_utf8_unchecked(buf) }\n };\n let mut lines = input.split('\\n');\n\n let n = lines.next().unwrap().parse().unwrap();\n let mut m = lines.next().unwrap().parse().unwrap();\n\n let mut max = m;\n\n for line in lines.take(n) {\n let mut iter = line.split(' ').map(|s| s.parse().unwrap());\n let (i, o) = (iter.next().unwrap(), iter.next().unwrap());\n\n let (s, err) = usize::overflowing_sub(m + i, o);\n if err {\n max = 0;\n break;\n }\n m = s;\n if max < s {\n max = s;\n }\n }\n\n println!(\"{}\", max);\n}", "difficulty": "medium"}
{"problem_id": "0134", "problem_description": "When he's not training for IOI, Little Alawn enjoys playing with puzzles of various types to stimulate his brain. Today, he's playing with a puzzle that consists of a $$$2 \\times n$$$ grid where each row is a permutation of the numbers $$$1,2,3,\\ldots,n$$$.The goal of Little Alawn's puzzle is to make sure no numbers on the same column or row are the same (we'll call this state of the puzzle as solved), and to achieve this he is able to swap the numbers in any column. However, after solving the puzzle many times, Little Alawn got bored and began wondering about the number of possible solved configurations of the puzzle he could achieve from an initial solved configuration only by swapping numbers in a column.Unfortunately, Little Alawn got stuck while trying to solve this harder problem, so he was wondering if you could help him with it. Find the answer modulo $$$10^9+7$$$.", "c_code": "int solution() {\n int t;\n scanf(\"%d\", &t);\n int i;\n int N = 200001;\n long long int MOD = 1000000007;\n long long int A[N];\n A[0] = 1;\n for (i = 1; i < N; i++) {\n A[i] = (2 * A[i - 1]) % MOD;\n }\n while (t > 0) {\n int n;\n int i;\n int j;\n int k;\n int count = 0;\n scanf(\"%d\", &n);\n int a[n];\n int b[n + 1];\n for (i = 0; i < n; i++) {\n scanf(\"%d\", &a[i]);\n }\n for (i = 0; i < n; i++) {\n j = a[i];\n scanf(\"%d\", &b[j]);\n }\n b[0] = 0;\n for (i = 0; i <= n; i++) {\n if (b[i] != 0) {\n j = i;\n k = b[j];\n while (b[k] != i) {\n b[j] = 0;\n j = k;\n k = b[k];\n }\n b[j] = b[k] = 0;\n count++;\n }\n }\n printf(\"%lld\\n\", A[count]);\n t--;\n }\n return 0;\n}", "rust_code": "fn solution() {\n let std_in = stdin();\n let in_lock = std_in.lock();\n let input = BufReader::new(in_lock);\n\n let std_out = stdout();\n let out_lock = std_out.lock();\n let mut output = BufWriter::new(out_lock);\n\n let mut lines = input.lines().map(|r| r.unwrap());\n\n let s = lines.next().unwrap();\n let mut it = s.split_whitespace().map(|s| s.parse::\n問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。\n
\nScore : 400 points
\n\n\n \n
\nProblem Statement
Joisino is planning to record N TV programs with recorders.
\nThe TV can receive C channels numbered 1 through C.
\nThe i-th program that she wants to record will be broadcast from time s_i to time t_i (including time s_i but not t_i) on Channel c_i.
\nHere, there will never be more than one program that are broadcast on the same channel at the same time.
\nWhen the recorder is recording a channel from time S to time T (including time S but not T), it cannot record other channels from time S-0.5 to time T (including time S-0.5 but not T).
\nFind the minimum number of recorders required to record the channels so that all the N programs are completely recorded.
\n\n\n \n
\nConstraints
- \n
- 1≤N≤10^5 \n
- 1≤C≤30 \n
- 1≤s_i<t_i≤10^5 \n
- 1≤c_i≤C \n
- If c_i=c_j and i≠j, either t_i≤s_j or s_i≥t_j. \n
- All input values are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN C\ns_1 t_1 c_1\n:\ns_N t_N c_N\n\n
\n\n \n
\nOutput
When the minimum required number of recorders is x, print the value of x.
\n\n
\n\n \n
\nSample Input 1
3 2\n1 7 2\n7 8 1\n8 12 1\n\n
\n\n \n
\nSample Output 1
2\n\n
Two recorders can record all the programs, for example, as follows:
\n- \n
- With the first recorder, record Channel 2 from time 1 to time 7. The first program will be recorded. Note that this recorder will be unable to record other channels from time 0.5 to time 7. \n
- With the second recorder, record Channel 1 from time 7 to time 12. The second and third programs will be recorded. Note that this recorder will be unable to record other channels from time 6.5 to time 12. \n
\n
\n\n \n
\nSample Input 2
3 4\n1 3 2\n3 4 4\n1 4 3\n\n
\n\n \n
\nSample Output 2
3\n\n
There may be a channel where there is no program to record.
\n\n
\n\n \n
\nSample Input 3
9 4\n56 60 4\n33 37 2\n89 90 3\n32 43 1\n67 68 3\n49 51 3\n31 32 3\n70 71 1\n11 12 3\n\n
\n\n \n
\n", "c_code": "int solution() {\n int n;\n int C;\n int s[100000];\n int t[100000];\n int c[100000];\n\n scanf(\"%d %d\", &n, &C);\n for (int i = 0; i < n; i++) {\n scanf(\"%d %d %d\", &s[i], &t[i], &c[i]);\n }\n int m = 100001;\n int T[31][100001];\n for (int i = 0; i < C + 1; i++) {\n for (int j = 0; j < m; j++) {\n T[i][j] = 0;\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = s[i]; j <= t[i]; j++) {\n if (T[c[i]][j] == 0) {\n T[c[i]][j] = 1;\n }\n }\n }\n int x = 0;\n for (int i = 0; i < m; i++) {\n int y = 0;\n for (int j = 0; j < C + 1; j++) {\n y = y + T[j][i];\n }\n if (x < y) {\n x = y;\n }\n }\n printf(\"%d\\n\", x);\n}", "rust_code": "fn solution() {\n let mut s: String = String::new();\n stdin().read_to_string(&mut s).ok();\n let mut itr = s.split_whitespace();\n let n: usize = itr.next().unwrap().parse().unwrap();\n let c: usize = itr.next().unwrap().parse().unwrap();\n\n let mut event = Vec::new();\n for _ in 0..n {\n let s: usize = itr.next().unwrap().parse().unwrap();\n let t: usize = itr.next().unwrap().parse().unwrap();\n let a: usize = itr.next().unwrap().parse().unwrap();\n event.push((s, 0, a));\n event.push((t, 1, a));\n }\n event.sort();\n\n let mut ans = 0;\n let mut channel = vec![0; c + 1];\n for &x in event.iter() {\n let typ = x.1;\n let chn = x.2;\n if typ == 0 {\n channel[chn] += 1;\n } else {\n channel[chn] -= 1;\n }\n\n ans = max(\n ans,\n (1..c + 1).fold(0, |acc, x| if channel[x] > 0 { acc + 1 } else { acc }),\n );\n }\n println!(\"{}\", ans);\n}", "difficulty": "medium"}
{"problem_id": "0137", "problem_description": "\nSample Output 3
2\n
Score : 100 points
\n\n\n \n
\nProblem Statement
Joisino wants to evaluate the formula \"A op B\".\nHere, A and B are integers, and the binary operator op is either + or -.\nYour task is to evaluate the formula instead of her.
\n\n \n
\nConstraints
- \n
- 1≦A,B≦10^9 \n
- op is either
+or-. \n
\n
\n
\n\n\n \n
\nInput
The input is given from Standard Input in the following format:
\nA op B\n\n
\n\n \n
\nOutput
Evaluate the formula and print the result.
\n\n
\n\n \n
\nSample Input 1
1 + 2\n\n
\n\n \n
\nSample Output 1
3\n\n
Since 1 + 2 = 3, the output should be 3.
\n\n
\n\n \n
\nSample Input 2
5 - 7\n\n
\n\n \n
\n", "c_code": "int solution() {\n int *a = malloc(sizeof(int));\n int *b = malloc(sizeof(int));\n char *op = malloc(sizeof(char));\n scanf(\"%d\", a);\n scanf(\" %c[^\"\n \"]\",\n op);\n scanf(\"%d\", b);\n if (*op == '+') {\n printf(\"%d\\n\", *a + *b);\n }\n if (*op == '-') {\n printf(\"%d\\n\", *a - *b);\n }\n free(a);\n free(b);\n free(op);\n}", "rust_code": "fn solution() {\n let mut input_line: String = String::new();\n io::stdin().read_line(&mut input_line).expect(\"err\");\n\n let inputs: Vec<&str> = input_line.split_whitespace().collect();\n\n let a: i64 = inputs[0].parse::Sample Output 2
-2\n
Score : 300 points
\n\n\n \n
\nProblem Statement
You are given two integer sequences of length N: a_1,a_2,..,a_N and b_1,b_2,..,b_N.\nDetermine if we can repeat the following operation zero or more times so that the sequences a and b become equal.
\nOperation: Choose two integers i and j (possibly the same) between 1 and N (inclusive), then perform the following two actions simultaneously:
\n- \n
- Add 2 to a_i. \n
- Add 1 to b_j. \n
\n\n \n
\nConstraints
- \n
- 1 ≤ N ≤ 10 000 \n
- 0 ≤ a_i,b_i ≤ 10^9 (1 ≤ i ≤ N) \n
- All input values are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\na_1 a_2 .. a_N\nb_1 b_2 .. b_N\n\n
\n\n \n
\nOutput
If we can repeat the operation zero or more times so that the sequences a and b become equal, print Yes; otherwise, print No.
\n
\n\n \n
\nSample Input 1
3\n1 2 3\n5 2 2\n\n
\n\n \n
\nSample Output 1
Yes\n\n
For example, we can perform three operations as follows to do our job:
\n- \n
- First operation: i=1 and j=2. Now we have a = \\{3,2,3\\}, b = \\{5,3,2\\}. \n
- Second operation: i=1 and j=2. Now we have a = \\{5,2,3\\}, b = \\{5,4,2\\}. \n
- Third operation: i=2 and j=3. Now we have a = \\{5,4,3\\}, b = \\{5,4,3\\}. \n
\n
\n\n \n
\nSample Input 2
5\n3 1 4 1 5\n2 7 1 8 2\n\n
\n\n \n
\nSample Output 2
No\n\n
\n
\n\n \n
\nSample Input 3
5\n2 7 1 8 2\n3 1 4 1 5\n\n
\n\n \n
\n", "c_code": "int solution() {\n long long N;\n scanf(\"%lld\", &N);\n long long a[N];\n long long b[N];\n long long a_sum = 0;\n long long b_sum = 0;\n long long ap = 0;\n long long bp = 0;\n for (long long i = 0; i < N; i++) {\n scanf(\"%lld\", &a[i]);\n a_sum += a[i];\n }\n for (long long i = 0; i < N; i++) {\n scanf(\"%lld\", &b[i]);\n b_sum += b[i];\n }\n long long dif = b_sum - a_sum;\n for (long long i = 0; i < N; i++) {\n if (a[i] >= b[i]) {\n bp += a[i] - b[i];\n } else {\n ap += (b[i] - a[i] + 1) / 2;\n }\n }\n if (ap <= dif && bp <= dif) {\n printf(\"Yes\\n\");\n } else {\n printf(\"No\\n\");\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut s: String = String::new();\n std::io::stdin().read_to_string(&mut s).ok();\n let mut itr = s.split_whitespace();\n\n let n: usize = itr.next().unwrap().parse().unwrap();\n let a: VecSample Output 3
No\n
Score : 100 points
\n\n\n \n
\nProblem Statement
You are given a string S as input. This represents a valid date in the year 2019 in the yyyy/mm/dd format. (For example, April 30, 2019 is represented as 2019/04/30.)
Write a program that prints Heisei if the date represented by S is not later than April 30, 2019, and prints TBD otherwise.
\n\n \n
\nConstraints
- \n
- S is a string that represents a valid date in the year 2019 in the
yyyy/mm/ddformat. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nS\n\n
\n\n \n
\nOutput
Print Heisei if the date represented by S is not later than April 30, 2019, and print TBD otherwise.
\n
\n\n \n
\nSample Input 1
2019/04/30\n\n
\n\n \n
\nSample Output 1
Heisei\n\n
\n
\n\n \n
\nSample Input 2
2019/11/01\n\n
\n\n \n
\n", "c_code": "int solution() {\n char str[12];\n\n scanf(\"%s\", str);\n\n if (str[5] == '0' && str[6] <= '4' &&\n ((str[8] < '3') || (str[8] == '3' && str[9] == '0'))) {\n\n printf(\"Heisei\");\n }\n\n else {\n printf(\"TBD\");\n }\n}", "rust_code": "fn solution() {\n let mut s = String::new();\n stdin().read_line(&mut s).unwrap();\n let s: VecSample Output 2
TBD\n
Score : 100 points
\n\n\n \n
\nProblem Statement
Dolphin loves programming contests. Today, he will take part in a contest in AtCoder.
\nIn this country, 24-hour clock is used. For example, 9:00 p.m. is referred to as \"21 o'clock\".
\nThe current time is A o'clock, and a contest will begin in exactly B hours.\nWhen will the contest begin? Answer in 24-hour time.
\n\n \n
\nConstraints
- \n
- 0 \\leq A,B \\leq 23 \n
- A and B are integers. \n
\n
\n
\n\n\n \n
\nInput
The input is given from Standard Input in the following format:
\nA B\n\n
\n\n \n
\nOutput
Print the hour of the starting time of the contest in 24-hour time.
\n\n
\n\n \n
\nSample Input 1
9 12\n\n
\n\n \n
\nSample Output 1
21\n\n
In this input, the current time is 9 o'clock, and 12 hours later it will be 21 o'clock in 24-hour time.
\n\n
\n\n \n
\nSample Input 2
19 0\n\n
\n\n \n
\nSample Output 2
19\n\n
The contest has just started.
\n\n
\n\n \n
\nSample Input 3
23 2\n\n
\n\n \n
\n", "c_code": "int solution() {\n\n int sum = 0;\n int a = 0;\n int b = 0;\n scanf(\"%d %d\", &a, &b);\n sum = a + b;\n if (sum > 23) {\n printf(\"%d\", sum - 24);\n } else {\n printf(\"%d\", sum);\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut line = String::new();\n std::io::stdin()\n .read_line(&mut line)\n .expect(\"faild to read line\");\n let mut sum: u64 = 0;\n for elem in line.split_whitespace() {\n sum += elem.trim().parse::Sample Output 3
1\n\n
The contest will begin at 1 o'clock the next day.
Score: 200 points
\n\n\n \n
\nProblem Statement
\nM-kun has the following three cards:
\n- \n
- A red card with the integer A. \n
- A green card with the integer B. \n
- A blue card with the integer C. \n
He is a genius magician who can do the following operation at most K times:
\n- \n
- Choose one of the three cards and multiply the written integer by 2. \n
His magic is successful if both of the following conditions are satisfied after the operations:
\n- \n
- The integer on the green card is strictly greater than the integer on the red card. \n
- The integer on the blue card is strictly greater than the integer on the green card. \n
Determine whether the magic can be successful.
\n\n\n \n
\nConstraints
\n- \n
- 1 \\leq A, B, C \\leq 7 \n
- 1 \\leq K \\leq 7 \n
- All values in input are integers. \n
\n
\n
\n\n\n \n
\nInput
\nInput is given from Standard Input in the following format:
\nA B C\nK\n\n
\n\n \n
\nOutput
\nIf the magic can be successful, print Yes; otherwise, print No.
\n
\n\n \n
\nSample Input 1
7 2 5\n3\n\n
\n\n \n
\nSample Output 1
Yes\n\n
The magic will be successful if, for example, he does the following operations:
\n- \n
- First, choose the blue card. The integers on the red, green, and blue cards are now 7, 2, and 10, respectively. \n
- Second, choose the green card. The integers on the red, green, and blue cards are now 7, 4, and 10, respectively. \n
- Third, choose the green card. The integers on the red, green, and blue cards are now 7, 8, and 10, respectively. \n
\n
\n\n \n
\nSample Input 2
7 4 2\n3\n\n
\n\n \n
\n", "c_code": "int solution() {\n int a[3];\n int k;\n scanf(\"%d%d%d\", &a[0], &a[1], &a[2]);\n scanf(\"%d\", &k);\n for (int i = 0; i < k; i++) {\n if (a[0] >= a[1]) {\n a[1] = a[1] * 2;\n } else {\n a[2] = a[2] * 2;\n }\n }\n if (a[0] < a[1] && a[1] < a[2]) {\n printf(\"Yes\\n\");\n } else {\n printf(\"No\\n\");\n }\n return 0;\n}", "rust_code": "fn solution() {\n let (a, mut b, mut c): (usize, usize, usize) = {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n let mut iter = buf.split_whitespace();\n (\n iter.next().unwrap().parse().unwrap(),\n iter.next().unwrap().parse().unwrap(),\n iter.next().unwrap().parse().unwrap(),\n )\n };\n let k: usize = {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n buf.trim_end().parse().unwrap()\n };\n\n let mut count = 0;\n while a >= b {\n b *= 2;\n count += 1;\n }\n while b >= c {\n c *= 2;\n count += 1;\n }\n\n if count <= k {\n println!(\"Yes\");\n } else {\n println!(\"No\");\n }\n}", "difficulty": "easy"}
{"problem_id": "0145", "problem_description": "Little C loves number «3» very much. He loves all things about it.Now he has a positive integer $$$n$$$. He wants to split $$$n$$$ into $$$3$$$ positive integers $$$a,b,c$$$, such that $$$a+b+c=n$$$ and none of the $$$3$$$ integers is a multiple of $$$3$$$. Help him to find a solution.", "c_code": "int solution(void) {\n int n;\n scanf(\"%d\", &n);\n int p = n / 3;\n if (p % 3 != 0 && (n - (2 * p)) % 3 != 0) {\n printf(\"%d %d %d\", p, p, (n - (2 * p)));\n } else if (n % 3 == 0) {\n printf(\"%d %d %d\", p + 1, p + 1, p - 2);\n } else if (p % 3 != 0 && (n - 2 * p) % 3 == 0) {\n if (p % 3 == 1) {\n printf(\"%d %d %d\", p + 1, p + 1, (n - 2 * p) - 2);\n } else {\n printf(\"%d %d %d\", p - 1, p - 1, (n - 2 * p) + 2);\n }\n } else if (p % 3 == 0 && (n - 2 * p) != 0) {\n printf(\"%d %d %d\", p - 1, p + 1, n - (2 * p));\n }\n return 0;\n}", "rust_code": "fn solution() {\n let mut buffer = String::new();\n let stdin = io::stdin();\n let mut handle = stdin.lock();\n handle.read_to_string(&mut buffer).unwrap();\n\n let arr: Vec<_> = buffer\n .split_whitespace()\n .map(|x| x.parse::Sample Output 2
No\n\n
He has no way to succeed in the magic with at most three operations.
Score : 100 points
\n\n\n \n
\nProblem Statement
You are given two integers a and b.\nDetermine if a+b=15 or a\\times b=15 or neither holds.
\nNote that a+b=15 and a\\times b=15 do not hold at the same time.
\n\n\n \n
\nConstraints
- \n
- 1 \\leq a,b \\leq 15 \n
- All values in input are integers. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\na b\n\n
\n\n \n
\nOutput
If a+b=15, print +;\nif a\\times b=15, print *;\nif neither holds, print x.
\n
\n\n \n
\nSample Input 1
4 11\n\n
\n\n \n
\nSample Output 1
+\n\n
4+11=15.
\n\n
\n\n \n
\nSample Input 2
3 5\n\n
\n\n \n
\nSample Output 2
*\n\n
3\\times 5=15.
\n\n
\n\n \n
\nSample Input 3
1 1\n\n
\n\n \n
\n", "c_code": "int solution(void) {\n int a = 0;\n int b = 0;\n\n scanf(\"%d %d\", &a, &b);\n\n if (a + b == 15) {\n printf(\"+\\n\");\n } else if (a * b == 15) {\n printf(\"*\\n\");\n } else {\n printf(\"x\\n\");\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut ab = String::new();\n std::io::stdin().read_line(&mut ab).ok();\n let mut it = ab.split_whitespace().map(|n| usize::from_str(n).unwrap());\n let (a, b) = (it.next().unwrap(), it.next().unwrap());\n if a + b == 15 {\n println!(\"+\");\n } else if a * b == 15 {\n println!(\"*\");\n } else {\n println!(\"x\");\n }\n}", "difficulty": "easy"}
{"problem_id": "0147", "problem_description": "\n\n\nSample Output 3
x\n\n
1+1=2 and 1\\times 1=1, neither of which is 15.
Ring
\n\n
\n Write a program which finds a pattern $p$ in a ring shaped text $s$.\n
\n\n\n\n
![](\"https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE2_ITP1_8_D\")
\n\n\n
Input
\n\n In the first line, the text $s$ is given.
\n In the second line, the pattern $p$ is given.\n
Output
\n\n\n If $p$ is in $s$, print Yes in a line, otherwise No.\n
\n\nConstraints
\n\n- \n
- $1 \\leq $ length of $p \\leq $ length of $s \\leq 100$ \n
- $s$ and $p$ consists of lower-case letters \n
Sample Input 1
\n\nvanceknowledgetoad\nadvance\n\n\n
Sample Output 1
\n\n\nYes\n\n
\n
Sample Input 2
\n\nvanceknowledgetoad\nadvanced\n\n\n
Sample Output 2
\n\nNo\n", "c_code": "int solution() {\n char a[105];\n char b[105];\n int i = 0;\n int j = 0;\n do {\n scanf(\"%c\", &a[i++]);\n } while (a[i - 1] != '\\n');\n\n do {\n scanf(\"%c\", &b[j++]);\n } while (b[j - 1] != '\\n');\n\n i--;\n j--;\n\n int flag = 0;\n for (int k = 0; k < i; k++) {\n if (a[k] == b[0]) {\n flag = 0;\n for (int p = k, q = 0; q < j; p++, q++) {\n if (p == i) {\n p = 0;\n }\n if (a[p] != b[q]) {\n flag = 1;\n\n break;\n }\n }\n if (flag == 0) {\n printf(\"Yes\\n\");\n return 0;\n }\n }\n }\n printf(\"No\\n\");\n}", "rust_code": "fn solution() {\n let scan = std::io::stdin();\n\n let mut line = String::new();\n let _ = scan.read_line(&mut line);\n\n let mut line2 = String::new();\n let _ = scan.read_line(&mut line2);\n\n let s = [line.trim(), line.trim()].concat();\n\n if !s.contains(line2.trim()) {\n println!(\"No\");\n } else {\n println!(\"Yes\");\n }\n}", "difficulty": "medium"} {"problem_id": "0148", "problem_description": "The grasshopper is located on the numeric axis at the point with coordinate $$$x_0$$$.Having nothing else to do he starts jumping between integer points on the axis. Making a jump from a point with coordinate $$$x$$$ with a distance $$$d$$$ to the left moves the grasshopper to a point with a coordinate $$$x - d$$$, while jumping to the right moves him to a point with a coordinate $$$x + d$$$.The grasshopper is very fond of positive integers, so for each integer $$$i$$$ starting with $$$1$$$ the following holds: exactly $$$i$$$ minutes after the start he makes a jump with a distance of exactly $$$i$$$. So, in the first minutes he jumps by $$$1$$$, then by $$$2$$$, and so on.The direction of a jump is determined as follows: if the point where the grasshopper was before the jump has an even coordinate, the grasshopper jumps to the left, otherwise he jumps to the right.For example, if after $$$18$$$ consecutive jumps he arrives at the point with a coordinate $$$7$$$, he will jump by a distance of $$$19$$$ to the right, since $$$7$$$ is an odd number, and will end up at a point $$$7 + 19 = 26$$$. Since $$$26$$$ is an even number, the next jump the grasshopper will make to the left by a distance of $$$20$$$, and it will move him to the point $$$26 - 20 = 6$$$.Find exactly which point the grasshopper will be at after exactly $$$n$$$ jumps.", "c_code": "int solution() {\n int testcase;\n scanf(\"%d\", &testcase);\n\n while (testcase--) {\n long long x;\n long long n;\n scanf(\"%lld%lld\", &x, &n);\n\n long long remainder = n % 4;\n long long cycle = (n / 4) + 1;\n if (x % 2 == 0) {\n switch (remainder) {\n case 0:\n x = x;\n break;\n case 1:\n x = x - n;\n break;\n case 2:\n x = x + 1;\n break;\n case 3:\n x = x + 4 * cycle;\n break;\n }\n } else {\n switch (remainder) {\n case 0:\n x = x;\n break;\n case 1:\n x = x + n;\n break;\n case 2:\n x = x - 1;\n break;\n case 3:\n x = x - 4 * cycle;\n break;\n }\n }\n\n printf(\"%lld\\n\", x);\n }\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut line = String::new();\n io::stdin().read_line(&mut line).unwrap();\n for _ in 0..(line.trim().parse().unwrap()) {\n line.clear();\n io::stdin().read_line(&mut line).unwrap();\n let nums: Vec
Score : 600 points
\n\n\n \n
\nProblem Statement
We have a sequence of length N consisting of non-negative integers. Consider performing the following operation on this sequence until the largest element in this sequence becomes N-1 or smaller.
\n- \n
- Determine the largest element in the sequence (if there is more than one, choose one). Decrease the value of this element by N, and increase each of the other elements by 1. \n
It can be proved that the largest element in the sequence becomes N-1 or smaller after a finite number of operations.
\nYou are given an integer K. Find an integer sequence a_i such that the number of times we will perform the above operation is exactly K. It can be shown that there is always such a sequence under the constraints on input and output in this problem.
\n\n\n \n
\nConstraints
- \n
- 0 ≤ K ≤ 50 \\times 10^{16} \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nK\n\n
\n\n \n
\nOutput
Print a solution in the following format:
\nN\na_1 a_2 ... a_N\n\n
Here, 2 ≤ N ≤ 50 and 0 ≤ a_i ≤ 10^{16} + 1000 must hold.
\n\n
\n\n \n
\nSample Input 1
0\n\n
\n\n \n
\nSample Output 1
4\n3 3 3 3\n\n
\n
\n\n \n
\nSample Input 2
1\n\n
\n\n \n
\nSample Output 2
3\n1 0 3\n\n
\n
\n\n \n
\nSample Input 3
2\n\n
\n\n \n
\nSample Output 3
2\n2 2\n\n
The operation will be performed twice: [2, 2] -> [0, 3] -> [1, 1].
\n\n
\n\n \n
\nSample Input 4
3\n\n
\n\n \n
\nSample Output 4
7\n27 0 0 0 0 0 0\n\n
\n
\n\n \n
\nSample Input 5
1234567894848\n\n
\n\n \n
\n", "c_code": "int solution() {\n long long n;\n long long a;\n long long i;\n scanf(\"%lld\", &n);\n a = n / 50;\n printf(\"50\\n\");\n if (a == 0) {\n for (i = 0; i < 50; i++) {\n if (i) {\n printf(\" \");\n }\n if (i < n) {\n printf(\"50\");\n } else {\n printf(\"0\");\n }\n }\n } else {\n for (i = 0; i < 50; i++) {\n if (i) {\n printf(\" \");\n }\n if (i < n % 50) {\n printf(\"%lld\", a + 50);\n } else {\n printf(\"%lld\", a + 49 - (n % 50));\n }\n }\n }\n printf(\"\\n\");\n return 0;\n}", "rust_code": "fn solution() {\n input!(k: usize);\n let n = 50;\n let mut b = vec![k / n; n];\n for i in 0..(k % n) {\n b[i] += 1;\n }\n\n assert_eq!(b.iter().sum::Sample Output 5
10\n1000 193 256 777 0 1 1192 1234567891011 48 425\n
Score: 300 points
\n\n\n \n
\nProblem Statement
\nIn 2028 and after a continuous growth, AtCoder Inc. finally built an empire with six cities (City 1, 2, 3, 4, 5, 6)!
\nThere are five means of transport in this empire:
\n- \n
- Train: travels from City 1 to 2 in one minute. A train can occupy at most A people. \n
- Bus: travels from City 2 to 3 in one minute. A bus can occupy at most B people. \n
- Taxi: travels from City 3 to 4 in one minute. A taxi can occupy at most C people. \n
- Airplane: travels from City 4 to 5 in one minute. An airplane can occupy at most D people. \n
- Ship: travels from City 5 to 6 in one minute. A ship can occupy at most E people. \n
For each of them, one vehicle leaves the city at each integer time (time 0, 1, 2, ...).
\nThere is a group of N people at City 1, and they all want to go to City 6.
\nAt least how long does it take for all of them to reach there? \nYou can ignore the time needed to transfer.
\n\n \n
\nConstraints
\n- \n
- 1 \\leq N, A, B, C, D, E \\leq 10^{15} \n
- All values in input are integers. \n
\n
\n
\n\n\n \n
\nInput
\nInput is given from Standard Input in the following format:
\nN\nA\nB\nC\nD\nE\n\n
\n\n \n
\nOutput
\nPrint the minimum time required for all of the people to reach City 6, in minutes.
\n\n
\n\n \n
\nSample Input 1
5\n3\n2\n4\n3\n5\n\n
\n\n \n
\nSample Output 1
7\n\n
One possible way to travel is as follows.\nFirst, there are N = 5 people at City 1, as shown in the following image:
\n![\"](\"https://img.atcoder.jp/ghi/9c306138eddc8a2e08acfa5da19bdfe8.png\"/)
In the first minute, three people travels from City 1 to City 2 by train. Note that a train can only occupy at most three people.
\n![\"](\"https://img.atcoder.jp/ghi/bd30b5ab37fc06951c9f5256bb974e4f.png\"/)
In the second minute, the remaining two people travels from City 1 to City 2 by train, and two of the three people who were already at City 2 travels to City 3 by bus. Note that a bus can only occupy at most two people.
\n![\"](\"https://img.atcoder.jp/ghi/50f2e49a770a30193fc53588ec8475b3.png\"/)
In the third minute, two people travels from City 2 to City 3 by train, and another two people travels from City 3 to City 4 by taxi.
\n![\"](\"https://img.atcoder.jp/ghi/d6d80dc50abe58190905c8c5ea6ba345.png\"/)
From then on, if they continue traveling without stopping until they reach City 6, all of them can reach there in seven minutes.
\nThere is no way for them to reach City 6 in 6 minutes or less.
\n
\n\n \n
\nSample Input 2
10\n123\n123\n123\n123\n123\n\n
\n\n \n
\nSample Output 2
5\n\n
All kinds of vehicles can occupy N = 10 people at a time.\nThus, if they continue traveling without stopping until they reach City 6, all of them can reach there in five minutes.
\n\n
\n\n \n
\nSample Input 3
10000000007\n2\n3\n5\n7\n11\n\n
\n\n \n
\n", "c_code": "int solution() {\n long long int n;\n long long int vehicle[5];\n scanf(\"%lld %lld %lld %lld %lld %lld\", &n, &vehicle[0], &vehicle[1],\n &vehicle[2], &vehicle[3], &vehicle[4]);\n long long int min = LLONG_MAX;\n for (int i = 0; i < 5; i++) {\n if (min > vehicle[i]) {\n min = vehicle[i];\n }\n }\n printf(\"%lld\", ((n + (min - 1)) / min) + 4);\n\n return 0;\n}", "rust_code": "fn solution() {\n let mut s: String = String::new();\n std::io::stdin().read_to_string(&mut s).ok();\n let mut itr = s.split_whitespace();\n let n: usize = itr.next().unwrap().parse().unwrap();\n let mut a: VecSample Output 3
5000000008\n\n
Note that the input or output may not fit into a 32-bit integer type.
Score : 200 points
\n\n\n \n
\nProblem Statement
Takahashi is practicing shiritori alone again today.
\nShiritori is a game as follows:
\n- \n
- In the first turn, a player announces any one word. \n
- In the subsequent turns, a player announces a word that satisfies the following conditions:
- \n
- That word is not announced before. \n
- The first character of that word is the same as the last character of the last word announced. \n
\n
In this game, he is practicing to announce as many words as possible in ten seconds.
\nYou are given the number of words Takahashi announced, N, and the i-th word he announced, W_i, for each i. Determine if the rules of shiritori was observed, that is, every word announced by him satisfied the conditions.
\n\n\n \n
\nConstraints
- \n
- N is an integer satisfying 2 \\leq N \\leq 100. \n
- W_i is a string of length between 1 and 10 (inclusive) consisting of lowercase English letters. \n
\n
\n
\n\n\n \n
\nInput
Input is given from Standard Input in the following format:
\nN\nW_1\nW_2\n:\nW_N\n\n
\n\n \n
\nOutput
If every word announced by Takahashi satisfied the conditions, print Yes; otherwise, print No.
\n
\n\n \n
\nSample Input 1
4\nhoge\nenglish\nhoge\nenigma\n\n
\n\n \n
\nSample Output 1
No\n\n
As hoge is announced multiple times, the rules of shiritori was not observed.
\n
\n\n \n
\nSample Input 2
9\nbasic\nc\ncpp\nphp\npython\nnadesico\nocaml\nlua\nassembly\n\n
\n\n \n
\nSample Output 2
Yes\n\n
\n
\n\n \n
\nSample Input 3
8\na\naa\naaa\naaaa\naaaaa\naaaaaa\naaa\naaaaaaa\n\n
\n\n \n
\nSample Output 3
No\n\n
\n
\n\n \n
\nSample Input 4
3\nabc\narc\nagc\n\n
\n\n \n
\n", "c_code": "int solution() {\n int n = 0;\n scanf(\"%d\\n\", &n);\n char s[n][12];\n for (int i = 0; i < n; i++) {\n fgets(s[i], 12, stdin);\n int length = strlen(s[i]);\n s[i][length - 1] = '\\0';\n if (i == 0) {\n continue;\n }\n if (s[i][0] != s[i - 1][strlen(s[i - 1]) - 1]) {\n printf(\"No\\n\");\n return 0;\n }\n for (int j = 0; j < i; j++) {\n if (!strcmp(s[i], s[j])) {\n printf(\"No\\n\");\n return 0;\n }\n }\n }\n printf(\"Yes\\n\");\n return 0;\n}", "rust_code": "fn solution() {\n let mut n = String::new();\n std::io::stdin().read_line(&mut n).unwrap();\n let n: usize = n.trim().parse().unwrap();\n let mut p = std::collections::HashSet::Sample Output 4
No\n
Score : 700 points
\n\n\n \n
\nProblem Statement
Nuske has a grid with N rows and M columns of squares. The rows are numbered 1 through N from top to bottom, and the columns are numbered 1 through M from left to right.\nEach square in the grid is painted in either blue or white. If S_{i,j} is 1, the square at the i-th row and j-th column is blue; if S_{i,j} is 0, the square is white.\nFor every pair of two blue square a and b, there is at most one path that starts from a, repeatedly proceeds to an adjacent (side by side) blue square and finally reaches b, without traversing the same square more than once.
\nPhantom Thnook, Nuske's eternal rival, gives Q queries to Nuske. The i-th query consists of four integers x_{i,1}, y_{i,1}, x_{i,2} and y_{i,2} and asks him the following: when the rectangular region of the grid bounded by (and including) the x_{i,1}-th row, x_{i,2}-th row, y_{i,1}-th column and y_{i,2}-th column is cut out, how many connected components consisting of blue squares there are in the region?
\nProcess all the queries.
\n\n\n \n
\nConstraints
- \n
- 1 ≤ N,M ≤ 2000 \n
- 1 ≤ Q ≤ 200000 \n
- S_{i,j} is either 0 or 1. \n
- S_{i,j} satisfies the condition explained in the statement. \n
- 1 ≤ x_{i,1} ≤ x_{i,2} ≤ N(1 ≤ i ≤ Q) \n
- 1 ≤ y_{i,1} ≤ y_{i,2} ≤ M(1 ≤ i ≤ Q) \n
\n
\n
\n\n\n \n
\nInput
The input is given from Standard Input in the following format:
\nN M Q\nS_{1,1}..S_{1,M}\n:\nS_{N,1}..S_{N,M}\nx_{1,1} y_{i,1} x_{i,2} y_{i,2}\n:\nx_{Q,1} y_{Q,1} x_{Q,2} y_{Q,2}\n\n\n\n \n
\nOutput
For each query, print the number of the connected components consisting of blue squares in the region.
\n\n
\n\n \n
\nSample Input 1
3 4 4\n1101\n0110\n1101\n1 1 3 4\n1 1 3 1\n2 2 3 4\n1 2 2 4\n\n
\n\n \n
\nSample Output 1
3\n2\n2\n2\n\n
![\"\"](\"https://atcoder.jp/img/agc015/7aa4a2252f50a19fc18e0cec01368a2a.png\"/)
In the first query, the whole grid is specified. There are three components consisting of blue squares, and thus 3 should be printed.
\nIn the second query, the region within the red frame is specified. There are two components consisting of blue squares, and thus 2 should be printed.\nNote that squares that belong to the same component in the original grid may belong to different components.
\n\n
\n\n \n
\nSample Input 2
5 5 6\n11010\n01110\n10101\n11101\n01010\n1 1 5 5\n1 2 4 5\n2 3 3 4\n3 3 3 3\n3 1 3 5\n1 1 3 4\n\n
\n\n \n
\n", "c_code": "int solution() {\n int i;\n int j;\n int N;\n int M;\n int Q;\n char S[2002][2002] = {};\n scanf(\"%d %d %d\", &N, &M, &Q);\n for (i = 1; i <= N; i++) {\n scanf(\"%s\", &(S[i][1]));\n }\n\n short q[4000001][2];\n short par[2002][2002][2] = {};\n int k;\n int l;\n int head;\n int tail;\n for (i = 1; i <= N; i++) {\n for (j = 1; j <= M; j++) {\n if (S[i][j] == '0' || par[i][j][0] != 0) {\n continue;\n }\n par[i][j][0] = i;\n par[i][j][1] = j;\n q[0][0] = i;\n q[0][1] = j;\n for (head = 0, tail = 1; head < tail; head++) {\n k = q[head][0];\n l = q[head][1];\n if (S[k - 1][l] == '1' && par[k - 1][l][0] == 0) {\n par[k - 1][l][0] = k;\n par[k - 1][l][1] = l;\n q[tail][0] = k - 1;\n q[tail++][1] = l;\n }\n if (S[k + 1][l] == '1' && par[k + 1][l][0] == 0) {\n par[k + 1][l][0] = k;\n par[k + 1][l][1] = l;\n q[tail][0] = k + 1;\n q[tail++][1] = l;\n }\n if (S[k][l - 1] == '1' && par[k][l - 1][0] == 0) {\n par[k][l - 1][0] = k;\n par[k][l - 1][1] = l;\n q[tail][0] = k;\n q[tail++][1] = l - 1;\n }\n if (S[k][l + 1] == '1' && par[k][l + 1][0] == 0) {\n par[k][l + 1][0] = k;\n par[k][l + 1][1] = l;\n q[tail][0] = k;\n q[tail++][1] = l + 1;\n }\n }\n }\n }\n\n int root[2002][2002];\n int up[2002][2002];\n int down[2002][2002];\n int left[2002][2002];\n int right[2002][2002];\n for (j = 1, root[0][0] = 0; j <= M; j++) {\n root[0][j] = 0;\n for (i = 1, left[0][j] = 0, right[0][j] = 0; i <= N; i++) {\n left[i][j] =\n left[i - 1][j] + ((S[i][j] == '1' && par[i][j][1] == j - 1) ? 1 : 0);\n right[i][j] =\n right[i - 1][j] + ((S[i][j] == '1' && par[i][j][1] == j + 1) ? 1 : 0);\n }\n }\n for (i = 1; i <= N; i++) {\n root[i][0] = 0;\n for (j = 1, up[i][0] = 0, down[i][0] = 0; j <= M; j++) {\n root[i][j] = root[i - 1][j] + root[i][j - 1] - root[i - 1][j - 1] +\n ((par[i][j][0] == i && par[i][j][1] == j) ? 1 : 0);\n up[i][j] =\n up[i][j - 1] + ((S[i][j] == '1' && par[i][j][0] == i - 1) ? 1 : 0);\n down[i][j] =\n down[i][j - 1] + ((S[i][j] == '1' && par[i][j][0] == i + 1) ? 1 : 0);\n }\n }\n\n int m;\n int n;\n for (n = 1; n <= Q; n++) {\n scanf(\"%d %d %d %d\", &i, &j, &k, &l);\n printf(\"%d\\n\", root[k][l] - root[i - 1][l] - root[k][j - 1] +\n root[i - 1][j - 1] + up[i][l] - up[i][j - 1] +\n down[k][l] - down[k][j - 1] + left[k][j] -\n left[i - 1][j] + right[k][l] - right[i - 1][l]);\n }\n\n fflush(stdout);\n return 0;\n}", "rust_code": "fn solution() {\n let mut stdin = io::stdin();\n let mut lines_str = String::new();\n let _ = stdin.read_to_string(&mut lines_str);\n let mut lines = lines_str.lines();\n let mut line0itr = lines.next().expect(\"\").split_whitespace();\n let n: usize = line0itr.next().expect(\"\").trim().parse().unwrap();\n let m: usize = line0itr.next().expect(\"\").trim().parse().unwrap();\n let q: usize = line0itr.next().expect(\"\").trim().parse().unwrap();\n\n let mut dots: VecSample Output 2
3\n2\n1\n1\n3\n2\n