message stringlengths 2 59.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 37 108k | cluster float64 20 20 | __index_level_0__ int64 74 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a large electronic screen which can display up to 998244353 decimal digits. The digits are displayed in the same way as on different electronic alarm clocks: each place for a digit consists of 7 segments which can be turned on and off to compose different digits. The following picture describes how you can display all 10 decimal digits:
<image>
As you can see, different digits may require different number of segments to be turned on. For example, if you want to display 1, you have to turn on 2 segments of the screen, and if you want to display 8, all 7 segments of some place to display a digit should be turned on.
You want to display a really large integer on the screen. Unfortunately, the screen is bugged: no more than n segments can be turned on simultaneously. So now you wonder what is the greatest integer that can be displayed by turning on no more than n segments.
Your program should be able to process t different test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow, each of them is represented by a separate line containing one integer n (2 ≤ n ≤ 10^5) — the maximum number of segments that can be turned on in the corresponding testcase.
It is guaranteed that the sum of n over all test cases in the input does not exceed 10^5.
Output
For each test case, print the greatest integer that can be displayed by turning on no more than n segments of the screen. Note that the answer may not fit in the standard 32-bit or 64-bit integral data type.
Example
Input
2
3
4
Output
7
11
Submitted Solution:
```
T = int(input())
inputs=[]
while(T!=0):
n = int(input())
inputs.append(n)
T-=1
def largestnumber(n):
digits = []
left = n
while left>1:
if left%2!=0:
digits.append('7')
left=left-3
else:
digits.append('1')
left = left - 2
print(''.join(digits))
def main():
if 1<=len(inputs)<=100:
for x in inputs:
if 2<=x<=10**5:
largestnumber(x)
main()
``` | instruction | 0 | 21,306 | 20 | 42,612 |
Yes | output | 1 | 21,306 | 20 | 42,613 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a large electronic screen which can display up to 998244353 decimal digits. The digits are displayed in the same way as on different electronic alarm clocks: each place for a digit consists of 7 segments which can be turned on and off to compose different digits. The following picture describes how you can display all 10 decimal digits:
<image>
As you can see, different digits may require different number of segments to be turned on. For example, if you want to display 1, you have to turn on 2 segments of the screen, and if you want to display 8, all 7 segments of some place to display a digit should be turned on.
You want to display a really large integer on the screen. Unfortunately, the screen is bugged: no more than n segments can be turned on simultaneously. So now you wonder what is the greatest integer that can be displayed by turning on no more than n segments.
Your program should be able to process t different test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow, each of them is represented by a separate line containing one integer n (2 ≤ n ≤ 10^5) — the maximum number of segments that can be turned on in the corresponding testcase.
It is guaranteed that the sum of n over all test cases in the input does not exceed 10^5.
Output
For each test case, print the greatest integer that can be displayed by turning on no more than n segments of the screen. Note that the answer may not fit in the standard 32-bit or 64-bit integral data type.
Example
Input
2
3
4
Output
7
11
Submitted Solution:
```
from sys import stdin
import math
def inp():
return stdin.readline().strip()
t = int(inp())
for _ in range(t):
n = int(inp())
if n < 2:
print("0")
elif n == 3:
print("7")
else:
k = n//2
if n%2 == 1:
ar = [7]
ar.extend([1]*(k-1))
print("".join(map(str, ar)))
else:
ar = [1]*k
print("".join(map(str, ar)))
``` | instruction | 0 | 21,307 | 20 | 42,614 |
Yes | output | 1 | 21,307 | 20 | 42,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a large electronic screen which can display up to 998244353 decimal digits. The digits are displayed in the same way as on different electronic alarm clocks: each place for a digit consists of 7 segments which can be turned on and off to compose different digits. The following picture describes how you can display all 10 decimal digits:
<image>
As you can see, different digits may require different number of segments to be turned on. For example, if you want to display 1, you have to turn on 2 segments of the screen, and if you want to display 8, all 7 segments of some place to display a digit should be turned on.
You want to display a really large integer on the screen. Unfortunately, the screen is bugged: no more than n segments can be turned on simultaneously. So now you wonder what is the greatest integer that can be displayed by turning on no more than n segments.
Your program should be able to process t different test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow, each of them is represented by a separate line containing one integer n (2 ≤ n ≤ 10^5) — the maximum number of segments that can be turned on in the corresponding testcase.
It is guaranteed that the sum of n over all test cases in the input does not exceed 10^5.
Output
For each test case, print the greatest integer that can be displayed by turning on no more than n segments of the screen. Note that the answer may not fit in the standard 32-bit or 64-bit integral data type.
Example
Input
2
3
4
Output
7
11
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
if(n%2==0):
print('1'*(n//2))
else:
print('7'+'1'*(n//2-1))
``` | instruction | 0 | 21,308 | 20 | 42,616 |
Yes | output | 1 | 21,308 | 20 | 42,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a large electronic screen which can display up to 998244353 decimal digits. The digits are displayed in the same way as on different electronic alarm clocks: each place for a digit consists of 7 segments which can be turned on and off to compose different digits. The following picture describes how you can display all 10 decimal digits:
<image>
As you can see, different digits may require different number of segments to be turned on. For example, if you want to display 1, you have to turn on 2 segments of the screen, and if you want to display 8, all 7 segments of some place to display a digit should be turned on.
You want to display a really large integer on the screen. Unfortunately, the screen is bugged: no more than n segments can be turned on simultaneously. So now you wonder what is the greatest integer that can be displayed by turning on no more than n segments.
Your program should be able to process t different test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow, each of them is represented by a separate line containing one integer n (2 ≤ n ≤ 10^5) — the maximum number of segments that can be turned on in the corresponding testcase.
It is guaranteed that the sum of n over all test cases in the input does not exceed 10^5.
Output
For each test case, print the greatest integer that can be displayed by turning on no more than n segments of the screen. Note that the answer may not fit in the standard 32-bit or 64-bit integral data type.
Example
Input
2
3
4
Output
7
11
Submitted Solution:
```
q = int ( input ( ) )
for i in range ( q ) :
#arr = [ ]
a = int ( input ( ) )
if a == 2 :
print ( '1' )
elif a == 3 :
print ( '7' )
else :
arr = [ ]
while a > 0 :
if a == 0 :
continue
elif a > 3 :
a -= 2
arr += [1]
elif a == 2 :
a = 0
arr += [1]
else :
a = 0
arr += [7]
arr . sort ( )
arr = arr [ :: -1 ]
for j in range ( len ( arr ) ) :
print ( arr [ j ] , end='' )
arr = [ ]
print ( )
``` | instruction | 0 | 21,309 | 20 | 42,618 |
Yes | output | 1 | 21,309 | 20 | 42,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a large electronic screen which can display up to 998244353 decimal digits. The digits are displayed in the same way as on different electronic alarm clocks: each place for a digit consists of 7 segments which can be turned on and off to compose different digits. The following picture describes how you can display all 10 decimal digits:
<image>
As you can see, different digits may require different number of segments to be turned on. For example, if you want to display 1, you have to turn on 2 segments of the screen, and if you want to display 8, all 7 segments of some place to display a digit should be turned on.
You want to display a really large integer on the screen. Unfortunately, the screen is bugged: no more than n segments can be turned on simultaneously. So now you wonder what is the greatest integer that can be displayed by turning on no more than n segments.
Your program should be able to process t different test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow, each of them is represented by a separate line containing one integer n (2 ≤ n ≤ 10^5) — the maximum number of segments that can be turned on in the corresponding testcase.
It is guaranteed that the sum of n over all test cases in the input does not exceed 10^5.
Output
For each test case, print the greatest integer that can be displayed by turning on no more than n segments of the screen. Note that the answer may not fit in the standard 32-bit or 64-bit integral data type.
Example
Input
2
3
4
Output
7
11
Submitted Solution:
```
segments={
0 : 6,
1 : 2,
2 : 5,
3 : 5,
4 : 4,
5 : 5,
6 : 6,
7 : 3,
8 : 7,
9 : 6
}
def solve():
n = int(input())
if n & 1:
if n == 1:
pass
n -= 3
rem = n // segments[1]
print(str(1) * rem + '7')
else:
rem = n // segments[1]
print(str(1) * rem)
if __name__=='__main__':
for _ in range(int(input())):
solve()
``` | instruction | 0 | 21,310 | 20 | 42,620 |
No | output | 1 | 21,310 | 20 | 42,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a large electronic screen which can display up to 998244353 decimal digits. The digits are displayed in the same way as on different electronic alarm clocks: each place for a digit consists of 7 segments which can be turned on and off to compose different digits. The following picture describes how you can display all 10 decimal digits:
<image>
As you can see, different digits may require different number of segments to be turned on. For example, if you want to display 1, you have to turn on 2 segments of the screen, and if you want to display 8, all 7 segments of some place to display a digit should be turned on.
You want to display a really large integer on the screen. Unfortunately, the screen is bugged: no more than n segments can be turned on simultaneously. So now you wonder what is the greatest integer that can be displayed by turning on no more than n segments.
Your program should be able to process t different test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow, each of them is represented by a separate line containing one integer n (2 ≤ n ≤ 10^5) — the maximum number of segments that can be turned on in the corresponding testcase.
It is guaranteed that the sum of n over all test cases in the input does not exceed 10^5.
Output
For each test case, print the greatest integer that can be displayed by turning on no more than n segments of the screen. Note that the answer may not fit in the standard 32-bit or 64-bit integral data type.
Example
Input
2
3
4
Output
7
11
Submitted Solution:
```
def solve(n, count, memo):
sim = [6,2,5,5,4,5,6,3,7,6]
if n < 0:
return -float('inf')
elif n < 2 or count == 0:
return 0
else:
if (n,count) not in memo:
memo[(n, count)] = max([(i + 10*solve(n-sim[i], count-1, memo)) for i in range(10)])
return memo[(n, count)]
t = int(input())
memo = {}
for _ in range(t):
n = int(input())
print(solve(n, 11, memo))
``` | instruction | 0 | 21,311 | 20 | 42,622 |
No | output | 1 | 21,311 | 20 | 42,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a large electronic screen which can display up to 998244353 decimal digits. The digits are displayed in the same way as on different electronic alarm clocks: each place for a digit consists of 7 segments which can be turned on and off to compose different digits. The following picture describes how you can display all 10 decimal digits:
<image>
As you can see, different digits may require different number of segments to be turned on. For example, if you want to display 1, you have to turn on 2 segments of the screen, and if you want to display 8, all 7 segments of some place to display a digit should be turned on.
You want to display a really large integer on the screen. Unfortunately, the screen is bugged: no more than n segments can be turned on simultaneously. So now you wonder what is the greatest integer that can be displayed by turning on no more than n segments.
Your program should be able to process t different test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow, each of them is represented by a separate line containing one integer n (2 ≤ n ≤ 10^5) — the maximum number of segments that can be turned on in the corresponding testcase.
It is guaranteed that the sum of n over all test cases in the input does not exceed 10^5.
Output
For each test case, print the greatest integer that can be displayed by turning on no more than n segments of the screen. Note that the answer may not fit in the standard 32-bit or 64-bit integral data type.
Example
Input
2
3
4
Output
7
11
Submitted Solution:
```
t = int(input())
while t:
t -= 1
n = int(input())
merchant, remainder = divmod(n, 2)
ans = ["1" for _ in range(merchant if merchant < 10 else 9)]
if merchant > 9:
remainder += (merchant - 9) * 2
if remainder == 1:
ans[0] = "7"
if remainder == 2:
ans[0] = ans[1] = "7"
if remainder == 3:
ans[0] = ans[1] = ans[2] = "7"
if remainder == 4:
ans[0] = "9"
if remainder == 5:
ans[0] = "9"
ans[1] = "7"
if remainder == 6:
ans[0] = "9"
ans[1] = ans[2] = "7"
if remainder == 7:
ans[0] = "9"
ans[1] = ans[2] = ans[3] = "7"
if remainder == 8:
ans[0] = ans[1] = "9"
if remainder == 9:
ans[0] = ans[1] = "9"
ans[2] = "7"
if remainder == 10:
ans[0] = ans[1] = "9"
ans[2] = ans[3] = "7"
if remainder == 11:
ans[0] = ans[1] = "9"
ans[2] = ans[3] = ans[4] = "7"
if remainder == 12:
ans[0] = ans[1] = "9"
ans[2] = ans[3] = ans[4] = ans[5] = "7"
if remainder == 13:
ans[0] = ans[1] = "9"
ans[2] = "8"
if remainder == 14:
ans[0] = ans[1] = "9"
ans[2] = "8"
ans[3] = "7"
print(int("".join(ans)))
``` | instruction | 0 | 21,312 | 20 | 42,624 |
No | output | 1 | 21,312 | 20 | 42,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a large electronic screen which can display up to 998244353 decimal digits. The digits are displayed in the same way as on different electronic alarm clocks: each place for a digit consists of 7 segments which can be turned on and off to compose different digits. The following picture describes how you can display all 10 decimal digits:
<image>
As you can see, different digits may require different number of segments to be turned on. For example, if you want to display 1, you have to turn on 2 segments of the screen, and if you want to display 8, all 7 segments of some place to display a digit should be turned on.
You want to display a really large integer on the screen. Unfortunately, the screen is bugged: no more than n segments can be turned on simultaneously. So now you wonder what is the greatest integer that can be displayed by turning on no more than n segments.
Your program should be able to process t different test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow, each of them is represented by a separate line containing one integer n (2 ≤ n ≤ 10^5) — the maximum number of segments that can be turned on in the corresponding testcase.
It is guaranteed that the sum of n over all test cases in the input does not exceed 10^5.
Output
For each test case, print the greatest integer that can be displayed by turning on no more than n segments of the screen. Note that the answer may not fit in the standard 32-bit or 64-bit integral data type.
Example
Input
2
3
4
Output
7
11
Submitted Solution:
```
t = int(input())
lst = ["1"]*16
for i in range(1,16):
lst[i] = lst[i-1]+lst[i-1]
for i in range(t):
ans = ""
cnt = 0
n = int(input())
bin_n = bin(n)[2:]
for j in range(2,len(bin_n)+1):
if bin_n[-j] == "1":
ans += lst[j-2]
if bin_n[-1] == "1":
ans = int(ans)+6
else:
ans = int(ans)
if 998244353 < ans:
print(998244353)
else:
print(ans)
``` | instruction | 0 | 21,313 | 20 | 42,626 |
No | output | 1 | 21,313 | 20 | 42,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The only difference is that here 2≤ k≤ 100. You can make hacks only if both the versions of the problem are solved.
This is an interactive problem!
Every decimal number has a base k equivalent. The individual digits of a base k number are called k-its. Let's define the k-itwise XOR of two k-its a and b as (a + b)mod k.
The k-itwise XOR of two base k numbers is equal to the new number formed by taking the k-itwise XOR of their corresponding k-its. The k-itwise XOR of two decimal numbers a and b is denoted by a⊕_{k} b and is equal to the decimal representation of the k-itwise XOR of the base k representations of a and b. All further numbers used in the statement below are in decimal unless specified.
You have hacked the criminal database of Rockport Police Department (RPD), also known as the Rap Sheet. But in order to access it, you require a password. You don't know it, but you are quite sure that it lies between 0 and n-1 inclusive. So, you have decided to guess it. Luckily, you can try at most n times without being blocked by the system. But the system is adaptive. Each time you make an incorrect guess, it changes the password. Specifically, if the password before the guess was x, and you guess a different number y, then the system changes the password to a number z such that x⊕_{k} z=y. Guess the password and break into the system.
Input
The first line of input contains a single integer t (1≤ t≤ 10 000) denoting the number of test cases. t test cases follow.
The first line of each test case contains two integers n (1≤ n≤ 2⋅ 10^5) and k (2≤ k≤ 100).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Interaction
For each test case, first read two integers n and k. Then you may ask up to n queries.
For each query, print a single integer y (0≤ y≤ 2⋅ 10^7). Let the current password be x. After that, read an integer r.
If x=y, you will read r=1 and the test case is solved. You must then continue solving the remaining test cases.
Else, you will read r=0. At this moment the password is changed to a number z such that x⊕_{k} z=y.
After printing a query, do not forget to output the end of line and flush the output. Otherwise, you will get the Idleness limit exceeded verdict.
To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
If you ask an invalid query or exceed n queries, you will read r=-1 and you will receive the Wrong Answer verdict. Make sure to exit immediately to avoid unexpected verdicts.
Note that the interactor is adaptive. That is, the original password is not fixed in the beginning and may depend on your queries. But it is guaranteed that at any moment there is at least one initial password such that all the answers to the queries are consistent.
Hacks:
To use hacks, use the following format of tests:
The first line should contain a single integer t (1≤ t≤ 10 000) — the number of test cases.
The first and only line of each test case should contain two integers n (1≤ n≤ 2⋅ 10^5) and k (2≤ k≤ 100) denoting the number of queries and the base respectively. The optimal original password is automatically decided by the adaptive interactor.
You must ensure that the sum of n over all test cases does not exceed 2⋅ 10^5.
Example
Input
2
5 2
0
0
1
5 3
0
0
1
Output
3
4
5
1
4
6
Note
Test Case 1:
In this case, the hidden password is 2.
The first query is 3. It is not equal to the current password. So, 0 is returned, and the password is changed to 1 since 2⊕_2 1=3.
The second query is 4. It is not equal to the current password. So, 0 is returned, and the password is changed to 5 since 1⊕_2 5=4.
The third query is 5. It is equal to the current password. So, 1 is returned, and the job is done.
Test Case 2:
In this case, the hidden password is 3.
The first query is 1. It is not equal to the current password. So, 0 is returned, and the password is changed to 7 since 3⊕_3 7=1. [3=(10)_3, 7=(21)_3, 1=(01)_3 and (10)_3⊕_3 (21)_3 = (01)_3].
The second query is 4. It is not equal to the current password. So, 0 is returned, and the password is changed to 6 since 7⊕_3 6=4. [7=(21)_3, 6=(20)_3, 4=(11)_3 and (21)_3⊕_3 (20)_3 = (11)_3].
The third query is 6. It is equal to the current password. So, 1 is returned, and the job is done.
Note that these initial passwords are taken just for the sake of explanation. In reality, the grader might behave differently because it is adaptive.
Submitted Solution:
```
import sys, os
from io import BytesIO, IOBase
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
import string
digs = string.digits + string.ascii_letters
def int2base(x, base):
if x < 0:
sign = -1
elif x == 0:
return digs[0]
else:
sign = 1
x *= sign
digits = []
while x:
digits.append(digs[int(x % base)])
x = int(x / base)
if sign < 0:
digits.append('-')
digits.reverse()
return ''.join(digits)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
stdin, stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def ceil(a, b): return (a+b-1)//b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
def kbit(i, j, k):
i = int2base(i, k)[::-1]
j = int2base(j, k)[::-1]
j = j+'0'
ans = ''
for x in range(len(i)):
ans += str((-int(i[x]) + int(j[x]))%k)
return int(ans[::-1], k)
for _ in range(iinp()):
n, k = mp()
out("0")
stdout.flush()
r = iinp()
if r==-1:
exit()
if r==1:
continue
for i in range(1, n):
out(str(kbit(i, i-1, k)))
stdout.flush()
r = iinp()
if r==-1:
exit()
if r==1:
break
``` | instruction | 0 | 21,459 | 20 | 42,918 |
No | output | 1 | 21,459 | 20 | 42,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The only difference is that here 2≤ k≤ 100. You can make hacks only if both the versions of the problem are solved.
This is an interactive problem!
Every decimal number has a base k equivalent. The individual digits of a base k number are called k-its. Let's define the k-itwise XOR of two k-its a and b as (a + b)mod k.
The k-itwise XOR of two base k numbers is equal to the new number formed by taking the k-itwise XOR of their corresponding k-its. The k-itwise XOR of two decimal numbers a and b is denoted by a⊕_{k} b and is equal to the decimal representation of the k-itwise XOR of the base k representations of a and b. All further numbers used in the statement below are in decimal unless specified.
You have hacked the criminal database of Rockport Police Department (RPD), also known as the Rap Sheet. But in order to access it, you require a password. You don't know it, but you are quite sure that it lies between 0 and n-1 inclusive. So, you have decided to guess it. Luckily, you can try at most n times without being blocked by the system. But the system is adaptive. Each time you make an incorrect guess, it changes the password. Specifically, if the password before the guess was x, and you guess a different number y, then the system changes the password to a number z such that x⊕_{k} z=y. Guess the password and break into the system.
Input
The first line of input contains a single integer t (1≤ t≤ 10 000) denoting the number of test cases. t test cases follow.
The first line of each test case contains two integers n (1≤ n≤ 2⋅ 10^5) and k (2≤ k≤ 100).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Interaction
For each test case, first read two integers n and k. Then you may ask up to n queries.
For each query, print a single integer y (0≤ y≤ 2⋅ 10^7). Let the current password be x. After that, read an integer r.
If x=y, you will read r=1 and the test case is solved. You must then continue solving the remaining test cases.
Else, you will read r=0. At this moment the password is changed to a number z such that x⊕_{k} z=y.
After printing a query, do not forget to output the end of line and flush the output. Otherwise, you will get the Idleness limit exceeded verdict.
To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
If you ask an invalid query or exceed n queries, you will read r=-1 and you will receive the Wrong Answer verdict. Make sure to exit immediately to avoid unexpected verdicts.
Note that the interactor is adaptive. That is, the original password is not fixed in the beginning and may depend on your queries. But it is guaranteed that at any moment there is at least one initial password such that all the answers to the queries are consistent.
Hacks:
To use hacks, use the following format of tests:
The first line should contain a single integer t (1≤ t≤ 10 000) — the number of test cases.
The first and only line of each test case should contain two integers n (1≤ n≤ 2⋅ 10^5) and k (2≤ k≤ 100) denoting the number of queries and the base respectively. The optimal original password is automatically decided by the adaptive interactor.
You must ensure that the sum of n over all test cases does not exceed 2⋅ 10^5.
Example
Input
2
5 2
0
0
1
5 3
0
0
1
Output
3
4
5
1
4
6
Note
Test Case 1:
In this case, the hidden password is 2.
The first query is 3. It is not equal to the current password. So, 0 is returned, and the password is changed to 1 since 2⊕_2 1=3.
The second query is 4. It is not equal to the current password. So, 0 is returned, and the password is changed to 5 since 1⊕_2 5=4.
The third query is 5. It is equal to the current password. So, 1 is returned, and the job is done.
Test Case 2:
In this case, the hidden password is 3.
The first query is 1. It is not equal to the current password. So, 0 is returned, and the password is changed to 7 since 3⊕_3 7=1. [3=(10)_3, 7=(21)_3, 1=(01)_3 and (10)_3⊕_3 (21)_3 = (01)_3].
The second query is 4. It is not equal to the current password. So, 0 is returned, and the password is changed to 6 since 7⊕_3 6=4. [7=(21)_3, 6=(20)_3, 4=(11)_3 and (21)_3⊕_3 (20)_3 = (11)_3].
The third query is 6. It is equal to the current password. So, 1 is returned, and the job is done.
Note that these initial passwords are taken just for the sake of explanation. In reality, the grader might behave differently because it is adaptive.
Submitted Solution:
```
import sys, os
from io import BytesIO, IOBase
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
import string
digs = string.digits + string.ascii_letters
def int2base(x, base):
if x < 0:
sign = -1
elif x == 0:
return digs[0]
else:
sign = 1
x *= sign
digits = []
while x:
digits.append(digs[int(x % base)])
x = int(x / base)
if sign < 0:
digits.append('-')
digits.reverse()
return ''.join(digits)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
stdin, stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def ceil(a, b): return (a+b-1)//b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
def kbit(i, j, k, f):
i = int2base(i, k)[::-1]
j = int2base(j, k)[::-1]
j = j+'0'
ans = ''
for x in range(len(i)):
if f:
ans += str((int(i[x]) - int(j[x]))%k)
else:
ans += str((-int(i[x]) + int(j[x]))%k)
return int(ans[::-1], k)
for _ in range(iinp()):
n, k = mp()
out("0")
stdout.flush()
r = iinp()
if r==-1:
exit()
if r==1:
continue
for i in range(1, n):
out(str(kbit(i, i-1, k, 1-i%2)))
stdout.flush()
r = iinp()
if r==-1:
exit()
if r==1:
break
``` | instruction | 0 | 21,460 | 20 | 42,920 |
No | output | 1 | 21,460 | 20 | 42,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The only difference is that here 2≤ k≤ 100. You can make hacks only if both the versions of the problem are solved.
This is an interactive problem!
Every decimal number has a base k equivalent. The individual digits of a base k number are called k-its. Let's define the k-itwise XOR of two k-its a and b as (a + b)mod k.
The k-itwise XOR of two base k numbers is equal to the new number formed by taking the k-itwise XOR of their corresponding k-its. The k-itwise XOR of two decimal numbers a and b is denoted by a⊕_{k} b and is equal to the decimal representation of the k-itwise XOR of the base k representations of a and b. All further numbers used in the statement below are in decimal unless specified.
You have hacked the criminal database of Rockport Police Department (RPD), also known as the Rap Sheet. But in order to access it, you require a password. You don't know it, but you are quite sure that it lies between 0 and n-1 inclusive. So, you have decided to guess it. Luckily, you can try at most n times without being blocked by the system. But the system is adaptive. Each time you make an incorrect guess, it changes the password. Specifically, if the password before the guess was x, and you guess a different number y, then the system changes the password to a number z such that x⊕_{k} z=y. Guess the password and break into the system.
Input
The first line of input contains a single integer t (1≤ t≤ 10 000) denoting the number of test cases. t test cases follow.
The first line of each test case contains two integers n (1≤ n≤ 2⋅ 10^5) and k (2≤ k≤ 100).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Interaction
For each test case, first read two integers n and k. Then you may ask up to n queries.
For each query, print a single integer y (0≤ y≤ 2⋅ 10^7). Let the current password be x. After that, read an integer r.
If x=y, you will read r=1 and the test case is solved. You must then continue solving the remaining test cases.
Else, you will read r=0. At this moment the password is changed to a number z such that x⊕_{k} z=y.
After printing a query, do not forget to output the end of line and flush the output. Otherwise, you will get the Idleness limit exceeded verdict.
To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
If you ask an invalid query or exceed n queries, you will read r=-1 and you will receive the Wrong Answer verdict. Make sure to exit immediately to avoid unexpected verdicts.
Note that the interactor is adaptive. That is, the original password is not fixed in the beginning and may depend on your queries. But it is guaranteed that at any moment there is at least one initial password such that all the answers to the queries are consistent.
Hacks:
To use hacks, use the following format of tests:
The first line should contain a single integer t (1≤ t≤ 10 000) — the number of test cases.
The first and only line of each test case should contain two integers n (1≤ n≤ 2⋅ 10^5) and k (2≤ k≤ 100) denoting the number of queries and the base respectively. The optimal original password is automatically decided by the adaptive interactor.
You must ensure that the sum of n over all test cases does not exceed 2⋅ 10^5.
Example
Input
2
5 2
0
0
1
5 3
0
0
1
Output
3
4
5
1
4
6
Note
Test Case 1:
In this case, the hidden password is 2.
The first query is 3. It is not equal to the current password. So, 0 is returned, and the password is changed to 1 since 2⊕_2 1=3.
The second query is 4. It is not equal to the current password. So, 0 is returned, and the password is changed to 5 since 1⊕_2 5=4.
The third query is 5. It is equal to the current password. So, 1 is returned, and the job is done.
Test Case 2:
In this case, the hidden password is 3.
The first query is 1. It is not equal to the current password. So, 0 is returned, and the password is changed to 7 since 3⊕_3 7=1. [3=(10)_3, 7=(21)_3, 1=(01)_3 and (10)_3⊕_3 (21)_3 = (01)_3].
The second query is 4. It is not equal to the current password. So, 0 is returned, and the password is changed to 6 since 7⊕_3 6=4. [7=(21)_3, 6=(20)_3, 4=(11)_3 and (21)_3⊕_3 (20)_3 = (11)_3].
The third query is 6. It is equal to the current password. So, 1 is returned, and the job is done.
Note that these initial passwords are taken just for the sake of explanation. In reality, the grader might behave differently because it is adaptive.
Submitted Solution:
```
import sys,os
from io import BytesIO,IOBase
# from functools import lru_cache
mod = 10**9+7; Mod = 998244353; INF = float('inf')
# input = lambda: sys.stdin.readline().rstrip("\r\n")
# inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
#______________________________________________________________________________________________________
# region fastio
# '''
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# endregion'''
#______________________________________________________________________________________________________
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
# ______________________________________________________________________________________________________
from math import *
# from bisect import *
# from heapq import *
# from collections import defaultdict as dd
# from collections import OrderedDict as odict
# from collections import Counter as cc
# from collections import deque
# from itertools import groupby
# from itertools import combinations
# sys.setrecursionlimit(100_100) #this is must for dfs
# ______________________________________________________________________________________________________
# segment tree for range minimum query and update 0 indexing
# init = float('inf')
# st = [init for i in range(4*len(a))]
# def build(a,ind,start,end):
# if start == end:
# st[ind] = a[start]
# else:
# mid = (start+end)//2
# build(a,2*ind+1,start,mid)
# build(a,2*ind+2,mid+1,end)
# st[ind] = min(st[2*ind+1],st[2*ind+2])
# build(a,0,0,n-1)
# def query(ind,l,r,start,end):
# if start>r or end<l:
# return init
# if l<=start<=end<=r:
# return st[ind]
# mid = (start+end)//2
# return min(query(2*ind+1,l,r,start,mid),query(2*ind+2,l,r,mid+1,end))
# def update(ind,val,stind,start,end):
# if start<=ind<=end:
# if start==end:
# st[stind] = a[start] = val
# else:
# mid = (start+end)//2
# update(ind,val,2*stind+1,start,mid)
# update(ind,val,2*stind+2,mid+1,end)
# st[stind] = min(st[left],st[right])
# ______________________________________________________________________________________________________
# Checking prime in O(root(N))
# def isprime(n):
# if (n % 2 == 0 and n > 2) or n == 1: return 0
# else:
# s = int(n**(0.5)) + 1
# for i in range(3, s, 2):
# if n % i == 0:
# return 0
# return 1
# def lcm(a,b):
# return (a*b)//gcd(a,b)
# returning factors in O(root(N))
# def factors(n):
# fact = []
# N = int(n**0.5)+1
# for i in range(1,N):
# if (n%i==0):
# fact.append(i)
# if (i!=n//i):
# fact.append(n//i)
# return fact
# ______________________________________________________________________________________________________
# Merge sort for inversion count
# def mergeSort(left,right,arr,temp):
# inv_cnt = 0
# if left<right:
# mid = (left+right)//2
# inv1 = mergeSort(left,mid,arr,temp)
# inv2 = mergeSort(mid+1,right,arr,temp)
# inv3 = merge(left,right,mid,arr,temp)
# inv_cnt = inv1+inv3+inv2
# return inv_cnt
# def merge(left,right,mid,arr,temp):
# i = left
# j = mid+1
# k = left
# inv = 0
# while(i<=mid and j<=right):
# if(arr[i]<=arr[j]):
# temp[k] = arr[i]
# i+=1
# else:
# temp[k] = arr[j]
# inv+=(mid+1-i)
# j+=1
# k+=1
# while(i<=mid):
# temp[k]=arr[i]
# i+=1
# k+=1
# while(j<=right):
# temp[k]=arr[j]
# j+=1
# k+=1
# for k in range(left,right+1):
# arr[k] = temp[k]
# return inv
# ______________________________________________________________________________________________________
# nCr under mod
# def C(n,r,mod = 10**9+7):
# if r>n: return 0
# if r>n-r: r = n-r
# num = den = 1
# for i in range(r):
# num = (num*(n-i))%mod
# den = (den*(i+1))%mod
# return (num*pow(den,mod-2,mod))%mod
# def C(n,r):
# if r>n:
# return 0
# if r>n-r:
# r = n-r
# ans = 1
# for i in range(r):
# ans = (ans*(n-i))//(i+1)
# return ans
# ______________________________________________________________________________________________________
# For smallest prime factor of a number
# M = 5*10**5+100
# spf = [i for i in range(M)]
# def spfs(M):
# for i in range(2,M):
# if spf[i]==i:
# for j in range(i*i,M,i):
# if spf[j]==j:
# spf[j] = i
# return
# spfs(M)
# p = [0]*M
# for i in range(2,M):
# p[i]+=(p[i-1]+(spf[i]==i))
# ______________________________________________________________________________________________________
# def gtc(p):
# print('Case #'+str(p)+': ',end='')
# ______________________________________________________________________________________________________
tc = 1
tc = int(input())
for test in range(1,tc+1):
n,k = inp()
q = 0
prev = 0
Max = 2+log10(n)/log10(k)
power = [k**i for i in range(int(Max))]
for i in range(n):
cur = i
number = 0
cnt = 0
while(prev or cur):
ad = (k+k-prev%k-cur%k)%k
number+= ad*power[cnt]
cnt+=1
prev//=k
cur//=k
print(number,flush = True)
r = int(input())
if (r==1):
break
prev = i
# n,k = inp()
# q = 0
# prev = 0
# for i in range(n):
# q = i^prev
# print(q,flush = True)
# r = int(input())
# if (r==1):
# break
# prev = i
``` | instruction | 0 | 21,461 | 20 | 42,922 |
No | output | 1 | 21,461 | 20 | 42,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The only difference is that here 2≤ k≤ 100. You can make hacks only if both the versions of the problem are solved.
This is an interactive problem!
Every decimal number has a base k equivalent. The individual digits of a base k number are called k-its. Let's define the k-itwise XOR of two k-its a and b as (a + b)mod k.
The k-itwise XOR of two base k numbers is equal to the new number formed by taking the k-itwise XOR of their corresponding k-its. The k-itwise XOR of two decimal numbers a and b is denoted by a⊕_{k} b and is equal to the decimal representation of the k-itwise XOR of the base k representations of a and b. All further numbers used in the statement below are in decimal unless specified.
You have hacked the criminal database of Rockport Police Department (RPD), also known as the Rap Sheet. But in order to access it, you require a password. You don't know it, but you are quite sure that it lies between 0 and n-1 inclusive. So, you have decided to guess it. Luckily, you can try at most n times without being blocked by the system. But the system is adaptive. Each time you make an incorrect guess, it changes the password. Specifically, if the password before the guess was x, and you guess a different number y, then the system changes the password to a number z such that x⊕_{k} z=y. Guess the password and break into the system.
Input
The first line of input contains a single integer t (1≤ t≤ 10 000) denoting the number of test cases. t test cases follow.
The first line of each test case contains two integers n (1≤ n≤ 2⋅ 10^5) and k (2≤ k≤ 100).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Interaction
For each test case, first read two integers n and k. Then you may ask up to n queries.
For each query, print a single integer y (0≤ y≤ 2⋅ 10^7). Let the current password be x. After that, read an integer r.
If x=y, you will read r=1 and the test case is solved. You must then continue solving the remaining test cases.
Else, you will read r=0. At this moment the password is changed to a number z such that x⊕_{k} z=y.
After printing a query, do not forget to output the end of line and flush the output. Otherwise, you will get the Idleness limit exceeded verdict.
To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
If you ask an invalid query or exceed n queries, you will read r=-1 and you will receive the Wrong Answer verdict. Make sure to exit immediately to avoid unexpected verdicts.
Note that the interactor is adaptive. That is, the original password is not fixed in the beginning and may depend on your queries. But it is guaranteed that at any moment there is at least one initial password such that all the answers to the queries are consistent.
Hacks:
To use hacks, use the following format of tests:
The first line should contain a single integer t (1≤ t≤ 10 000) — the number of test cases.
The first and only line of each test case should contain two integers n (1≤ n≤ 2⋅ 10^5) and k (2≤ k≤ 100) denoting the number of queries and the base respectively. The optimal original password is automatically decided by the adaptive interactor.
You must ensure that the sum of n over all test cases does not exceed 2⋅ 10^5.
Example
Input
2
5 2
0
0
1
5 3
0
0
1
Output
3
4
5
1
4
6
Note
Test Case 1:
In this case, the hidden password is 2.
The first query is 3. It is not equal to the current password. So, 0 is returned, and the password is changed to 1 since 2⊕_2 1=3.
The second query is 4. It is not equal to the current password. So, 0 is returned, and the password is changed to 5 since 1⊕_2 5=4.
The third query is 5. It is equal to the current password. So, 1 is returned, and the job is done.
Test Case 2:
In this case, the hidden password is 3.
The first query is 1. It is not equal to the current password. So, 0 is returned, and the password is changed to 7 since 3⊕_3 7=1. [3=(10)_3, 7=(21)_3, 1=(01)_3 and (10)_3⊕_3 (21)_3 = (01)_3].
The second query is 4. It is not equal to the current password. So, 0 is returned, and the password is changed to 6 since 7⊕_3 6=4. [7=(21)_3, 6=(20)_3, 4=(11)_3 and (21)_3⊕_3 (20)_3 = (11)_3].
The third query is 6. It is equal to the current password. So, 1 is returned, and the job is done.
Note that these initial passwords are taken just for the sake of explanation. In reality, the grader might behave differently because it is adaptive.
Submitted Solution:
```
import sys,os
from io import BytesIO,IOBase
# from functools import lru_cache
mod = 10**9+7; Mod = 998244353; INF = float('inf')
# input = lambda: sys.stdin.readline().rstrip("\r\n")
# inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
#______________________________________________________________________________________________________
# region fastio
# '''
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# endregion'''
#______________________________________________________________________________________________________
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
# ______________________________________________________________________________________________________
from math import *
# from bisect import *
# from heapq import *
# from collections import defaultdict as dd
# from collections import OrderedDict as odict
# from collections import Counter as cc
# from collections import deque
# from itertools import groupby
# from itertools import combinations
# sys.setrecursionlimit(100_100) #this is must for dfs
# ______________________________________________________________________________________________________
# segment tree for range minimum query and update 0 indexing
# init = float('inf')
# st = [init for i in range(4*len(a))]
# def build(a,ind,start,end):
# if start == end:
# st[ind] = a[start]
# else:
# mid = (start+end)//2
# build(a,2*ind+1,start,mid)
# build(a,2*ind+2,mid+1,end)
# st[ind] = min(st[2*ind+1],st[2*ind+2])
# build(a,0,0,n-1)
# def query(ind,l,r,start,end):
# if start>r or end<l:
# return init
# if l<=start<=end<=r:
# return st[ind]
# mid = (start+end)//2
# return min(query(2*ind+1,l,r,start,mid),query(2*ind+2,l,r,mid+1,end))
# def update(ind,val,stind,start,end):
# if start<=ind<=end:
# if start==end:
# st[stind] = a[start] = val
# else:
# mid = (start+end)//2
# update(ind,val,2*stind+1,start,mid)
# update(ind,val,2*stind+2,mid+1,end)
# st[stind] = min(st[left],st[right])
# ______________________________________________________________________________________________________
# Checking prime in O(root(N))
# def isprime(n):
# if (n % 2 == 0 and n > 2) or n == 1: return 0
# else:
# s = int(n**(0.5)) + 1
# for i in range(3, s, 2):
# if n % i == 0:
# return 0
# return 1
# def lcm(a,b):
# return (a*b)//gcd(a,b)
# returning factors in O(root(N))
# def factors(n):
# fact = []
# N = int(n**0.5)+1
# for i in range(1,N):
# if (n%i==0):
# fact.append(i)
# if (i!=n//i):
# fact.append(n//i)
# return fact
# ______________________________________________________________________________________________________
# Merge sort for inversion count
# def mergeSort(left,right,arr,temp):
# inv_cnt = 0
# if left<right:
# mid = (left+right)//2
# inv1 = mergeSort(left,mid,arr,temp)
# inv2 = mergeSort(mid+1,right,arr,temp)
# inv3 = merge(left,right,mid,arr,temp)
# inv_cnt = inv1+inv3+inv2
# return inv_cnt
# def merge(left,right,mid,arr,temp):
# i = left
# j = mid+1
# k = left
# inv = 0
# while(i<=mid and j<=right):
# if(arr[i]<=arr[j]):
# temp[k] = arr[i]
# i+=1
# else:
# temp[k] = arr[j]
# inv+=(mid+1-i)
# j+=1
# k+=1
# while(i<=mid):
# temp[k]=arr[i]
# i+=1
# k+=1
# while(j<=right):
# temp[k]=arr[j]
# j+=1
# k+=1
# for k in range(left,right+1):
# arr[k] = temp[k]
# return inv
# ______________________________________________________________________________________________________
# nCr under mod
# def C(n,r,mod = 10**9+7):
# if r>n: return 0
# if r>n-r: r = n-r
# num = den = 1
# for i in range(r):
# num = (num*(n-i))%mod
# den = (den*(i+1))%mod
# return (num*pow(den,mod-2,mod))%mod
# def C(n,r):
# if r>n:
# return 0
# if r>n-r:
# r = n-r
# ans = 1
# for i in range(r):
# ans = (ans*(n-i))//(i+1)
# return ans
# ______________________________________________________________________________________________________
# For smallest prime factor of a number
# M = 5*10**5+100
# spf = [i for i in range(M)]
# def spfs(M):
# for i in range(2,M):
# if spf[i]==i:
# for j in range(i*i,M,i):
# if spf[j]==j:
# spf[j] = i
# return
# spfs(M)
# p = [0]*M
# for i in range(2,M):
# p[i]+=(p[i-1]+(spf[i]==i))
# ______________________________________________________________________________________________________
# def gtc(p):
# print('Case #'+str(p)+': ',end='')
# ______________________________________________________________________________________________________
tc = 1
tc = int(input())
for test in range(1,tc+1):
n,k = inp()
q = 0
prev = 0
Max = 2+log10(n)/log10(k)
power = [k**i for i in range(int(Max))]
for i in range(n):
cur = i
number = 0
cnt = 0
if (i&1==0):
while(prev or cur):
ad = (k+k+(prev%k)+(cur%k))%k
number+= ad*power[cnt]
cnt+=1
prev//=k
cur//=k
else:
while(prev or cur):
ad = (k+k-(prev%k)-(cur%k))%k
number+= ad*power[cnt]
cnt+=1
prev//=k
cur//=k
print(number,flush = True)
r = int(input())
if (r==1):
break
prev = i
# n,k = inp()
# q = 0
# prev = 0
# for i in range(n):
# q = i^prev
# print(q,flush = True)
# r = int(input())
# if (r==1):
# break
# prev = i
``` | instruction | 0 | 21,462 | 20 | 42,924 |
No | output | 1 | 21,462 | 20 | 42,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
qd ucyhf yi q fhycu dkcruh mxeiu huluhiu yi q tyvvuhudj fhycu dkcruh. oekh jqia yi je vydt jxu djx ucyhf.
Input
jxu ydfkj sediyiji ev q iydwbu ydjuwuh d (1 ≤ d ≤ 11184) — jxu edu-rqiut ydtun ev jxu ucyhf je vydt.
Output
ekjfkj q iydwbu dkcruh.
Examples
Input
1
Output
13 | instruction | 0 | 21,463 | 20 | 42,926 |
Tags: *special, brute force, implementation, number theory
Correct Solution:
```
#!/usr/bin/env python
from __future__ import division, print_function
import math
import os
import sys
from fractions import *
from sys import *
from io import BytesIO, IOBase
from itertools import *
from collections import *
# sys.setrecursionlimit(10**5)
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
# sys.setrecursionlimit(10**6)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def fsep(): return map(float, inp().split())
def inpu(): return int(inp())
# -----------------------------------------------------------------
def regularbracket(t):
p = 0
for i in t:
if i == "(":
p += 1
else:
p -= 1
if p < 0:
return False
else:
if p > 0:
return False
else:
return True
# -------------------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <= key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# ------------------------------reverse string(pallindrome)
def reverse1(string):
pp = ""
for i in string[::-1]:
pp += i
if pp == string:
return True
return False
# --------------------------------reverse list(paindrome)
def reverse2(list1):
l = []
for i in list1[::-1]:
l.append(i)
if l == list1:
return True
return False
def mex(list1):
# list1 = sorted(list1)
p = max(list1) + 1
for i in range(len(list1)):
if list1[i] != i:
p = i
break
return p
def sumofdigits(n):
n = str(n)
s1 = 0
for i in n:
s1 += int(i)
return s1
def perfect_square(n):
s = math.sqrt(n)
if s == int(s):
return True
return False
# -----------------------------roman
def roman_number(x):
if x > 15999:
return
value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
symbol = ["F", "MF", "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman = ""
i = 0
while x > 0:
div = x // value[i]
x = x % value[i]
while div:
roman += symbol[i]
div -= 1
i += 1
return roman
def soretd(s):
for i in range(1, len(s)):
if s[i - 1] > s[i]:
return False
return True
# print(soretd("1"))
# ---------------------------
def countRhombi(h, w):
ct = 0
for i in range(2, h + 1, 2):
for j in range(2, w + 1, 2):
ct += (h - i + 1) * (w - j + 1)
return ct
def countrhombi2(h, w):
return ((h * h) // 4) * ((w * w) // 4)
# ---------------------------------
def binpow(a, b):
if b == 0:
return 1
else:
res = binpow(a, b // 2)
if b % 2 != 0:
return res * res * a
else:
return res * res
# -------------------------------------------------------
def binpowmodulus(a, b, m):
a %= m
res = 1
while (b > 0):
if (b & 1):
res = res * a % m
a = a * a % m
b >>= 1
return res
# -------------------------------------------------------------
def coprime_to_n(n):
result = n
i = 2
while (i * i <= n):
if (n % i == 0):
while (n % i == 0):
n //= i
result -= result // i
i += 1
if (n > 1):
result -= result // n
return result
# -------------------prime
def prime(x):
if x == 1:
return False
else:
for i in range(2, int(math.sqrt(x)) + 1):
if (x % i == 0):
return False
else:
return True
def luckynumwithequalnumberoffourandseven(x, n, a):
if x >= n and str(x).count("4") == str(x).count("7"):
a.append(x)
else:
if x < 1e12:
luckynumwithequalnumberoffourandseven(x * 10 + 4, n, a)
luckynumwithequalnumberoffourandseven(x * 10 + 7, n, a)
return a
def luckynuber(x, n, a):
p = set(str(x))
if len(p) <= 2:
a.append(x)
if x < n:
luckynuber(x + 1, n, a)
return a
#------------------------------------------------------interactive problems
def interact(type, x):
if type == "r":
inp = input()
return inp.strip()
else:
print(x, flush=True)
#------------------------------------------------------------------zero at end of factorial of a number
def findTrailingZeros(n):
# Initialize result
count = 0
# Keep dividing n by
# 5 & update Count
while (n >= 5):
n //= 5
count += n
return count
#-----------------------------------------------merge sort
# Python program for implementation of MergeSort
def mergeSort(arr):
if len(arr) > 1:
# Finding the mid of the array
mid = len(arr) // 2
# Dividing the array elements
L = arr[:mid]
# into 2 halves
R = arr[mid:]
# Sorting the first half
mergeSort(L)
# Sorting the second half
mergeSort(R)
i = j = k = 0
# Copy data to temp arrays L[] and R[]
while i < len(L) and j < len(R):
if L[i] < R[j]:
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
k += 1
# Checking if any element was left
while i < len(L):
arr[k] = L[i]
i += 1
k += 1
while j < len(R):
arr[k] = R[j]
j += 1
k += 1
#-----------------------------------------------lucky number with two lucky any digits
res = set()
def solve(p, l, a, b,n):#given number
if p > n or l > 10:
return
if p > 0:
res.add(p)
solve(p * 10 + a, l + 1, a, b,n)
solve(p * 10 + b, l + 1, a, b,n)
# problem
"""
n = int(input())
for a in range(0, 10):
for b in range(0, a):
solve(0, 0)
print(len(res))
"""
#-----------------------------------------------
# endregion------------------------------
"""
def main():
n = inpu()
cnt=0
c = n
if n % 7 == 0:
print("7" * (n // 7))
else:
while(c>0):
c-=4
cnt+=1
if c%7==0 and c>=0:
#print(n,n%4)
print("4"*(cnt)+"7"*(c//7))
break
else:
if n % 4 == 0:
print("4" * (n // 4))
else:
print(-1)
if __name__ == '__main__':
main()
"""
"""
def main():
n,t = sep()
arr = lis()
i=0
cnt=0
min1 = min(arr)
while(True):
if t>=arr[i]:
cnt+=1
t-=arr[i]
i+=1
else:
i+=1
if i==n:
i=0
if t<min1:
break
print(cnt)
if __name__ == '__main__':
main()
"""
# Python3 program to find all subsets
# by backtracking.
# In the array A at every step we have two
# choices for each element either we can
# ignore the element or we can include the
# element in our subset
def subsetsUtil(A, subset, index,d):
print(*subset)
s = sum(subset)
d.append(s)
for i in range(index, len(A)):
# include the A[i] in subset.
subset.append(A[i])
# move onto the next element.
subsetsUtil(A, subset, i + 1,d)
# exclude the A[i] from subset and
# triggers backtracking.
subset.pop(-1)
return d
def subsetSums(arr, l, r,d, sum=0):
if l > r:
d.append(sum)
return
subsetSums(arr, l + 1, r,d, sum + arr[l])
# Subset excluding arr[l]
subsetSums(arr, l + 1, r,d, sum)
return d
"""
def main():
t = inpu()
for _ in range(t):
n = inpu()
arr=[]
subset=[]
i=0
l=[]
for j in range(26):
arr.append(3**j)
if __name__ == '__main__':
main()
"""
"""
def main():
n = int(input())
cnt=1
if n==1:
print(1)
else:
for i in range(1,n):
cnt+=i*12
print(cnt)
if __name__ == '__main__':
main()
"""
def f(n):
i = 2
while i * i <= n:
if n % i == 0:
return False
i += 1
return True
n = int(input())
for i in range(10, 1000000):
if i != int(str(i)[::-1]) and f(i) and f(int(str(i)[::-1])):
n -= 1
if n == 0:
print(i)
break
``` | output | 1 | 21,463 | 20 | 42,927 |
Provide tags and a correct Python 3 solution for this coding contest problem.
qd ucyhf yi q fhycu dkcruh mxeiu huluhiu yi q tyvvuhudj fhycu dkcruh. oekh jqia yi je vydt jxu djx ucyhf.
Input
jxu ydfkj sediyiji ev q iydwbu ydjuwuh d (1 ≤ d ≤ 11184) — jxu edu-rqiut ydtun ev jxu ucyhf je vydt.
Output
ekjfkj q iydwbu dkcruh.
Examples
Input
1
Output
13 | instruction | 0 | 21,465 | 20 | 42,930 |
Tags: *special, brute force, implementation, number theory
Correct Solution:
```
thelist = [13, 17, 37, 79, 107, 113, 149, 157, 167, 179, 199, 337, 347, 359, 389, 709, 739, 769, 1009, 1021, 1031, 1033, 1061, 1069, 1091, 1097, 1103, 1109, 1151, 1153, 1181, 1193, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1279, 1283, 1381, 1399, 1409, 1429, 1439, 1453, 1471, 1487, 1499, 1523, 1559, 1583, 1597, 1619, 1657, 1669, 1723, 1733, 1753, 1789, 1847, 1867, 1879, 1913, 1933, 1949, 1979, 3019, 3023, 3049, 3067, 3083, 3089, 3109, 3163, 3169, 3257, 3299, 3319, 3343, 3347, 3359, 3373, 3389, 3407, 3463, 3467, 3469, 3527, 3583, 3697, 3719, 3767, 3889, 3917, 3929, 7027, 7057, 7177, 7187, 7219, 7229, 7297, 7349, 7457, 7459, 7529, 7577, 7589, 7649, 7687, 7699, 7879, 7949, 9029, 9349, 9479, 9679, 10007, 10009, 10039, 10061, 10067, 10069, 10079, 10091, 10151, 10159, 10177, 10247, 10253, 10273, 10321, 10333, 10343, 10391, 10429, 10453, 10457, 10459, 10487, 10499, 10613, 10639, 10651, 10711, 10739, 10781, 10853, 10859, 10867, 10889, 10891, 10909, 10939, 10987, 10993, 11003, 11057, 11071, 11083, 11149, 11159, 11161, 11197, 11243, 11257, 11329, 11353, 11423, 11447, 11489, 11497, 11551, 11579, 11587, 11593, 11621, 11657, 11677, 11699, 11717, 11719, 11731, 11777, 11779, 11783, 11789, 11833, 11839, 11897, 11903, 11909, 11923, 11927, 11933, 11939, 11953, 11959, 11969, 11971, 11981, 12071, 12073, 12107, 12109, 12113, 12119, 12149, 12227, 12241, 12253, 12269, 12289, 12323, 12373, 12437, 12491, 12547, 12553, 12577, 12619, 12641, 12659, 12689, 12697, 12713, 12743, 12757, 12763, 12799, 12809, 12829, 12841, 12893, 12907, 12919, 12983, 13009, 13043, 13147, 13151, 13159, 13163, 13259, 13267, 13291, 13297, 13337, 13441, 13457, 13469, 13477, 13499, 13513, 13523, 13553, 13591, 13597, 13619, 13693, 13697, 13709, 13751, 13757, 13759, 13781, 13789, 13829, 13841, 13873, 13903, 13933, 13963, 14029, 14057, 14071, 14081, 14087, 14107, 14143, 14153, 14177, 14207, 14251, 14293, 14303, 14323, 14327, 14387, 14423, 14447, 14449, 14479, 14519, 14549, 14551, 14557, 14563, 14591, 14593, 14629, 14633, 14657, 14713, 14717, 14843, 14879, 14891, 14897, 14923, 14929, 14939, 14947, 14957, 15013, 15053, 15091, 15139, 15149, 15227, 15263, 15289, 15299, 15307, 15349, 15377, 15383, 15461, 15493, 15497, 15527, 15643, 15649, 15661, 15667, 15679, 15683, 15733, 15737, 15791, 15803, 15907, 15919, 15937, 15973, 16007, 16063, 16073, 16103, 16127, 16193, 16217, 16223, 16249, 16267, 16427, 16433, 16453, 16481, 16493, 16547, 16567, 16573, 16603, 16691, 16699, 16729, 16747, 16763, 16829, 16879, 16883, 16937, 16943, 16979, 17033, 17047, 17117, 17203, 17207, 17209, 17383, 17393, 17417, 17443, 17467, 17477, 17491, 17519, 17573, 17579, 17599, 17627, 17669, 17681, 17683, 17713, 17737, 17747, 17749, 17827, 17839, 17863, 17903, 17909, 17923, 17939, 17959, 18013, 18077, 18089, 18133, 18169, 18191, 18199, 18253, 18269, 18307, 18329, 18353, 18379, 18413, 18427, 18439, 18539, 18593, 18637, 18691, 18719, 18743, 18749, 18757, 18773, 18787, 18803, 18859, 18899, 18913, 19013, 19037, 19163, 19219, 19237, 19249, 19333, 19403, 19423, 19477, 19489, 19543, 19553, 19577, 19687, 19697, 19759, 19763, 19793, 19813, 19913, 19973, 30029, 30059, 30139, 30197, 30223, 30259, 30319, 30323, 30367, 30467, 30517, 30529, 30539, 30557, 30593, 30643, 30649, 30757, 30809, 30853, 30859, 30949, 30983, 31033, 31063, 31069, 31139, 31183, 31193, 31223, 31259, 31267, 31277, 31307, 31327, 31393, 31543, 31627, 31643, 31649, 31723, 31799, 31859, 31873, 31907, 31957, 31963, 32009, 32077, 32099, 32143, 32173, 32189, 32233, 32257, 32299, 32353, 32369, 32377, 32467, 32479, 32497, 32537, 32563, 32579, 32633, 32647, 32687, 32693, 32749, 32783, 32869, 32887, 32933, 32939, 32983, 32999, 33029, 33049, 33199, 33287, 33317, 33329, 33589, 33617, 33767, 33809, 33857, 33863, 34129, 34147, 34159, 34267, 34273, 34367, 34469, 34549, 34583, 34589, 34673, 34687, 34757, 34807, 34847, 34897, 34919, 34963, 35027, 35069, 35083, 35099, 35117, 35129, 35149, 35159, 35227, 35257, 35267, 35317, 35327, 35363, 35419, 35437, 35447, 35537, 35569, 35729, 35969, 35983, 35993, 36037, 36097, 36107, 36109, 36187, 36209, 36217, 36269, 36277, 36373, 36467, 36473, 36479, 36599, 36607, 36739, 36809, 36877, 36973, 37199, 37307, 37309, 37379, 37409, 37489, 37507, 37547, 37549, 37589, 37619, 37847, 37889, 37897, 37997, 38039, 38119, 38219, 38239, 38287, 38327, 38329, 38377, 38393, 38449, 38459, 38557, 38629, 38639, 38707, 38737, 38867, 38917, 38977, 38993, 39047, 39119, 39157, 39217, 39359, 39397, 39419, 39439, 39709, 39749, 39799, 39827, 39829, 39839, 39869, 39877, 39887, 39929, 39989, 70009, 70079, 70249, 70289, 70327, 70439, 70457, 70489, 70529, 70589, 70639, 70667, 70687, 70717, 70729, 70937, 70949, 70969, 70997, 70999, 71069, 71089, 71209, 71257, 71329, 71347, 71359, 71387, 71389, 71399, 71437, 71537, 71569, 71789, 71899, 71909, 72047, 72109, 72229, 72337, 72379, 72497, 72547, 72559, 72577, 72689, 72869, 73277, 73369, 73597, 73819, 73849, 73867, 73939, 74077, 74167, 74197, 74209, 74357, 74377, 74449, 74509, 74609, 74759, 74869, 74897, 74959, 75167, 75169, 75239, 75289, 75329, 75539, 75577, 75629, 75767, 75797, 75869, 76259, 76379, 76387, 76487, 76819, 76829, 76919, 77029, 77339, 77369, 77587, 77797, 77899, 78059, 78139, 78179, 78259, 78439, 78569, 78649, 78697, 78779, 78809, 78839, 78889, 78929, 78979, 79039, 79229, 79309, 79319, 79349, 79379, 79399, 79549, 79559, 79589, 79609, 79669, 79769, 79889, 79939, 90019, 90059, 90089, 90149, 90199, 90499, 90679, 90749, 90989, 91129, 91199, 91229, 91249, 91459, 92189, 92369, 92459, 92479, 92489, 92639, 92779, 92789, 92899, 92959, 93199, 93559, 94169, 94399, 94559, 94889, 95279, 95479, 96179, 96289, 97789, 98299, 98999, 100049, 100129, 100183, 100267, 100271, 100279, 100357, 100379, 100411, 100459, 100483, 100511, 100523, 100537, 100547, 100621, 100673, 100693, 100699, 100799, 100829, 100913, 100957, 100987, 101027, 101119, 101141, 101159, 101207, 101267, 101281, 101293, 101323, 101333, 101383, 101429, 101503, 101531, 101573, 101611, 101627, 101653, 101701, 101719, 101771, 101789, 101869, 101873, 101917, 101977, 101987, 101999, 102019, 102031, 102043, 102061, 102079, 102149, 102161, 102181, 102197, 102199, 102233, 102253, 102293, 102329, 102367, 102409, 102461, 102497, 102523, 102539, 102547, 102551, 102563, 102593, 102607, 102611, 102643, 102677, 102701, 102763, 102769, 102797, 102841, 102877, 102913, 102931, 103049, 103067, 103091, 103123, 103141, 103177, 103183, 103217, 103289, 103307, 103349, 103391, 103393, 103421, 103423, 103457, 103483, 103511, 103613, 103681, 103699, 103703, 103801, 103813, 103837, 103841, 103867, 103919, 103963, 103969, 103997, 104021, 104059, 104087, 104089, 104107, 104147, 104179, 104183, 104347, 104393, 104399, 104479, 104639, 104659, 104677, 104683, 104723, 104743, 104801, 104831, 104849, 104947, 105097, 105137, 105143, 105211, 105251, 105341, 105359, 105373, 105467, 105499, 105529, 105541, 105601, 105613, 105619, 105653, 105667, 105673, 105683, 105691, 105727, 105769, 105871, 105929, 105953, 106087, 106103, 106129, 106187, 106189, 106213, 106217, 106261, 106291, 106297, 106321, 106349, 106367, 106391, 106397, 106411, 106417, 106427, 106531, 106541, 106543, 106621, 106627, 106657, 106661, 106681, 106693, 106699, 106721, 106759, 106787, 106853, 106861, 106871, 106937, 106993, 107071, 107279, 107309, 107351, 107441, 107449, 107453, 107473, 107509, 107603, 107609, 107641, 107687, 107713, 107827, 107881, 107897, 107951, 107981, 108007, 108013, 108089, 108187, 108191, 108193, 108203, 108247, 108263, 108271, 108289, 108343, 108379, 108463, 108517, 108587, 108649, 108677, 108707, 108739, 108761, 108803, 108863, 108869, 108881, 108917, 108923, 108943, 108959, 108971, 109013, 109037, 109063, 109103, 109139, 109199, 109211, 109267, 109279, 109363, 109367, 109379, 109397, 109423, 109471, 109481, 109537, 109579, 109583, 109609, 109663, 109751, 109849, 109859, 109873, 109883, 109891, 109913, 109919, 110023, 110039, 110051, 110119, 110183, 110221, 110233, 110261, 110269, 110281, 110311, 110459, 110543, 110603, 110609, 110641, 110651, 110771, 110777, 110807, 110819, 110879, 110881, 110917, 110921, 110939, 110947, 110969, 110977, 110989, 111043, 111053, 111109, 111119, 111127, 111187, 111211, 111253, 111337, 111341, 111347, 111427, 111439, 111443, 111467, 111497, 111509, 111593, 111637, 111667, 111767, 111781, 111799, 111821, 111829, 111857, 111863, 111869, 111919, 111949, 111953, 111977, 112031, 112067, 112087, 112103, 112163, 112181, 112207, 112213, 112237, 112241, 112247, 112289, 112361, 112363, 112403, 112481, 112559, 112571, 112621, 112663, 112687, 112741, 112759, 112771, 112913, 112979, 113027, 113081, 113083, 113123, 113131, 113143, 113153, 113173, 113189, 113209, 113213, 113227, 113287, 113329, 113537, 113557, 113591, 113621, 113723, 113761, 113797, 113899, 113903, 114031, 114041, 114067, 114073, 114157, 114161, 114197, 114203, 114329, 114343, 114479, 114487, 114493, 114571, 114617, 114649, 114679, 114689, 114713, 114743, 114749, 114833, 114913, 114941, 114967, 115013, 115021, 115067, 115099, 115133, 115163, 115337, 115561, 115603, 115631, 115637, 115663, 115733, 115769, 115771, 115823, 115831, 115877, 115879, 115931, 115987, 116027, 116041, 116107, 116131, 116167, 116273, 116279, 116293, 116351, 116381, 116443, 116483, 116593, 116719, 116747, 116797, 116911, 117053, 117071, 117133, 117167, 117193, 117203, 117241, 117281, 117307, 117329, 117331, 117353, 117413, 117497, 117499, 117577, 117643, 117671, 117703, 117721, 117727, 117757, 117763, 117773, 117787, 117797, 117809, 117841, 117881, 117883, 117889, 118037, 118043, 118081, 118169, 118171, 118189, 118249, 118259, 118361, 118369, 118409, 118423, 118429, 118457, 118493, 118543, 118549, 118571, 118583, 118673, 118709, 118717, 118747, 118757, 118787, 118799, 118843, 118891, 118903, 118913, 118973, 119039, 119089, 119129, 119159, 119183, 119191, 119237, 119293, 119321, 119363, 119389, 119417, 119447, 119489, 119627, 119633, 119773, 119783, 119797, 119809, 119813, 119827, 119869, 119881, 119953, 119983, 119993, 120047, 120097, 120121, 120157, 120193, 120283, 120299, 120371, 120413, 120427, 120503, 120539, 120563, 120641, 120661, 120671, 120709, 120713, 120763, 120779, 120847, 120863, 120871, 120889, 120919, 120937, 120941, 120977, 120997, 121019, 121151, 121267, 121291, 121321, 121369, 121421, 121439, 121453, 121577, 121591, 121609, 121633, 121637, 121697, 121727, 121763, 121921, 121931, 121937, 121949, 122027, 122041, 122051, 122081, 122131, 122149, 122203, 122263, 122279, 122327, 122347, 122443, 122471, 122497, 122533, 122663, 122741, 122761, 122777, 122867, 122891, 122921, 123017, 123091, 123127, 123143, 123217, 123229, 123289, 123307, 123379, 123407, 123419, 123499, 123527, 123553, 123583, 123593, 123667, 123707, 123731, 123817, 123821, 123833, 123887, 123923, 123989, 124087, 124097, 124139, 124181, 124231, 124303, 124309, 124339, 124349, 124351, 124429, 124433, 124489, 124513, 124643, 124739, 124753, 124771, 124777, 124823, 124907, 124919, 124951, 124981, 125053, 125219, 125243, 125299, 125383, 125407, 125507, 125551, 125627, 125639, 125641, 125651, 125659, 125669, 125683, 125791, 125803, 125821, 125863, 125887, 125897, 125941, 126019, 126031, 126067, 126107, 126127, 126199, 126359, 126397, 126443, 126461, 126499, 126517, 126547, 126551, 126583, 126613, 126631, 126653, 126683, 126713, 126743, 126761, 126823, 126851, 126949, 127033, 127051, 127079, 127123, 127207, 127271, 127277, 127373, 127447, 127481, 127493, 127529, 127541, 127637, 127643, 127663, 127679, 127733, 127739, 127763, 127781, 127837, 127849, 127931, 127951, 127973, 128033, 128113, 128257, 128341, 128377, 128399, 128449, 128461, 128477, 128483, 128551, 128603, 128831, 128873, 128879, 128969, 128971, 129049, 129089, 129127, 129193, 129223, 129277, 129281, 129287, 129313, 129347, 129443, 129457, 129497, 129529, 129587, 129589, 129593, 129607, 129629, 129641, 129671, 129737, 129793, 129841, 129893, 129959, 130043, 130069, 130079, 130147, 130199, 130241, 130267, 130279, 130349, 130367, 130369, 130379, 130423, 130517, 130553, 130619, 130633, 130649, 130687, 130693, 130783, 130807, 130843, 130987, 131149, 131171, 131293, 131297, 131437, 131477, 131581, 131591, 131707, 131731, 131743, 131771, 131797, 131959, 131969, 132059, 132071, 132241, 132283, 132287, 132299, 132523, 132547, 132647, 132667, 132679, 132739, 132751, 132763, 132833, 132851, 132857, 132863, 132887, 132953, 132967, 132989, 133033, 133069, 133097, 133103, 133213, 133271, 133283, 133319, 133337, 133379, 133403, 133583, 133649, 133657, 133691, 133709, 133717, 133723, 133853, 133963, 133999, 134033, 134053, 134089, 134177, 134207, 134227, 134257, 134263, 134269, 134291, 134359, 134363, 134371, 134399, 134437, 134471, 134587, 134593, 134609, 134669, 134683, 134699, 134707, 134753, 134777, 134857, 134867, 134923, 134947, 134951, 134999, 135017, 135049, 135059, 135151, 135353, 135389, 135409, 135427, 135461, 135469, 135479, 135497, 135581, 135589, 135599, 135613, 135617, 135647, 135671, 135697, 135781, 135841, 135887, 135977, 136099, 136193, 136217, 136223, 136237, 136277, 136333, 136343, 136373, 136379, 136403, 136471, 136481, 136519, 136523, 136547, 136573, 136607, 136651, 136693, 136861, 136949, 136951, 136987, 136999, 137089, 137117, 137153, 137303, 137359, 137363, 137369, 137519, 137537, 137587, 137639, 137653, 137713, 137743, 137777, 137827, 137831, 137869, 137909, 137941, 137993, 138007, 138041, 138191, 138403, 138461, 138497, 138581, 138763, 138869, 138899, 138959, 139109, 139199, 139291, 139303, 139313, 139339, 139387, 139393, 139397, 139409, 139423, 139457, 139493, 139547, 139591, 139597, 139609, 139619, 139661, 139697, 139871, 139883, 139939, 139943, 139991, 139999, 140143, 140237, 140249, 140269, 140281, 140297, 140333, 140381, 140419, 140453, 140473, 140527, 140603, 140681, 140683, 140759, 140867, 140869, 140983, 141023, 141061, 141067, 141157, 141161, 141179, 141181, 141209, 141307, 141371, 141497, 141499, 141619, 141623, 141653, 141697, 141709, 141719, 141803, 141829, 141833, 141851, 141863, 141871, 141907, 142007, 142049, 142067, 142097, 142151, 142169, 142189, 142297, 142369, 142529, 142567, 142591, 142673, 142757, 142759, 142867, 142873, 142903, 142949, 142993, 143107, 143113, 143159, 143239, 143243, 143249, 143281, 143291, 143329, 143333, 143357, 143461, 143467, 143489, 143527, 143537, 143573, 143743, 143791, 143833, 143909, 143977, 144061, 144071, 144073, 144163, 144167, 144253, 144271, 144299, 144307, 144323, 144407, 144409, 144413, 144427, 144439, 144481, 144541, 144563, 144577, 144791, 144847, 144917, 144941, 144973, 145043, 145063, 145259, 145283, 145349, 145391, 145399, 145433, 145463, 145477, 145487, 145603, 145661, 145777, 145799, 145861, 145879, 145903, 145967, 146033, 146057, 146077, 146161, 146297, 146309, 146323, 146423, 146519, 146563, 146581, 146609, 146683, 146719, 146749, 146777, 146807, 146819, 146891, 146953, 146989, 147029, 147107, 147137, 147229, 147253, 147263, 147289, 147293, 147391, 147503, 147547, 147551, 147583, 147617, 147629, 147661, 147671, 147799, 147997, 148061, 148151, 148157, 148243, 148361, 148399, 148429, 148483, 148573, 148627, 148663, 148747, 148763, 148817, 148867, 148891, 148933, 149053, 149069, 149159, 149173, 149213, 149239, 149251, 149287, 149297, 149333, 149351, 149419, 149423, 149533, 149561, 149563, 149579, 149603, 149623, 149627, 149689, 149827, 149867, 149873, 149893, 149899, 149993, 150091, 150097, 150151, 150217, 150223, 150239, 150299, 150329, 150343, 150379, 150383, 150439, 150523, 150533, 150559, 150607, 150659, 150743, 150767, 150797, 150883, 150889, 150929, 151027, 151057, 151153, 151157, 151169, 151189, 151247, 151289, 151303, 151339, 151379, 151381, 151423, 151429, 151483, 151517, 151549, 151579, 151607, 151651, 151687, 151717, 151783, 151799, 151849, 151871, 151897, 151909, 151967, 152083, 152197, 152213, 152219, 152287, 152293, 152377, 152407, 152423, 152443, 152461, 152519, 152563, 152567, 152597, 152623, 152629, 152657, 152723, 152777, 152833, 152839, 152897, 152981, 152989, 153071, 153247, 153271, 153313, 153337, 153469, 153487, 153557, 153589, 153623, 153689, 153739, 153749, 153871, 153887, 153913, 153947, 154043, 154073, 154097, 154127, 154213, 154229, 154243, 154277, 154333, 154423, 154459, 154487, 154543, 154573, 154589, 154619, 154681, 154727, 154747, 154769, 154897, 154927, 155009, 155153, 155191, 155203, 155303, 155327, 155453, 155509, 155557, 155569, 155579, 155581, 155599, 155671, 155699, 155717, 155777, 155783, 155797, 155849, 155851, 155863, 156061, 156217, 156257, 156371, 156539, 156619, 156671, 156677, 156683, 156703, 156733, 156749, 156781, 156799, 156823, 156887, 156899, 156971, 156979, 157007, 157019, 157061, 157081, 157103, 157109, 157181, 157271, 157273, 157349, 157363, 157427, 157429, 157433, 157457, 157483, 157513, 157523, 157627, 157669, 157733, 157739, 157769, 157793, 157799, 157813, 157867, 157897, 157933, 157991, 158003, 158017, 158071, 158143, 158233, 158293, 158329, 158359, 158371, 158519, 158563, 158567, 158663, 158749, 158759, 158803, 158843, 158867, 158927, 158981, 158993, 159017, 159113, 159119, 159179, 159199, 159223, 159233, 159349, 159389, 159553, 159589, 159617, 159623, 159671, 159697, 159707, 159769, 159793, 159853, 159871, 159899, 159937, 160009, 160033, 160073, 160079, 160087, 160159, 160183, 160243, 160343, 160483, 160619, 160637, 160687, 160789, 160807, 160877, 160981, 160997, 161009, 161047, 161059, 161093, 161159, 161167, 161233, 161263, 161333, 161363, 161407, 161507, 161527, 161561, 161569, 161591, 161639, 161683, 161717, 161729, 161743, 161783, 161807, 161971, 161983, 162017, 162079, 162091, 162209, 162229, 162293, 162343, 162359, 162389, 162391, 162413, 162553, 162593, 162671, 162703, 162727, 162787, 162791, 162859, 162881, 162971, 163019, 163027, 163181, 163327, 163363, 163393, 163409, 163417, 163517, 163633, 163637, 163643, 163697, 163729, 163733, 163781, 163789, 163819, 163847, 163859, 163871, 163979, 163981, 163997, 164149, 164183, 164191, 164233, 164291, 164299, 164357, 164419, 164513, 164587, 164599, 164663, 165047, 165079, 165173, 165229, 165233, 165313, 165343, 165379, 165397, 165449, 165653, 165707, 165709, 165749, 165829, 165857, 165887, 165983, 166027, 166043, 166147, 166157, 166169, 166273, 166409, 166429, 166487, 166597, 166603, 166613, 166669, 166723, 166739, 166781, 166843, 166967, 167009, 167071, 167077, 167099, 167107, 167267, 167309, 167339, 167381, 167393, 167407, 167413, 167471, 167597, 167633, 167771, 167777, 167779, 167861, 167873, 167887, 167891, 167953, 168013, 168023, 168109, 168193, 168269, 168391, 168409, 168433, 168457, 168491, 168523, 168527, 168617, 168677, 168737, 168781, 168899, 168937, 169003, 169067, 169069, 169079, 169093, 169097, 169177, 169199, 169217, 169283, 169313, 169399, 169427, 169483, 169607, 169633, 169649, 169657, 169691, 169769, 169823, 169837, 169957, 169987, 169991, 170063, 170081, 170213, 170243, 170279, 170327, 170447, 170497, 170509, 170537, 170539, 170557, 170579, 170627, 170689, 170707, 170759, 170767, 170773, 170777, 170809, 170837, 170857, 170873, 170887, 170899, 171007, 171047, 171179, 171203, 171271, 171317, 171329, 171383, 171467, 171517, 171553, 171583, 171617, 171629, 171653, 171673, 171697, 171713, 171757, 171823, 171863, 171881, 171929, 171937, 171947, 172049, 172097, 172223, 172279, 172283, 172657, 172681, 172687, 172717, 172829, 172969, 172981, 172993, 173081, 173087, 173099, 173183, 173249, 173263, 173267, 173273, 173297, 173491, 173573, 173647, 173683, 173687, 173713, 173773, 173783, 173807, 173819, 173867, 173909, 174007, 174019, 174091, 174149, 174281, 174329, 174367, 174467, 174487, 174491, 174583, 174599, 174613, 174637, 174673, 174679, 174703, 174767, 174773, 174829, 174893, 174943, 174959, 175013, 175039, 175267, 175277, 175291, 175303, 175349, 175393, 175463, 175481, 175493, 175499, 175523, 175543, 175633, 175699, 175723, 175753, 175843, 175853, 175873, 175891, 175919, 175993, 176047, 176087, 176191, 176207, 176347, 176459, 176549, 176629, 176713, 176753, 176777, 176779, 176809, 176849, 176857, 176903, 176923, 176927, 176933, 176989, 177013, 177019, 177209, 177223, 177257, 177319, 177433, 177473, 177533, 177539, 177691, 177743, 177763, 177787, 177893, 177949, 178067, 178091, 178169, 178223, 178289, 178333, 178349, 178393, 178469, 178537, 178597, 178603, 178681, 178691, 178693, 178697, 178781, 178817, 178859, 178877, 178897, 178907, 178939, 179029, 179083, 179173, 179203, 179209, 179213, 179243, 179269, 179381, 179437, 179453, 179479, 179573, 179581, 179591, 179593, 179657, 179687, 179693, 179719, 179779, 179819, 179827, 179849, 179909, 179939, 179947, 179989, 180007, 180023, 180073, 180181, 180233, 180239, 180263, 180307, 180379, 180533, 180799, 180883, 181063, 181157, 181183, 181199, 181253, 181277, 181397, 181409, 181457, 181459, 181499, 181513, 181523, 181537, 181639, 181693, 181757, 181759, 181763, 181777, 181787, 181813, 181957, 182027, 182029, 182059, 182099, 182159, 182179, 182209, 182243, 182503, 182579, 182639, 182657, 182659, 182813, 182899, 182929, 183167, 183247, 183259, 183263, 183289, 183317, 183343, 183437, 183509, 183527, 183637, 183683, 183809, 183823, 183907, 183919, 183943, 183949, 184003, 184013, 184039, 184043, 184157, 184187, 184189, 184259, 184273, 184279, 184369, 184417, 184487, 184489, 184559, 184607, 184609, 184669, 184703, 184823, 184859, 184903, 184969, 184993, 184997, 185069, 185291, 185303, 185323, 185363, 185369, 185483, 185491, 185539, 185543, 185567, 185593, 185681, 185693, 185723, 185797, 185813, 185819, 185833, 185849, 185893, 185957, 186007, 186103, 186107, 186113, 186119, 186187, 186229, 186239, 186247, 186259, 186317, 186377, 186379, 186649, 186733, 186773, 186799, 186877, 186889, 186917, 186959, 187049, 187133, 187139, 187177, 187217, 187223, 187303, 187339, 187349, 187379, 187387, 187409, 187417, 187423, 187507, 187559, 187669, 187699, 187763, 187823, 187883, 187897, 188107, 188137, 188273, 188359, 188389, 188417, 188519, 188609, 188687, 188693, 188767, 188779, 188827, 188863, 188939, 188957, 189019, 189139, 189149, 189169, 189199, 189307, 189337, 189439, 189473, 189491, 189493, 189547, 189617, 189653, 189697, 189743, 189823, 189913, 189977, 189983, 189989, 190027, 190063, 190129, 190159, 190249, 190357, 190403, 190573, 190577, 190649, 190667, 190717, 190759, 190787, 190807, 190891, 190909, 190997, 191039, 191047, 191137, 191143, 191173, 191237, 191449, 191497, 191507, 191519, 191627, 191657, 191669, 191689, 191707, 191717, 191827, 192013, 192029, 192097, 192113, 192173, 192193, 192229, 192259, 192263, 192373, 192383, 192463, 192529, 192583, 192613, 192617, 192697, 192737, 192757, 192853, 192979, 193093, 193133, 193153, 193189, 193283, 193327, 193337, 193367, 193423, 193447, 193549, 193559, 193573, 193649, 193763, 193789, 193799, 193877, 193883, 193891, 193937, 193939, 193993, 194003, 194017, 194027, 194093, 194149, 194179, 194267, 194377, 194413, 194507, 194569, 194687, 194713, 194717, 194723, 194729, 194809, 194839, 194863, 194867, 194891, 194933, 194963, 195023, 195043, 195047, 195077, 195089, 195103, 195277, 195329, 195343, 195413, 195479, 195539, 195599, 195697, 195737, 195739, 195743, 195809, 195893, 195913, 195919, 195967, 195977, 196003, 196117, 196139, 196169, 196177, 196193, 196277, 196303, 196307, 196379, 196387, 196477, 196499, 196523, 196579, 196613, 196687, 196709, 196727, 196817, 196853, 196873, 196907, 196919, 196993, 197023, 197033, 197059, 197159, 197203, 197233, 197243, 197269, 197347, 197359, 197383, 197389, 197419, 197423, 197453, 197539, 197569, 197597, 197599, 197647, 197779, 197837, 197909, 197927, 197963, 197969, 198047, 198073, 198109, 198127, 198193, 198197, 198223, 198257, 198347, 198439, 198463, 198479, 198529, 198553, 198593, 198613, 198647, 198673, 198733, 198823, 198827, 198929, 198997, 199039, 199103, 199153, 199207, 199247, 199313, 199337, 199417, 199457, 199499, 199559, 199567, 199583, 199603, 199669, 199679, 199739, 199799, 199807, 199933, 300073, 300119, 300163, 300187, 300239, 300277, 300323, 300413, 300589, 300649, 300673, 300719, 300739, 300743, 300809, 300857, 300869, 300929, 300953, 300967, 300977, 300997, 301073, 301183, 301219, 301319, 301333, 301409, 301459, 301463, 301487, 301619, 301703, 301753, 301813, 301933, 301979, 301997, 302123, 302143, 302167, 302213, 302329, 302399, 302459, 302483, 302567, 302573, 302587, 302597, 302609, 302629, 302647, 302723, 302747, 302767, 302779, 302833, 302857, 302909, 302927, 303007, 303119, 303139, 303143, 303217, 303257, 303283, 303367, 303409, 303463, 303469, 303539, 303587, 303593, 303643, 303647, 303679, 303683, 303803, 303817, 303827, 303937, 303983, 303997, 304049, 304193, 304223, 304253, 304279, 304349, 304363, 304393, 304429, 304433, 304439, 304609, 304729, 304757, 304807, 304813, 304849, 304879, 304883, 304897, 304903, 304943, 304979, 305017, 305093, 305119, 305423, 305597, 305603, 305633, 305719, 305783, 305857, 305867, 305873, 305917, 305927, 306133, 306167, 306329, 306349, 306377, 306407, 306473, 306577, 306749, 306763, 306809, 306847, 307033, 307093, 307129, 307169, 307189, 307277, 307283, 307289, 307339, 307399, 307589, 307633, 307687, 307693, 307759, 307817, 307919, 308137, 308153, 308293, 308309, 308323, 308327, 308333, 308437, 308509, 308587, 308597, 308923, 308989, 309079, 309107, 309193, 309269, 309277, 309289, 309317, 309457, 309539, 309599, 309623, 309629, 309637, 309713, 309769, 309853, 309877, 310127, 310129, 310223, 310273, 310507, 310547, 310627, 310643, 310663, 310729, 310733, 310789, 310867, 311137, 311279, 311293, 311299, 311447, 311533, 311537, 311539, 311569, 311653, 311659, 311747, 311827, 311869, 311957, 312023, 312073, 312289, 312349, 312407, 312413, 312469, 312509, 312563, 312589, 312619, 312709, 312887, 312899, 313163, 313207, 313249, 313273, 313343, 313477, 313517, 313567, 313669, 313727, 313763, 313777, 313783, 313829, 313853, 313883, 313889, 313979, 313997, 314107, 314137, 314159, 314219, 314239, 314243, 314257, 314497, 314543, 314627, 314693, 314779, 314879, 314917, 314927, 314933, 315047, 315097, 315109, 315179, 315223, 315247, 315257, 315389, 315409, 315529, 315593, 315599, 315677, 315743, 315779, 315829, 315899, 315937, 315949, 316073, 316087, 316097, 316109, 316133, 316193, 316223, 316297, 316339, 316373, 316439, 316507, 316567, 316577, 316633, 316753, 316783, 316819, 316847, 316853, 316919, 317047, 317179, 317189, 317227, 317333, 317419, 317459, 317599, 317609, 317617, 317663, 317693, 317789, 317827, 317839, 317857, 317969, 317983, 317987, 318077, 318229, 318259, 318337, 318419, 318523, 318557, 318559, 318677, 318743, 318809, 318817, 318823, 318883, 318917, 319027, 319037, 319049, 319117, 319129, 319147, 319327, 319343, 319399, 319469, 319483, 319489, 319499, 319567, 319607, 319819, 319829, 319919, 319927, 319973, 319993, 320027, 320063, 320107, 320119, 320149, 320153, 320237, 320273, 320329, 320377, 320387, 320477, 320539, 320609, 320627, 320647, 320657, 320839, 320927, 321047, 321077, 321143, 321169, 321227, 321323, 321329, 321367, 321397, 321427, 321449, 321509, 321617, 321799, 322057, 322093, 322229, 322249, 322417, 322463, 322519, 322559, 322573, 322583, 322633, 322649, 322709, 322747, 322807, 322877, 322919, 322997, 323087, 323093, 323149, 323207, 323333, 323369, 323579, 323597, 323623, 323699, 323717, 323767, 323879, 323933, 323987, 324053, 324067, 324073, 324089, 324143, 324293, 324437, 324469, 324517, 324529, 324587, 324869, 324893, 324949, 324979, 325019, 325133, 325163, 325187, 325189, 325219, 325379, 325439, 325463, 325477, 325517, 325607, 325693, 325877, 325957, 325993, 326083, 326143, 326159, 326189, 326467, 326567, 326693, 326773, 326867, 326939, 326999, 327059, 327163, 327179, 327209, 327247, 327263, 327319, 327419, 327499, 327553, 327647, 327707, 327779, 327809, 327827, 327853, 327917, 327923, 327967, 327983, 328037, 328063, 328327, 328343, 328373, 328379, 328543, 328579, 328633, 328637, 328687, 328753, 328787, 328847, 328883, 328897, 328919, 329293, 329299, 329333, 329347, 329489, 329587, 329627, 329657, 329663, 329717, 329779, 329867, 329947, 329957, 329969, 330037, 330053, 330097, 330439, 330557, 330587, 330607, 330679, 330749, 330839, 330887, 331027, 331153, 331217, 331337, 331543, 331547, 331579, 331609, 331663, 331883, 331909, 331943, 331973, 331999, 332009, 332147, 332183, 332263, 332317, 332399, 332467, 332477, 332569, 332573, 332729, 332743, 332779, 333029, 333097, 333209, 333227, 333253, 333337, 333397, 333433, 333457, 333563, 333667, 333719, 333769, 333787, 333929, 333959, 333973, 333997, 334093, 334319, 334427, 334637, 334643, 334759, 334777, 334783, 334787, 334793, 334843, 334973, 334993, 335047, 335077, 335383, 335449, 335453, 335507, 335519, 335567, 335633, 335653, 335689, 335693, 335729, 335743, 335809, 335897, 335917, 336059, 336079, 336157, 336199, 336227, 336253, 336263, 336397, 336577, 336689, 336727, 336757, 336767, 336773, 336793, 336857, 336863, 336899, 336997, 337049, 337097, 337153, 337397, 337427, 337489, 337529, 337537, 337543, 337607, 337853, 337873, 337949, 338167, 338237, 338279, 338347, 338383, 338407, 338449, 338477, 338573, 338687, 338747, 338893, 338909, 339067, 339137, 339139, 339257, 339653, 339673, 339679, 339707, 339727, 339799, 339887, 339943, 340079, 340127, 340369, 340387, 340397, 340429, 340447, 340453, 340573, 340577, 340643, 340657, 340693, 340787, 340789, 340859, 340897, 340909, 340999, 341179, 341293, 341347, 341357, 341477, 341543, 341557, 341587, 341617, 341659, 341743, 341777, 341927, 341947, 341953, 341959, 341963, 342187, 342343, 342359, 342389, 342547, 342593, 342599, 342647, 342653, 342757, 342863, 342889, 342899, 342949, 343087, 343153, 343199, 343219, 343289, 343373, 343547, 343579, 343727, 343799, 343817, 343943, 343997, 344017, 344053, 344167, 344189, 344263, 344273, 344293, 344353, 344417, 344453, 344479, 344599, 344653, 344693, 344719, 344819, 344843, 344863, 344969, 344987, 345139, 345329, 345463, 345487, 345547, 345643, 345689, 345707, 345757, 345773, 345979, 345997, 346079, 346169, 346369, 346429, 346453, 346553, 346793, 346867, 346877, 347059, 347129, 347317, 347329, 347437, 347579, 347729, 347747, 347899, 347929, 347969, 347983, 347989, 348053, 348077, 348083, 348097, 348163, 348217, 348259, 348367, 348419, 348583, 348629, 348637, 348709, 348769, 348827, 348839, 349079, 349183, 349199, 349369, 349373, 349399, 349493, 349529, 349579, 349667, 349819, 349849, 349927, 349967, 350029, 350137, 350159, 350179, 350219, 350257, 350293, 350587, 350657, 350663, 350719, 350737, 350747, 350789, 350809, 351047, 351179, 351293, 351383, 351427, 351457, 351469, 351497, 351517, 351529, 351587, 351707, 351829, 351863, 351887, 351919, 351929, 352109, 352267, 352369, 352399, 352459, 352483, 352489, 352589, 352607, 352739, 352883, 352909, 352949, 353057, 353069, 353117, 353173, 353179, 353263, 353317, 353453, 353489, 353567, 353629, 353737, 353777, 353797, 353807, 353819, 353867, 353869, 353917, 353963, 354149, 354169, 354329, 354373, 354377, 354667, 354677, 354763, 354799, 354829, 354839, 354847, 354997, 355009, 355037, 355049, 355057, 355087, 355093, 355193, 355297, 355339, 355427, 355573, 355679, 355697, 355799, 355937, 355967, 356039, 356093, 356479, 356647, 356819, 356947, 356999, 357083, 357179, 357263, 357319, 357473, 357517, 357587, 357649, 357677, 357737, 357793, 357989, 357997, 358157, 358219, 358229, 358277, 358417, 358427, 358459, 358499, 358697, 358747, 358783, 358867, 358879, 358907, 358973, 358993, 358999, 359063, 359209, 359263, 359377, 359449, 359663, 359747, 359783, 359837, 359929, 360169, 360187, 360193, 360289, 360497, 360589, 360637, 360869, 360977, 360979, 361279, 361499, 361507, 361577, 361649, 361763, 361799, 361807, 361873, 361877, 361973, 361979, 361993, 362093, 362293, 362339, 362347, 362449, 362459, 362749, 362759, 362867, 362897, 363037, 363059, 363119, 363157, 363269, 363373, 363497, 363577, 363683, 363719, 363757, 363809, 363887, 363959, 364073, 364129, 364373, 364417, 364607, 364627, 364657, 364669, 364717, 364739, 364747, 364829, 364873, 364879, 364909, 364937, 365129, 365147, 365179, 365297, 365327, 365467, 365479, 365489, 365689, 365699, 365747, 365759, 365773, 365839, 365983, 366077, 366127, 366169, 366173, 366199, 366227, 366239, 366277, 366293, 366307, 366409, 366437, 366599, 366869, 366907, 366967, 366973, 366983, 367027, 367069, 367219, 367273, 367307, 367369, 367519, 367597, 367687, 367699, 367819, 367889, 367957, 368029, 368077, 368107, 368369, 368507, 368729, 368947, 369007, 369029, 369269, 369293, 369673, 369793, 369877, 370169, 370193, 370199, 370247, 370373, 370477, 370493, 370529, 370537, 370619, 370793, 370879, 371027, 371057, 371069, 371087, 371227, 371339, 371389, 371617, 371699, 371719, 371837, 371869, 371897, 371927, 371957, 372067, 372179, 372277, 372289, 372377, 372629, 372637, 372667, 372797, 372829, 372847, 372973, 372979, 373183, 373193, 373349, 373357, 373379, 373393, 373487, 373517, 373657, 373669, 373693, 373777, 373837, 373937, 374029, 374047, 374177, 374189, 374239, 374287, 374293, 374359, 374483, 374537, 374557, 374789, 374797, 374807, 374879, 374893, 374987, 374993, 375017, 375049, 375149, 375259, 375367, 375457, 375673, 375707, 375787, 375799, 375857, 375997, 376009, 376099, 376183, 376237, 376307, 376417, 376483, 376547, 376609, 376639, 376657, 376687, 376793, 376949, 377197, 377219, 377329, 377477, 377737, 377749, 377999, 378193, 378283, 378317, 378449, 378593, 378667, 378977, 378997, 379009, 379039, 379087, 379147, 379177, 379187, 379199, 379289, 379369, 379459, 379607, 379699, 379787, 379817, 379849, 379859, 379909, 380059, 380287, 380377, 380383, 380447, 380729, 380837, 380839, 380929, 380983, 381077, 381167, 381169, 381287, 381289, 381319, 381487, 381559, 381607, 381629, 381737, 381749, 381793, 381817, 381859, 381917, 381937, 382037, 382189, 382229, 382429, 382457, 382519, 382567, 382747, 382807, 382847, 382979, 383069, 383099, 383107, 383297, 383393, 383429, 383483, 383489, 383609, 383659, 383683, 383777, 383797, 383837, 383909, 384017, 384049, 384187, 384257, 384359, 384497, 384589, 384737, 384889, 385039, 385079, 385087, 385159, 385249, 385267, 385393, 385709, 385837, 386017, 386119, 386149, 386279, 386429, 386677, 386777, 386987, 387169, 387197, 387227, 387269, 387509, 387529, 387749, 387799, 387857, 388187, 388259, 388693, 388699, 388859, 388879, 389027, 389057, 389117, 389167, 389189, 389227, 389287, 389297, 389299, 389357, 389399, 389479, 389527, 389567, 389569, 389629, 389687, 389839, 389867, 389999, 390067, 390097, 390109, 390359, 390367, 390499, 390539, 390889, 390959, 391159, 391219, 391247, 391387, 391537, 391579, 391679, 391789, 391939, 392069, 392099, 392177, 392297, 392339, 392467, 392549, 392593, 392629, 392669, 392699, 392737, 392767, 392807, 392827, 392849, 392927, 392929, 392957, 393007, 393059, 393247, 393287, 393299, 393377, 393539, 393557, 393577, 393667, 393709, 393857, 393859, 393919, 393929, 393947, 394187, 394327, 394367, 394507, 394579, 394747, 394817, 394987, 394993, 395039, 395069, 395089, 395107, 395119, 395137, 395147, 395407, 395657, 395719, 395737, 395849, 396199, 396217, 396349, 396377, 396437, 396509, 396709, 396919, 396937, 397027, 397127, 397297, 397337, 397357, 397429, 397469, 397597, 397757, 397799, 397829, 397867, 397939, 398119, 398207, 398267, 398339, 398417, 398467, 398569, 398627, 398669, 398857, 398917, 399059, 399067, 399197, 399389, 399527, 399719, 399757, 399787, 399887, 700027, 700067, 700109, 700129, 700387, 700459, 700577, 700597, 700627, 700639, 700849, 701089, 701159, 701257, 701329, 701399, 701417, 701479, 701609, 701627, 701837, 702017, 702077, 702127, 702179, 702239, 702257, 702469, 702497, 702587, 702607, 702787, 702827, 702847, 703117, 703127, 703349, 703357, 703459, 703489, 703499, 703537, 703559, 703679, 703907, 703949, 704027, 704029, 704279, 704309, 704399, 704447, 704569, 704687, 704719, 704747, 704779, 704849, 705119, 705169, 705209, 705247, 705259, 705689, 705737, 705769, 705779, 705937, 705989, 706009, 706049, 706067, 706309, 706369, 706679, 706757, 706829, 706907, 707029, 707099, 707117, 707299, 707359, 707437, 707627, 707689, 707767, 707849, 707857, 707939, 708137, 708229, 708269, 708437, 708527, 708559, 708647, 708667, 708839, 708859, 708979, 708997, 709139, 709409, 709417, 709879, 709909, 709927, 710189, 710449, 710519, 710839, 710987, 711089, 711187, 711259, 711317, 711409, 711427, 711617, 711679, 711839, 711899, 711937, 711967, 712157, 712199, 712219, 712237, 712289, 712319, 712339, 712409, 712477, 712697, 712837, 712847, 712889, 712909, 712927, 713227, 713239, 713389, 713467, 713477, 713569, 713827, 713939, 714139, 714227, 714377, 714479, 714517, 714577, 714619, 714797, 714809, 714827, 714919, 715109, 715189, 715229, 715397, 715439, 715577, 715849, 716389, 716399, 716629, 716659, 716809, 716857, 716899, 716959, 717047, 717089, 717109, 717229, 717397, 717449, 717539, 717817, 717917, 717979, 718049, 718087, 718169, 718187, 718547, 718847, 718919, 719009, 719057, 719119, 719177, 719179, 719239, 719267, 719447, 719597, 719639, 719749, 719989, 720089, 720179, 720229, 720319, 720367, 720547, 720869, 720877, 720887, 720899, 720947, 721087, 721139, 721199, 721337, 721439, 721597, 721619, 721687, 721739, 722047, 722077, 722119, 722147, 722167, 722369, 722509, 722599, 722639, 722669, 723049, 723089, 723119, 723157, 723319, 723467, 723727, 723799, 723859, 723977, 724187, 724597, 724609, 724747, 724769, 724879, 724949, 725077, 725119, 725189, 725357, 725399, 725449, 725519, 725587, 725597, 725639, 725827, 725897, 725929, 726157, 726169, 726367, 726457, 726487, 726797, 726809, 727049, 727157, 727249, 727409, 727459, 727487, 727729, 727799, 727877, 727879, 727997, 728209, 728579, 728639, 728747, 728837, 728839, 728869, 729059, 729199, 729367, 729569, 729637, 729689, 729719, 729737, 729749, 729779, 729877, 729919, 729947, 729977, 730199, 730297, 730399, 730559, 730637, 730747, 730799, 730879, 730909, 730969, 731057, 731189, 731209, 731257, 731287, 731447, 731509, 731567, 731729, 731869, 732079, 732157, 732229, 732709, 732877, 732889, 732959, 733147, 733289, 733387, 733477, 733489, 733559, 733619, 733687, 733697, 733829, 733847, 733879, 733919, 733937, 734057, 734159, 734177, 734189, 734329, 734429, 734479, 734557, 734567, 734869, 735067, 735139, 735239, 735247, 735439, 735479, 735739, 735877, 736039, 736097, 736159, 736249, 736279, 736409, 736447, 736469, 736679, 736699, 736847, 736937, 737039, 737047, 737059, 737119, 737129, 737479, 737719, 737747, 737819, 737897, 737929, 738349, 738379, 738487, 738499, 738547, 738677, 738889, 738977, 738989, 739069, 739549, 739759, 740087, 740279, 740329, 740477, 740687, 741079, 741119, 741409, 741479, 741509, 741569, 741599, 741679, 741869, 741967, 742229, 742499, 742519, 742657, 742697, 742757, 742759, 742909, 742967, 743059, 743167, 743209, 743279, 743669, 743819, 743947, 743989, 744019, 744077, 744199, 744239, 744377, 744389, 744397, 744539, 744599, 745357, 745379, 745397, 745747, 745859, 746069, 746129, 746267, 746509, 746597, 746747, 746749, 746797, 746869, 746989, 747139, 747157, 747599, 747839, 747977, 747979, 748039, 748169, 748249, 748339, 748567, 748609, 748729, 748849, 748877, 748987, 749149, 749299, 749467, 749587, 749677, 749899, 750077, 750097, 750157, 750229, 750287, 750457, 750787, 750797, 750809, 750929, 751367, 751579, 751669, 751879, 752197, 752449, 752459, 752699, 752819, 753187, 753229, 753409, 753569, 753587, 753659, 753677, 753799, 753859, 754067, 754109, 754367, 754489, 754549, 754709, 754829, 754969, 754979, 755077, 755239, 755267, 755387, 755399, 755719, 755759, 755869, 756139, 756419, 756467, 756629, 756709, 757429, 757577, 757709, 758179, 758299, 758449, 758579, 758699, 758767, 758819, 758867, 758899, 758987, 759019, 759029, 759089, 759397, 759559, 759599, 759709, 759797, 760169, 760229, 760289, 760297, 760367, 760499, 760519, 760897, 761119, 761249, 761459, 761489, 761777, 761779, 761939, 762367, 762389, 762577, 762919, 762959, 763159, 763349, 763369, 763549, 763579, 763619, 763649, 763699, 763859, 764149, 764189, 764399, 764629, 764887, 764969, 764989, 765097, 765109, 765169, 765199, 765329, 765439, 765949, 766039, 766079, 766229, 766369, 766477, 766639, 766739, 766769, 766877, 766999, 767509, 767549, 767867, 767909, 768059, 768199, 768377, 768409, 768419, 768479, 768589, 768629, 769159, 769259, 769289, 769309, 769339, 769429, 769469, 769579, 769729, 769987, 770039, 770069, 770179, 770359, 770387, 770449, 770597, 770929, 771019, 771109, 771179, 771269, 771569, 771619, 771679, 771697, 772019, 772097, 772159, 772169, 772279, 772297, 772349, 772379, 772439, 772459, 773029, 773599, 773609, 773659, 773849, 773869, 773939, 773987, 773989, 773999, 774577, 774679, 774959, 775189, 775639, 775739, 775889, 775987, 776029, 776449, 776569, 776599, 776729, 776819, 776887, 776969, 777169, 777199, 777209, 777349, 777389, 777419, 777787, 777859, 777877, 777989, 778079, 778597, 778697, 778759, 778769, 778819, 779039, 779069, 779329, 779579, 779797, 780049, 780119, 780287, 780499, 780887, 781199, 781369, 781397, 781619, 782009, 782129, 782189, 782219, 782689, 782849, 783197, 783329, 783379, 783487, 783529, 783599, 783619, 784219, 784229, 784379, 784649, 784697, 784859, 784897, 784939, 785269, 785549, 786109, 786319, 786329, 786449, 786697, 786719, 786859, 786887, 786949, 787079, 787469, 787769, 788089, 788129, 788159, 788189, 788399, 788419, 788449, 788479, 788497, 788549, 788719, 788849, 788897, 788959, 789389, 789749, 789979, 790169, 790289, 790369, 790429, 790459, 790529, 790589, 790897, 790969, 791029, 791309, 791519, 791569, 791699, 791897, 791899, 791929, 792049, 792359, 792397, 792709, 792769, 793099, 793189, 793379, 793399, 793489, 793769, 794239, 794449, 794509, 794579, 795139, 795239, 795589, 795799, 795829, 796189, 796409, 796459, 797009, 797579, 798089, 798799, 798929, 799259, 799529, 799789, 799949, 900149, 900259, 900349, 900929, 900959, 901169, 901309, 901429, 901529, 901679, 901819, 901919, 902029, 902389, 902669, 902719, 902789, 903179, 903269, 903449, 904219, 904459, 904759, 904919, 905249, 905269, 905329, 906029, 906779, 906929, 906949, 907019, 907139, 907259, 907369, 907589, 907759, 908549, 908909, 908959, 909019, 909089, 909289, 909599, 909679, 909889, 909899, 910069, 910369, 910799, 910849, 910939, 911039, 911269, 911749, 912089, 912239, 912349, 912469, 912799, 912839, 912959, 912979, 913139, 913279, 913639, 913799, 913889, 914189, 914239, 914369, 914429, 915029, 915589, 915869, 915919, 916049, 916169, 916259, 916879, 917039, 917089, 917459, 917689, 918389, 918539, 918779, 918829, 918899, 919129, 919189, 919559, 919679, 919769, 919969, 919979, 920279, 920789, 920849, 920999, 921199, 921259, 921379, 921589, 921629, 921749, 921839, 921889, 922039, 922069, 922499, 922729, 922739, 923449, 923599, 923869, 924299, 924659, 924769, 924829, 925979, 926899, 927089, 927869, 928079, 928159, 928289, 928469, 928859, 929389, 929459, 929549, 930179, 930469, 930499, 930859, 931169, 931849, 932749, 932779, 932879, 932969, 932999, 934259, 934579, 934669, 934799, 934889, 934939, 934979, 935359, 935489, 935639, 935699, 935899, 936179, 936679, 936739, 937049, 937789, 938059, 938369, 938879, 938939, 938989, 939179, 939469, 939989, 940189, 940249, 940399, 940469, 940879, 941179, 941359, 941449, 941489, 941669, 941879, 941999, 942479, 942569, 943769, 943849, 944389, 945089, 945179, 946459, 946579, 946949, 947659, 948659, 949759, 949979, 950569, 951089, 951479, 951859, 951959, 952279, 952859, 953969, 954269, 954379, 954869, 955469, 956569, 956689, 956759, 956789, 957289, 957889, 957959, 959269, 959479, 959489, 959689, 959869, 960199, 960389, 960499, 960889, 961099, 961399, 962779, 963499, 963689, 963779, 963799, 963979, 965179, 965189, 965969, 966379, 967289, 967999, 970279, 970789, 971099, 971389, 971479, 972679, 972799, 974879, 974989, 975089, 975199, 975389, 978799, 979189, 979889, 982099, 985399, 985799, 988199, 989099, 990799, 991499, 991999, 995699]
newlist = []
for item in thelist:
newlist.append(item)
newlist.append(int("".join(reversed(list(str(item))))))
newlist.sort()
print(newlist[int(input())-1])
``` | output | 1 | 21,465 | 20 | 42,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
qd ucyhf yi q fhycu dkcruh mxeiu huluhiu yi q tyvvuhudj fhycu dkcruh. oekh jqia yi je vydt jxu djx ucyhf.
Input
jxu ydfkj sediyiji ev q iydwbu ydjuwuh d (1 ≤ d ≤ 11184) — jxu edu-rqiut ydtun ev jxu ucyhf je vydt.
Output
ekjfkj q iydwbu dkcruh.
Examples
Input
1
Output
13 | instruction | 0 | 21,466 | 20 | 42,932 |
Tags: *special, brute force, implementation, number theory
Correct Solution:
```
def f(n):
i = 2
while i*i <= n:
if n%i == 0:
return False
i += 1
return True
n = int(input())
for i in range(10,1000000):
if i != int(str(i)[::-1]) and f(i) and f(int(str(i)[::-1])):
n -= 1
if n == 0:
print(i)
break
``` | output | 1 | 21,466 | 20 | 42,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
qd ucyhf yi q fhycu dkcruh mxeiu huluhiu yi q tyvvuhudj fhycu dkcruh. oekh jqia yi je vydt jxu djx ucyhf.
Input
jxu ydfkj sediyiji ev q iydwbu ydjuwuh d (1 ≤ d ≤ 11184) — jxu edu-rqiut ydtun ev jxu ucyhf je vydt.
Output
ekjfkj q iydwbu dkcruh.
Examples
Input
1
Output
13 | instruction | 0 | 21,470 | 20 | 42,940 |
Tags: *special, brute force, implementation, number theory
Correct Solution:
```
import sys
def main():
nb=1000*1000
tab=[True]*(nb+1)
#sys.stdout.write("0\n1\n")
premier = [2]
tab[0]=False;
tab[1]=False;
for i in range(2,nb+1):
if tab[i]:
#print(i)
j=i*i
while j<nb+1:
tab[j]=False
j+=i
cible=int(input())
x=0
for i in range(nb):
if tab[i]:
rev=int(str(i)[::-1])
if (rev<nb and rev!=i and tab[rev]):
x+=1
if(x==cible):
print(i)
return
main()
``` | output | 1 | 21,470 | 20 | 42,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ilya the Lion wants to help all his friends with passing exams. They need to solve the following problem to pass the IT exam.
You've got string s = s1s2... sn (n is the length of the string), consisting only of characters "." and "#" and m queries. Each query is described by a pair of integers li, ri (1 ≤ li < ri ≤ n). The answer to the query li, ri is the number of such integers i (li ≤ i < ri), that si = si + 1.
Ilya the Lion wants to help his friends but is there anyone to help him? Help Ilya, solve the problem.
Input
The first line contains string s of length n (2 ≤ n ≤ 105). It is guaranteed that the given string only consists of characters "." and "#".
The next line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains the description of the corresponding query. The i-th line contains integers li, ri (1 ≤ li < ri ≤ n).
Output
Print m integers — the answers to the queries in the order in which they are given in the input.
Examples
Input
......
4
3 4
2 3
1 6
2 6
Output
1
1
5
4
Input
#..###
5
1 3
5 6
1 5
3 6
3 4
Output
1
1
2
2
0 | instruction | 0 | 21,520 | 20 | 43,040 |
Tags: dp, implementation
Correct Solution:
```
from collections import deque, defaultdict, Counter
from itertools import product, groupby, permutations, combinations, accumulate
from math import gcd, floor, inf, log2, sqrt, log10
from bisect import bisect_right, bisect_left
from statistics import mode
from string import ascii_uppercase
s = input()
ln = len(s)-1
pre_sum = [0]
for i in range(ln):
if s[i] == s[i+1]:
pre_sum.append(pre_sum[-1]+1)
else:
pre_sum.append(pre_sum[-1])
cases = int(input())
for _ in range(cases):
l, r = map(int, input().split())
print(pre_sum[r-1] - pre_sum[l-1])
``` | output | 1 | 21,520 | 20 | 43,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ilya the Lion wants to help all his friends with passing exams. They need to solve the following problem to pass the IT exam.
You've got string s = s1s2... sn (n is the length of the string), consisting only of characters "." and "#" and m queries. Each query is described by a pair of integers li, ri (1 ≤ li < ri ≤ n). The answer to the query li, ri is the number of such integers i (li ≤ i < ri), that si = si + 1.
Ilya the Lion wants to help his friends but is there anyone to help him? Help Ilya, solve the problem.
Input
The first line contains string s of length n (2 ≤ n ≤ 105). It is guaranteed that the given string only consists of characters "." and "#".
The next line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains the description of the corresponding query. The i-th line contains integers li, ri (1 ≤ li < ri ≤ n).
Output
Print m integers — the answers to the queries in the order in which they are given in the input.
Examples
Input
......
4
3 4
2 3
1 6
2 6
Output
1
1
5
4
Input
#..###
5
1 3
5 6
1 5
3 6
3 4
Output
1
1
2
2
0 | instruction | 0 | 21,524 | 20 | 43,048 |
Tags: dp, implementation
Correct Solution:
```
s=input();n=int(input());l=len(s);a=[0]*l;ans=''
for i in range(l-1):
a[i+1]=a[i]+(s[i]==s[i+1])
for i in range(n):
c,d=map(int,input().split())
ans+=str(a[d-1]-a[c-1])+'\n'
print(ans)
# Made By Mostafa_Khaled
``` | output | 1 | 21,524 | 20 | 43,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ilya the Lion wants to help all his friends with passing exams. They need to solve the following problem to pass the IT exam.
You've got string s = s1s2... sn (n is the length of the string), consisting only of characters "." and "#" and m queries. Each query is described by a pair of integers li, ri (1 ≤ li < ri ≤ n). The answer to the query li, ri is the number of such integers i (li ≤ i < ri), that si = si + 1.
Ilya the Lion wants to help his friends but is there anyone to help him? Help Ilya, solve the problem.
Input
The first line contains string s of length n (2 ≤ n ≤ 105). It is guaranteed that the given string only consists of characters "." and "#".
The next line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains the description of the corresponding query. The i-th line contains integers li, ri (1 ≤ li < ri ≤ n).
Output
Print m integers — the answers to the queries in the order in which they are given in the input.
Examples
Input
......
4
3 4
2 3
1 6
2 6
Output
1
1
5
4
Input
#..###
5
1 3
5 6
1 5
3 6
3 4
Output
1
1
2
2
0 | instruction | 0 | 21,525 | 20 | 43,050 |
Tags: dp, implementation
Correct Solution:
```
import sys
from math import sqrt
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
str = input()
n = len(str)
m = int(input())
dp = [0]*(n+1)
for i in range(1,n):
if str[i-1] == str[i]:
dp[i+1] = dp[i]+1
else:
dp[i+1] = dp[i]
#print(dp)
for i in range(m):
l,r = map(int,input().split())
print(dp[r]-dp[l])
``` | output | 1 | 21,525 | 20 | 43,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important. | instruction | 0 | 21,756 | 20 | 43,512 |
Tags: implementation
Correct Solution:
```
# https://codeforces.com/problemset/problem/994/A
n, m = input().split()
sequence = input().split()
finger = tuple(input().split())
for i in sequence:
if i in finger:
print(i, end=" ")
``` | output | 1 | 21,756 | 20 | 43,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important. | instruction | 0 | 21,757 | 20 | 43,514 |
Tags: implementation
Correct Solution:
```
from math import ceil, log
t = 1
for test in range(t):
n,m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = []
for key in a:
if key in b:
ans.append(key)
print(*ans)
``` | output | 1 | 21,757 | 20 | 43,515 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important. | instruction | 0 | 21,758 | 20 | 43,516 |
Tags: implementation
Correct Solution:
```
n, m = map(int, input().split(' '))
x = list(map(int, input().split(' ')))
y = list(map(int, input().split(' ')))
for i in range(n):
if x[i] in y:
print(x[i], end= ' ')
``` | output | 1 | 21,758 | 20 | 43,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important. | instruction | 0 | 21,759 | 20 | 43,518 |
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
a=[int(i) for i in input().split()]
ans=[]
b=[int(i) for i in input().split()]
s=[0 for i in range(11)]
for i in b:
s[i]=1
for i in a:
if s[i]==1:
ans.append(i)
print(*ans,sep=" ")
``` | output | 1 | 21,759 | 20 | 43,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important. | instruction | 0 | 21,760 | 20 | 43,520 |
Tags: implementation
Correct Solution:
```
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = {}
for x in map(int, input().split()):
b[x] = 1
for x in a:
if x in b:
print(x, end=' ')
``` | output | 1 | 21,760 | 20 | 43,521 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important. | instruction | 0 | 21,761 | 20 | 43,522 |
Tags: implementation
Correct Solution:
```
mat=[]
num_dig_keys=input().split()
num_dig_keys=list(map(int,num_dig_keys))
if(num_dig_keys[0]>=1 and num_dig_keys[1]<=10):
if len(num_dig_keys)>2:
print("enter correctly the the number of digits in sequence and number of keys on the keypad having finger print")
exit(0)
sequence=(input().split())
sequence=list(map(int,sequence))
for x in sequence:
if x>9:
exit(0)
if len(sequence)>num_dig_keys[0]:
print("enter correctly the number of digits in the sequence")
exit(0)
fin_print=(input().split())
fin_print=list(map(int,fin_print))
for x in sequence:
if x>9:
exit(0)
if len(sequence)>num_dig_keys[0]:
print("enter correctly the number of digits having fingerprint")
exit(0)
for x in sequence:
for y in fin_print:
if y==x:
mat.append(y)
for z in mat:
print(z,end=" ")
``` | output | 1 | 21,761 | 20 | 43,523 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important. | instruction | 0 | 21,762 | 20 | 43,524 |
Tags: implementation
Correct Solution:
```
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = set(list(map(int, input().split())))
res = []
for i in range(n):
if a[i] in b:
res.append(a[i])
print(' '.join(list(map(str, res))))
``` | output | 1 | 21,762 | 20 | 43,525 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important. | instruction | 0 | 21,763 | 20 | 43,526 |
Tags: implementation
Correct Solution:
```
n,m = map(int,input().split())
list1 = list(map(int,input().split()))
list2 = list(map(int,input().split()))
list3 = []
for _ in range(n):
for i in range(m):
if(list1[_] == list2[i]):
list3.append(list1[_])
print(*list3,sep = ' ')
``` | output | 1 | 21,763 | 20 | 43,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important.
Submitted Solution:
```
nm=list(map(int,input().split()))
n=nm[0]
m=nm[1]
q=list(map(int,input().split()))
p=list(map(int,input().split()))
l=[]
for i in p:
if(i in q):
l.append(q.index(i))
l.sort()
for k in l:
print(q[k],end=' ')
``` | instruction | 0 | 21,764 | 20 | 43,528 |
Yes | output | 1 | 21,764 | 20 | 43,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important.
Submitted Solution:
```
n,m=map(int,input().split())
x=list(map(int,input().split()))
y=list(map(int,input().split()))
b=[100000]*10
for j in range(n):
b[x[j]]=j
c=[0]*m
for i in range(m):
c[i]=b[y[i]]
cc=sorted(zip(c,y))
#print(cc)
for i in range(m):
if(cc[i][0]==100000):
break
print(cc[i][1],end=" ")
``` | instruction | 0 | 21,765 | 20 | 43,530 |
Yes | output | 1 | 21,765 | 20 | 43,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important.
Submitted Solution:
```
n, m = map(int, input().split())
ans = ""
x = [0]*n
y = [0]*m
x = input().split()
y = input().split()
for i in range(n): x[i] = int(x[i])
for i in range(m): y[i] = int(y[i])
i = 0
j = 0
while (j<m) and (i<n):
if x[i] in y:
ans = ans + str(x[i]) + " "
j+=1
i+=1
print(ans)
``` | instruction | 0 | 21,766 | 20 | 43,532 |
Yes | output | 1 | 21,766 | 20 | 43,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important.
Submitted Solution:
```
n, m = [int(x) for x in input().split()]
seq = [int(x) for x in input().split()]
fig = [int(x) for x in input().split()]
code = []
for i in seq:
if i in fig:
code.append(i)
if len(code)>0:
print(*code)
else:
print()
``` | instruction | 0 | 21,767 | 20 | 43,534 |
Yes | output | 1 | 21,767 | 20 | 43,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important.
Submitted Solution:
```
input()
X, Y = input().split(), input().split()
print(filter(lambda x: x in Y, X))
``` | instruction | 0 | 21,768 | 20 | 43,536 |
No | output | 1 | 21,768 | 20 | 43,537 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important.
Submitted Solution:
```
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ans=[]
for i in range (0,m):
for j in range(0,n):
if(b[i]==a[j]):
ans.append(b[i])
break
ans.sort()
ans.reverse()
for i in range(0,len(ans)):
print(ans[i],end=' ')
``` | instruction | 0 | 21,769 | 20 | 43,538 |
No | output | 1 | 21,769 | 20 | 43,539 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important.
Submitted Solution:
```
n, m = map(int, input().split())
x = [int(i) for i in input().split()]
y = [int(i) for i in input().split()]
r = []
for i in y:
if i in x:
r.append(x.index(i))
else:
break
r.sort()
print(" ".join(str(x[i]) for i in r))
``` | instruction | 0 | 21,770 | 20 | 43,540 |
No | output | 1 | 21,770 | 20 | 43,541 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subsequence of the sequence you have that only contains digits with fingerprints on the corresponding keys. Find such code.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains n distinct space-separated integers x_1, x_2, …, x_n (0 ≤ x_i ≤ 9) representing the sequence.
The next line contains m distinct space-separated integers y_1, y_2, …, y_m (0 ≤ y_i ≤ 9) — the keys with fingerprints.
Output
In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable.
Examples
Input
7 3
3 5 7 1 6 2 8
1 2 7
Output
7 1 2
Input
4 4
3 4 1 0
0 1 7 9
Output
1 0
Note
In the first example, the only digits with fingerprints are 1, 2 and 7. All three of them appear in the sequence you know, 7 first, then 1 and then 2. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits 0, 1, 7 and 9 have fingerprints, however only 0 and 1 appear in the original sequence. 1 appears earlier, so the output is 1 0. Again, the order is important.
Submitted Solution:
```
a, b = map(int, input().split())
n = list(map(int, input().split()))
m = list(map(int, input().split()))
res = []
if a >= b:
for x in n:
if x in m:
res.append(x)
if b > a:
for x in m:
if x in n:
res.append(x)
c = res
print(*c)
``` | instruction | 0 | 21,771 | 20 | 43,542 |
No | output | 1 | 21,771 | 20 | 43,543 |
Provide a correct Python 3 solution for this coding contest problem.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3 | instruction | 0 | 21,937 | 20 | 43,874 |
"Correct Solution:
```
# Aizu Problem 0188: Search
#
import sys, math, os, bisect
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def search(n, A, s):
cnt = 0
left, right = 0, n - 1
while left <= right:
mid = (left + right) // 2
cnt += 1
if A[mid] == s:
return cnt
elif A[mid] > s:
right = mid - 1
else:
left = mid + 1
return cnt
while True:
n = int(input())
if n == 0:
break
A = [int(input()) for _ in range(n)]
s = int(input())
print(search(n, A, s))
``` | output | 1 | 21,937 | 20 | 43,875 |
Provide a correct Python 3 solution for this coding contest problem.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3 | instruction | 0 | 21,938 | 20 | 43,876 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0188
"""
import sys
from sys import stdin
input = stdin.readline
def b_search(data, k):
count = 0
l = 0
r = len(data) - 1
while r >= l:
count += 1
mid = (l + r) // 2
if data[mid] == k:
break
if data[mid] > k:
r = mid - 1
else:
l = mid + 1
return count
def main(args):
while True:
n = int(input())
if n == 0:
break
data = [int(input()) for _ in range(n)]
k = int(input())
result = b_search(data, k)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 21,938 | 20 | 43,877 |
Provide a correct Python 3 solution for this coding contest problem.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3 | instruction | 0 | 21,939 | 20 | 43,878 |
"Correct Solution:
```
def search(data, key):
cnt = 0
left, right = -1, len(data)
while right - left > 1:
mid = (left + right) // 2
cnt += 1
if data[mid] == key: break
elif data[mid] > key:
right = mid
else:
left = mid
return cnt
def solve():
N = int(input())
if N == 0: return -1
data = [int(input()) for i in range(N)]
k = int(input())
return search(data, k)
while True:
ans = solve()
if ans == -1: break
print(ans)
``` | output | 1 | 21,939 | 20 | 43,879 |
Provide a correct Python 3 solution for this coding contest problem.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3 | instruction | 0 | 21,940 | 20 | 43,880 |
"Correct Solution:
```
def search(n,d,t):
b = 0
e = n-1
r = 0
while True:
if b > e:
return r
else:
r += 1
i = (b+e)//2
if t == d[i]:
return r
elif t < d[i]:
e = i - 1
else:
b = i + 1
while True:
n = int(input())
if n == 0:
break
d = [int(input()) for i in range(n)]
t = int(input())
m = search(n,d,t)
print(m)
``` | output | 1 | 21,940 | 20 | 43,881 |
Provide a correct Python 3 solution for this coding contest problem.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3 | instruction | 0 | 21,941 | 20 | 43,882 |
"Correct Solution:
```
while 1:
l,r=0,int(input())
if r==0:break
a=[int(input()) for _ in range(r)]
r-=1;c=0
k=int(input())
while l<=r:
c+=1
m=(l+r)//2
if a[m]==k:break
if a[m]<k:l=m+1
else:r=m-1
print(c)
``` | output | 1 | 21,941 | 20 | 43,883 |
Provide a correct Python 3 solution for this coding contest problem.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3 | instruction | 0 | 21,942 | 20 | 43,884 |
"Correct Solution:
```
while True:
n = int(input())
if n == 0: break
a = [int(input()) for _ in range(n)]
k = int(input())
l, r, c = 0, n-1, 0
while l <= r:
c += 1
m = (l+r) >> 1
if k == a[m]:
break
elif k < a[m]:
r = m-1
else:
l = m+1
print(c)
``` | output | 1 | 21,942 | 20 | 43,885 |
Provide a correct Python 3 solution for this coding contest problem.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3 | instruction | 0 | 21,943 | 20 | 43,886 |
"Correct Solution:
```
# AOJ 0177 Distance Between Two Cities
# Python3 2018.6.20 bal4u
while True:
n = int(input())
if n == 0: break
a = [0]*120
for i in range(n): a[i] = int(input())
k = int(input())
cnt = 0
l, r = 0, n-1
while l <= r:
cnt += 1
m = (l + r) >> 1
if k == a[m]: break
if k < a[m]: r = m-1
else: l = m+1
print(cnt)
``` | output | 1 | 21,943 | 20 | 43,887 |
Provide a correct Python 3 solution for this coding contest problem.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3 | instruction | 0 | 21,944 | 20 | 43,888 |
"Correct Solution:
```
def search_num(k, alst):
left = 0
right = len(alst) - 1
cnt = 0
while left <= right:
mid = (left + right) // 2
cnt += 1
if alst[mid] == k:
return cnt
if alst[mid] < k:
left = mid + 1
else:
right = mid - 1
return cnt
while True:
n = int(input())
if n == 0:
break
alst = [int(input()) for _ in range(n)]
k = int(input())
print(search_num(k, alst))
``` | output | 1 | 21,944 | 20 | 43,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3
Submitted Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N = int(input())
if N == 0:
return False
A = [int(readline()) for i in range(N)]
k = int(readline())
ans = 0
left = 0; right = N-1
while left <= right:
mid = (left + right) >> 1
v = A[mid]
ans += 1
if v == k:
break
if v < k:
left = mid+1
else:
right = mid-1
write("%d\n" % ans)
return True
while solve():
...
``` | instruction | 0 | 21,945 | 20 | 43,890 |
Yes | output | 1 | 21,945 | 20 | 43,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3
Submitted Solution:
```
while 1:
n = int(input())
if n == 0:
break
array = []
for _ in range(n):
a = int(input())
array.append(a)
k = int(input())
n -= 1
l = 0
cnt = 0
while l <= n:
cnt += 1
m = (l+n) // 2
if array[m] == k:
break
if array[m] < k:
l = m + 1
else:
n = m - 1
print(cnt)
``` | instruction | 0 | 21,946 | 20 | 43,892 |
Yes | output | 1 | 21,946 | 20 | 43,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3
Submitted Solution:
```
def nibutan(f_id,e_id,f_num,count):
m_id = int((f_id + e_id) / 2)
m_num = n_lis[m_id]
if (f_id > e_id):
return count
else:
count += 1
if m_num > f_num:
return(nibutan(f_id,m_id -1,f_num,count))
elif m_num < f_num:
return(nibutan(m_id + 1,e_id,f_num,count))
else:
return count
while True:
global n_lis
n = int(input())
if n == 0:
break
n_lis = []
for i in range(n):
n_lis.append(int(input()))
f_n = int(input())
ans = nibutan(0,n - 1,f_n,0)
print(ans)
``` | instruction | 0 | 21,947 | 20 | 43,894 |
Yes | output | 1 | 21,947 | 20 | 43,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3
Submitted Solution:
```
def binary_search(num_list, num):
left = 0
right = len(num_list) - 1
count = 0
while left <= right:
mid = left + (right - left) // 2
count += 1
if num_list[mid] == num:
break
elif num_list[mid] < num:
left = mid + 1
else:
right = mid - 1
return count
while True:
input_count = int(input())
if input_count == 0:
break
num_list = [int(input()) for _ in range(input_count)]
search_number = int(input())
result = binary_search(num_list, search_number)
print(result)
``` | instruction | 0 | 21,948 | 20 | 43,896 |
Yes | output | 1 | 21,948 | 20 | 43,897 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0188
"""
import sys
from sys import stdin
input = stdin.readline
def b_search(data, k):
count = 0
l = 0
r = len(data) - 1
while True:
count += 1
mid = (l + r) // 2
if (data[mid] == k) or (l == r):
break
if data[mid] > k:
r = mid
else:
l = mid + 1
return count
def main(args):
while True:
n = int(input())
if n == 0:
break
data = [int(input()) for _ in range(n)]
k = int(input())
result = b_search(data, k)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 21,949 | 20 | 43,898 |
No | output | 1 | 21,949 | 20 | 43,899 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3
Submitted Solution:
```
def nibutan(f_id,e_id,f_num,count):
m_id = int((f_id + e_id) / 2)
m_num = n_lis[m_id]
count += 1
if (f_id > e_id):
return count
else:
if m_num > f_num:
return(nibutan(f_id,m_id -1,f_num,count))
elif m_num < f_num:
return(nibutan(m_id + 1,e_id,f_num,count))
else:
return count
while True:
global n_lis
n = int(input())
if n == 0:
break
n_lis = []
for i in range(n):
n_lis.append(int(input()))
f_n = int(input())
ans = nibutan(0,n,f_n,0)
print(ans)
``` | instruction | 0 | 21,950 | 20 | 43,900 |
No | output | 1 | 21,950 | 20 | 43,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Search" is an operation to obtain the desired information from a large amount of information. Familiar examples include "finding your own exam number from a large number of exam numbers" when announcing your success, or "finding Taro Aizu's phone number" from your phone book. This search operation is also widely used in the computer field.
<image>
There are many ways to search. Consider a search method that can be used when the data to be searched is arranged in ascending (or largest) order.
Using the magnitude relationship between the value located in the center of the data string arranged in ascending order (or in descending order) and the target value, the first half is set as the search range or the second half is searched from the value located in the center. There is a way to narrow down the search range by deciding whether to make it a range. The procedure is as follows.
1. The entire column of data is the scope of the search.
2. Examine the value located in the center of the search range.
3. If the desired value matches the centered value, the search ends.
4. If it is smaller than the target value and the value located in the center, the first half is the search range, and if it is larger, the second half is the search range and returns to 2.
The following is an example of the search method described above. The desired value in this example is 51. Each piece of data is numbered (index), which starts at 0.
Step 1: Initially, the search range is the entire number 0-6.
Step 2: Find the value in the center of the search range. However, the "centered value" is the value at the position of the number obtained by dividing (the number on the left side + the number on the right side) by 2. In other words, in this case, (0 + 6) ÷ 2 is calculated, and the value (36) at number 3 is the value located in the center.
Step 3: Compare the desired value (51) with the centrally located value (36).
Step 4: From the result of step 3, the target value is larger than the value located in the center, so the search range is from number 4 (next to the value located in the center) in the latter half. Use the same procedure to check the value located in the center of the search range, and if the target value is smaller than the value located in the center, the first half is the search range, and if it is larger, the second half is the search range. I will make it smaller. (Repeat of steps 2 to 4) The search ends when the target value matches the value located in the center or the search range is reached.
| <image>
--- | ---
Create a program that takes an array of n numbers as input and outputs the number of times the target value is compared with the value located in the center. However, if the number of the value located in the center is not divisible, the value rounded down to the nearest whole number will be used as the number. It is assumed that the given data columns are sorted in ascending order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
k
The number of numbers n (1 ≤ n ≤ 100) is given on the first line, and the i-th number ai (1 ≤ ai ≤ 100000, integer) is given on the following n lines.
The following line is given the value k (1 ≤ k ≤ 100000) to search for.
Output
The number of comparisons until the search is completed for each data set is output on one line.
Example
Input
7
11
15
23
36
51
61
86
51
4
1
2
3
5
4
0
Output
3
3
Submitted Solution:
```
def search(n,d,t):
b = 0
e = n
r = 0
while True:
r += 1
if b > e:
return r
else:
i = (b+e)//2
if t == d[i]:
return r
elif t < d[i]:
e = i - 1
else:
b = i + 1
while True:
n = int(input())
if n == 0:
break
d = [int(input()) for i in range(n)]
t = int(input())
m = search(n,d,t)
print(m)
``` | instruction | 0 | 21,951 | 20 | 43,902 |
No | output | 1 | 21,951 | 20 | 43,903 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.