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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6. | instruction | 0 | 2,923 | 20 | 5,846 |
Tags: dp, matrices
Correct Solution:
```
p = 10 ** 9 + 7
n, b, k, x = [int(s) for s in input().split()]
block = [int(s) for s in input().split()]
D = [0 for i in range(10)]
for s in block:
D[s] += 1
A = [[0 for t in range(x)]]
pows = [pow(10, 1<<j, x) for j in range(b.bit_length())]
for i in range(10):
A[0][i%x] += D[i]
for j in range(b.bit_length()-1):
B = A[-1]
C = [sum(B[i]*B[(t - i*pows[j])%x] for i in range(x)) % p for t in range(x)]
A.append(C)
ans = None
for j in range(b.bit_length()):
if (b>>j)&1:
if ans is None:
ans = A[j][:]
else:
ans = [sum(A[j][(t - i*pows[j])%x]*ans[i] for i in range(x)) % p for t in range(x)]
print(ans[k])
``` | output | 1 | 2,923 | 20 | 5,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6. | instruction | 0 | 2,924 | 20 | 5,848 |
Tags: dp, matrices
Correct Solution:
```
R = lambda : map(int, input().split())
n,b,k,x = R()
v = list(R())
mod = 10**9+7
arr_0 = [0]*x
for bd in v:
arr_0[bd%x]+=1
def cross(arr1,arr2,x,mod):
arr = [0]*len(arr1)
for i in range(len(arr1)):
for j in range(len(arr2)):
arr[(i+j)%x] += arr1[i]*arr2[j]
for i in range(len(arr)):
arr[i] %= mod
return arr
def move(arr,s,x):
m = pow(10,s,x)
res = [0]*x
for i in range(x):
res[(i*m)%x]+=arr[i]
return res
def solve(b,x,arr_0,mod):
if b==1:
return arr_0
if b%2==1:
sol = solve(b-1,x,arr_0,mod)
return cross(move(sol,1,x),arr_0,x,mod)
else:
sol = solve(b//2,x,arr_0,mod)
return cross(move(sol,b//2,x),sol,x,mod)
sol = solve(b,x,arr_0,mod)
print(sol[k])
``` | output | 1 | 2,924 | 20 | 5,849 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6. | instruction | 0 | 2,925 | 20 | 5,850 |
Tags: dp, matrices
Correct Solution:
```
import os
from io import BytesIO
#input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def main():
mod = 10**9 + 7
n,b,k,x = map(int,input().split())
x2 = x + 1
ai = list(map(int,input().split()))
ai2 = [0]*x2
for i in range(n):
ai2[ai[i] % x] += 1
ai2[-1] = 1
def power2(number, n, m):
res = 1
while(n):
if n & 1:
res *= number
res %= m
number *= number
number %= m
n >>= 1
return res
def mult(m1,m2):
ans = [0] * x2
for i in range(x):
for j in range(x):
temp = (i*power2(10,m2[-1],x)+j) % x
ans[temp] += m1[i] * m2[j]
ans[temp] %= mod
ans[-1] = m1[-1] + m2[-1]
return ans
def power(number, n):
res = number
while(n):
if n & 1:
res = mult(res,number)
number = mult(number,number)
n >>= 1
return res
ansm = power(ai2,b-1)
print(ansm[k])
main()
``` | output | 1 | 2,925 | 20 | 5,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6. | instruction | 0 | 2,926 | 20 | 5,852 |
Tags: dp, matrices
Correct Solution:
```
def g(b,w):
if(b,w)in x:return x[(b,w)]
x[(b,w)]=sum(c[i]for i in r(len(c))if i%m==w)if b==1else sum(g(b//2,l)*g(b-b//2,(w-(l*pow(10,b-b//2,m))%m+m)%m)for l in r(m))%(10**9+7)
return x[(b,w)]
q,r,k=input,range,'map(int,q().split())'
n,b,w,m=eval(k)
a,x=list(eval(k)),{}
c=[a.count(i)for i in r(10)]
print(g(b,w))
``` | output | 1 | 2,926 | 20 | 5,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6. | instruction | 0 | 2,927 | 20 | 5,854 |
Tags: dp, matrices
Correct Solution:
```
def g(b,w):
if(b,w)in x:return x[(b,w)]
x[(b,w)]=sum(c[i]for i in r(len(c))if i%m==w)if b==1else sum(g(b//2,l)*g(b-b//2,(w-(l*pow(10,b-b//2,m))%m+m)%m)for l in r(m))%(10**9+7)
return x[(b,w)]
q,r,k,t=input,range,'map(int,q().split())',eval
n,b,w,m=t(k)
a,x=list(t(k)),{}
c=[a.count(i)for i in r(10)]
print(g(b,w))
``` | output | 1 | 2,927 | 20 | 5,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Submitted Solution:
```
def g(b,w):
if(b,w)in x:return x[(b,w)]
x[(b,w)]=sum(c[i]for i in r(len(c))if i%m==w)if b==1else sum(g(b//2,l)*g(b-b//2,(w-(l*pow(10,b-b//2,m))%m+m)%m)for l in r(m))%(10**9+7)
return x[(b,w)]
q,r=input,range
n,b,w,m=map(int,q().split())
a,x=list(map(int,q().split())),{}
c=[a.count(i)for i in r(10)]
print(g(b,w))
``` | instruction | 0 | 2,928 | 20 | 5,856 |
Yes | output | 1 | 2,928 | 20 | 5,857 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Submitted Solution:
```
import os
from io import BytesIO
#input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def main():
mod = 10**9 + 7
n,b,k,x = map(int,input().split())
x2 = x + 1
ai = list(map(int,input().split()))
ai2 = [0]*x2
for i in range(n):
ai2[ai[i] % x] += 1
ai2[-1] = 1
def mult(m1,m2):
ans = [0] * x2
for i in range(x):
for j in range(x):
temp = (i*m2[-1]*10+j) % x
ans[temp] += m1[i] * m2[j]
ans[temp] %= mod
ans[-1] = (m1[-1] + m2[-1]) % x
return ans
def power(number, n):
res = number
while(n):
if n & 1:
res = mult(res,number)
number = mult(number,number)
n >>= 1
return res
ansm = power(ai2,b-1)
print(ansm[k])
main()
``` | instruction | 0 | 2,929 | 20 | 5,858 |
No | output | 1 | 2,929 | 20 | 5,859 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Submitted Solution:
```
import os
from io import BytesIO
#input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def main():
mod = 10**9 + 7
n,b,k,x = map(int,input().split())
ai = list(map(int,input().split()))
ai2 = [0]*x
for i in range(n):
ai2[ai[i] % x] += 1
def mult(m1,m2):
ans = [0] * x
for i in range(x):
for j in range(x):
temp = (i*10+j) % x
ans[temp] += m1[i] * m2[j]
ans[temp] %= mod
return ans
def power(number, n):
res = number
while(n):
if n & 1:
res = mult(res,number)
number = mult(number,number)
n >>= 1
return res
ansm = power(ai2,b-1)
print(ansm[k])
main()
``` | instruction | 0 | 2,930 | 20 | 5,860 |
No | output | 1 | 2,930 | 20 | 5,861 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Submitted Solution:
```
n,b,k,x=map(int,input().split())
arr=list(map(int,input().split()))
flg=[0]*x
mod = 10**9+7
for i in arr:
flg[i%x]+=1
def mul(dp,flg,rank):
global x
res=[0]*x
for i in range(x):
for j in range(x):
res[ ( (i*rank)%x+j)%x ] += dp[i]*flg[j]%mod
res[ ( (i*rank)%x+j)%x ] %= mod
# print(i,j,dp[i],dp[j],res[ ( (i*rank)%x+j)%x ])
return res
def pow(n):
global x
res=1
base=10
while n:
if n&1:
res=(res*base)%x
base=(base*base)%x
n>>=1
return res
dp=[0]*x
dp[0]=1
# print(mul(dp,flg,1))
rank=1
while b:
if b&1:
dp=mul(dp,flg,pow(rank-1))
rank<<=1
flg=mul(flg,flg,pow(rank-1))
b>>=1
print(dp[k])
``` | instruction | 0 | 2,931 | 20 | 5,862 |
No | output | 1 | 2,931 | 20 | 5,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Submitted Solution:
```
import math
p = 10 ** 9 + 7
n, b, k, x = [int(s) for s in input().split()]
block = [int(s) for s in input().split()]
D = [0 for i in range(10)]
for s in block:
D[s] += 1
A = [[0 for t in range(x)]]
for i in range(10):
A[0][i%x] += D[i]
for j in range(b.bit_length()):
B = A[-1]
C = [sum(B[i]*B[(t-i)%x] for i in range(x)) % p for t in range(x)]
A.append(C)
ans = None
for j in range(b.bit_length()):
if (b>>j)&1:
if ans is None:
ans = A[j]
else:
ans = [sum(A[j][i]*ans[(t-i)%x] for i in range(x)) % p for t in range(x)]
print(ans[k])
``` | instruction | 0 | 2,932 | 20 | 5,864 |
No | output | 1 | 2,932 | 20 | 5,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4 | instruction | 0 | 2,988 | 20 | 5,976 |
Tags: *special, implementation
Correct Solution:
```
_=input()
n=list(map(int,input().split()))
print(n[-1]^max(n))
#print(' '.join([str(i) for i in a]))
``` | output | 1 | 2,988 | 20 | 5,977 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4 | instruction | 0 | 2,989 | 20 | 5,978 |
Tags: *special, implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
x = max(a)
print(x ^ a[-1])
``` | output | 1 | 2,989 | 20 | 5,979 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4 | instruction | 0 | 2,991 | 20 | 5,982 |
Tags: *special, implementation
Correct Solution:
```
i=input
i()
a=list(map(int, i().split()))
print(max(a)^a[-1])
``` | output | 1 | 2,991 | 20 | 5,983 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4 | instruction | 0 | 2,993 | 20 | 5,986 |
Tags: *special, implementation
Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
k = max(a)
print(k ^ a[-1])
``` | output | 1 | 2,993 | 20 | 5,987 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10. | instruction | 0 | 3,932 | 20 | 7,864 |
Tags: brute force, implementation, math
Correct Solution:
```
#http://codeforces.com/problemset/problem/9/C
#solved
#finding lists
#
# from itertools import permutations
#
# print("a = ", sorted(list(map(int, map("".join, map(list, set(permutations("111111111000000000", 2))))))), "\n\n")
# print("b = ", sorted(list(map(int, map("".join, map(list, set(permutations("111111111000000000", 3))))))), "\n\n")
# print("c = ", sorted(list(map(int, map("".join, map(list, set(permutations("111111111000000000", 4))))))), "\n\n")
# print("d = ", sorted(list(map(int, map("".join, map(list, set(permutations("111111111000000000", 5))))))), "\n\n")
# print("e = ", sorted(list(map(int, map("".join, map(list, set(permutations("111111111000000000", 6))))))), "\n\n")
# print("f = ", sorted(list(map(int, map("".join, map(list, set(permutations("111111111000000000", 7))))))), "\n\n")
# print("g = ", sorted(list(map(int, map("".join, map(list, set(permutations("111111111000000000", 8))))))), "\n\n")
# print("h = ", sorted(list(map(int, map("".join, map(list, set(permutations("111111111000000000", 9))))))), "\n\n")
a = [1, 10, 11]
b = [1, 10, 11, 100, 101, 110, 111]
c = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111]
d = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111]
e = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111, 100000, 100001, 100010, 100011, 100100, 100101, 100110, 100111, 101000, 101001, 101010, 101011, 101100, 101101, 101110, 101111, 110000, 110001, 110010, 110011, 110100, 110101, 110110, 110111, 111000, 111001, 111010, 111011, 111100, 111101, 111110, 111111]
f = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111, 100000, 100001, 100010, 100011, 100100, 100101, 100110, 100111, 101000, 101001, 101010, 101011, 101100, 101101, 101110, 101111, 110000, 110001, 110010, 110011, 110100, 110101, 110110, 110111, 111000, 111001, 111010, 111011, 111100, 111101, 111110, 111111, 1000000, 1000001, 1000010, 1000011, 1000100, 1000101, 1000110, 1000111, 1001000, 1001001, 1001010, 1001011, 1001100, 1001101, 1001110, 1001111, 1010000, 1010001, 1010010, 1010011, 1010100, 1010101, 1010110, 1010111, 1011000, 1011001, 1011010, 1011011, 1011100, 1011101, 1011110, 1011111, 1100000, 1100001, 1100010, 1100011, 1100100, 1100101, 1100110, 1100111, 1101000, 1101001, 1101010, 1101011, 1101100, 1101101, 1101110, 1101111, 1110000, 1110001, 1110010, 1110011, 1110100, 1110101, 1110110, 1110111, 1111000, 1111001, 1111010, 1111011, 1111100, 1111101, 1111110, 1111111]
g = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111, 100000, 100001, 100010, 100011, 100100, 100101, 100110, 100111, 101000, 101001, 101010, 101011, 101100, 101101, 101110, 101111, 110000, 110001, 110010, 110011, 110100, 110101, 110110, 110111, 111000, 111001, 111010, 111011, 111100, 111101, 111110, 111111, 1000000, 1000001, 1000010, 1000011, 1000100, 1000101, 1000110, 1000111, 1001000, 1001001, 1001010, 1001011, 1001100, 1001101, 1001110, 1001111, 1010000, 1010001, 1010010, 1010011, 1010100, 1010101, 1010110, 1010111, 1011000, 1011001, 1011010, 1011011, 1011100, 1011101, 1011110, 1011111, 1100000, 1100001, 1100010, 1100011, 1100100, 1100101, 1100110, 1100111, 1101000, 1101001, 1101010, 1101011, 1101100, 1101101, 1101110, 1101111, 1110000, 1110001, 1110010, 1110011, 1110100, 1110101, 1110110, 1110111, 1111000, 1111001, 1111010, 1111011, 1111100, 1111101, 1111110, 1111111, 10000000, 10000001, 10000010, 10000011, 10000100, 10000101, 10000110, 10000111, 10001000, 10001001, 10001010, 10001011, 10001100, 10001101, 10001110, 10001111, 10010000, 10010001, 10010010, 10010011, 10010100, 10010101, 10010110, 10010111, 10011000, 10011001, 10011010, 10011011, 10011100, 10011101, 10011110, 10011111, 10100000, 10100001, 10100010, 10100011, 10100100, 10100101, 10100110, 10100111, 10101000, 10101001, 10101010, 10101011, 10101100, 10101101, 10101110, 10101111, 10110000, 10110001, 10110010, 10110011, 10110100, 10110101, 10110110, 10110111, 10111000, 10111001, 10111010, 10111011, 10111100, 10111101, 10111110, 10111111, 11000000, 11000001, 11000010, 11000011, 11000100, 11000101, 11000110, 11000111, 11001000, 11001001, 11001010, 11001011, 11001100, 11001101, 11001110, 11001111, 11010000, 11010001, 11010010, 11010011, 11010100, 11010101, 11010110, 11010111, 11011000, 11011001, 11011010, 11011011, 11011100, 11011101, 11011110, 11011111, 11100000, 11100001, 11100010, 11100011, 11100100, 11100101, 11100110, 11100111, 11101000, 11101001, 11101010, 11101011, 11101100, 11101101, 11101110, 11101111, 11110000, 11110001, 11110010, 11110011, 11110100, 11110101, 11110110, 11110111, 11111000, 11111001, 11111010, 11111011, 11111100, 11111101, 11111110, 11111111]
h = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111, 100000, 100001, 100010, 100011, 100100, 100101, 100110, 100111, 101000, 101001, 101010, 101011, 101100, 101101, 101110, 101111, 110000, 110001, 110010, 110011, 110100, 110101, 110110, 110111, 111000, 111001, 111010, 111011, 111100, 111101, 111110, 111111, 1000000, 1000001, 1000010, 1000011, 1000100, 1000101, 1000110, 1000111, 1001000, 1001001, 1001010, 1001011, 1001100, 1001101, 1001110, 1001111, 1010000, 1010001, 1010010, 1010011, 1010100, 1010101, 1010110, 1010111, 1011000, 1011001, 1011010, 1011011, 1011100, 1011101, 1011110, 1011111, 1100000, 1100001, 1100010, 1100011, 1100100, 1100101, 1100110, 1100111, 1101000, 1101001, 1101010, 1101011, 1101100, 1101101, 1101110, 1101111, 1110000, 1110001, 1110010, 1110011, 1110100, 1110101, 1110110, 1110111, 1111000, 1111001, 1111010, 1111011, 1111100, 1111101, 1111110, 1111111, 10000000, 10000001, 10000010, 10000011, 10000100, 10000101, 10000110, 10000111, 10001000, 10001001, 10001010, 10001011, 10001100, 10001101, 10001110, 10001111, 10010000, 10010001, 10010010, 10010011, 10010100, 10010101, 10010110, 10010111, 10011000, 10011001, 10011010, 10011011, 10011100, 10011101, 10011110, 10011111, 10100000, 10100001, 10100010, 10100011, 10100100, 10100101, 10100110, 10100111, 10101000, 10101001, 10101010, 10101011, 10101100, 10101101, 10101110, 10101111, 10110000, 10110001, 10110010, 10110011, 10110100, 10110101, 10110110, 10110111, 10111000, 10111001, 10111010, 10111011, 10111100, 10111101, 10111110, 10111111, 11000000, 11000001, 11000010, 11000011, 11000100, 11000101, 11000110, 11000111, 11001000, 11001001, 11001010, 11001011, 11001100, 11001101, 11001110, 11001111, 11010000, 11010001, 11010010, 11010011, 11010100, 11010101, 11010110, 11010111, 11011000, 11011001, 11011010, 11011011, 11011100, 11011101, 11011110, 11011111, 11100000, 11100001, 11100010, 11100011, 11100100, 11100101, 11100110, 11100111, 11101000, 11101001, 11101010, 11101011, 11101100, 11101101, 11101110, 11101111, 11110000, 11110001, 11110010, 11110011, 11110100, 11110101, 11110110, 11110111, 11111000, 11111001, 11111010, 11111011, 11111100, 11111101, 11111110, 11111111, 100000000, 100000001, 100000010, 100000011, 100000100, 100000101, 100000110, 100000111, 100001000, 100001001, 100001010, 100001011, 100001100, 100001101, 100001110, 100001111, 100010000, 100010001, 100010010, 100010011, 100010100, 100010101, 100010110, 100010111, 100011000, 100011001, 100011010, 100011011, 100011100, 100011101, 100011110, 100011111, 100100000, 100100001, 100100010, 100100011, 100100100, 100100101, 100100110, 100100111, 100101000, 100101001, 100101010, 100101011, 100101100, 100101101, 100101110, 100101111, 100110000, 100110001, 100110010, 100110011, 100110100, 100110101, 100110110, 100110111, 100111000, 100111001, 100111010, 100111011, 100111100, 100111101, 100111110, 100111111, 101000000, 101000001, 101000010, 101000011, 101000100, 101000101, 101000110, 101000111, 101001000, 101001001, 101001010, 101001011, 101001100, 101001101, 101001110, 101001111, 101010000, 101010001, 101010010, 101010011, 101010100, 101010101, 101010110, 101010111, 101011000, 101011001, 101011010, 101011011, 101011100, 101011101, 101011110, 101011111, 101100000, 101100001, 101100010, 101100011, 101100100, 101100101, 101100110, 101100111, 101101000, 101101001, 101101010, 101101011, 101101100, 101101101, 101101110, 101101111, 101110000, 101110001, 101110010, 101110011, 101110100, 101110101, 101110110, 101110111, 101111000, 101111001, 101111010, 101111011, 101111100, 101111101, 101111110, 101111111, 110000000, 110000001, 110000010, 110000011, 110000100, 110000101, 110000110, 110000111, 110001000, 110001001, 110001010, 110001011, 110001100, 110001101, 110001110, 110001111, 110010000, 110010001, 110010010, 110010011, 110010100, 110010101, 110010110, 110010111, 110011000, 110011001, 110011010, 110011011, 110011100, 110011101, 110011110, 110011111, 110100000, 110100001, 110100010, 110100011, 110100100, 110100101, 110100110, 110100111, 110101000, 110101001, 110101010, 110101011, 110101100, 110101101, 110101110, 110101111, 110110000, 110110001, 110110010, 110110011, 110110100, 110110101, 110110110, 110110111, 110111000, 110111001, 110111010, 110111011, 110111100, 110111101, 110111110, 110111111, 111000000, 111000001, 111000010, 111000011, 111000100, 111000101, 111000110, 111000111, 111001000, 111001001, 111001010, 111001011, 111001100, 111001101, 111001110, 111001111, 111010000, 111010001, 111010010, 111010011, 111010100, 111010101, 111010110, 111010111, 111011000, 111011001, 111011010, 111011011, 111011100, 111011101, 111011110, 111011111, 111100000, 111100001, 111100010, 111100011, 111100100, 111100101, 111100110, 111100111, 111101000, 111101001, 111101010, 111101011, 111101100, 111101101, 111101110, 111101111, 111110000, 111110001, 111110010, 111110011, 111110100, 111110101, 111110110, 111110111, 111111000, 111111001, 111111010, 111111011, 111111100, 111111101, 111111110, 111111111]
n = int(input())
dlugosc = len(str(n))
if dlugosc == 1:
print(1)
elif dlugosc == 2:
for i in range(len(a)):
if a[i] > n:
print(len(a[:i]))
exit()
print(len(a))
elif dlugosc == 3:
for i in range(len(b)):
if b[i] > n:
print(len(b[:i]))
exit()
print(len(b))
elif dlugosc == 4:
for i in range(len(c)):
if c[i] > n:
print(len(c[:i]))
exit()
print(len(c))
elif dlugosc == 5:
for i in range(len(d)):
if d[i] > n:
print(len(d[:i]))
exit()
print(len(d))
elif dlugosc == 6:
for i in range(len(e)):
if e[i] > n:
print(len(e[:i]))
exit()
print(len(e))
elif dlugosc == 7:
for i in range(len(f)):
if f[i] > n:
print(len(f[:i]))
exit()
print(len(f))
elif dlugosc == 8:
for i in range(len(g)):
if g[i] > n:
print(len(g[:i]))
exit()
print(len(g))
elif dlugosc == 9:
for i in range(len(h)):
if h[i] > n:
print(len(h[:i]))
exit()
print(len(h))
elif dlugosc == 10:
print(len(h) + 1)
``` | output | 1 | 3,932 | 20 | 7,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10. | instruction | 0 | 3,933 | 20 | 7,866 |
Tags: brute force, implementation, math
Correct Solution:
```
n=int(input())
k=1
z=1
s=1
if n<10 :
print(1)
exit()
for i in range(1,len(str(n))-1) :
z*=2
k+=z
n=str(n)
d=0
if int(n[0])>1 :
d=1
for i in range(1,len(n)) :
if int(n[i])>1 :
d=1
if n[i]!='0' or d==1 :
k+=2**(len(n)-i-1)
print(k+1)
``` | output | 1 | 3,933 | 20 | 7,867 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10. | instruction | 0 | 3,934 | 20 | 7,868 |
Tags: brute force, implementation, math
Correct Solution:
```
def main():
alpha = 'abcdefghijklmnopqrstuvwxyz'
ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
inf = 1e17
mod = 10 ** 9 + 7
# Max = 10 ** 1
# primes = []
# prime = [True for i in range(Max + 1)]
# p = 2
# while (p * p <= Max + 1):
#
# # If prime[p] is not
# # changed, then it is a prime
# if (prime[p] == True):
#
# # Update all multiples of p
# for i in range(p * p, Max + 1, p):
# prime[i] = False
# p += 1
#
# for p in range(2, Max + 1):
# if prime[p]:
# primes.append(p)
#
# print(primes)
def factorial(n):
f = 1
for i in range(1, n + 1):
f = (f * i) % mod # Now f never can
# exceed 10^9+7
return f
def ncr(n, r):
# initialize numerator
# and denominator
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 solve(n):
cnt = 0
for i in range(1,pow(2,len(str(n)))):
if int(bin(i)[2:]) <= n:
cnt += 1
print(cnt)
pass
t = 1#int(input())
ans = []
for _ in range(t):
n = int(input())
#n,m = map(int, input().split())
# s = input()
#arr = [int(x) for x in input().split()]
# a2 = [int(x) for x in input().split()]
# grid = []
# for i in range(n):
# grid.append([int(x) for x in input().split()][::-1])
ans.append(solve(n))
# for answer in ans:
# print(answer)
if __name__ == "__main__":
import sys, threading
import bisect
import math
import itertools
from sys import stdout
# Sorted Containers
import heapq
from queue import PriorityQueue
# Tree Problems
#sys.setrecursionlimit(2 ** 32 // 2 - 1)
#threading.stack_size(1 << 27)
# fast io
input = sys.stdin.readline
thread = threading.Thread(target=main)
thread.start()
thread.join()
``` | output | 1 | 3,934 | 20 | 7,869 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10. | instruction | 0 | 3,935 | 20 | 7,870 |
Tags: brute force, implementation, math
Correct Solution:
```
n=int(input())
a=[]
c=int
for i in range(515):
a.append(c(bin(i)[2:]))
a.remove(0)
ans=0
for i in a:
if i<=n:
ans+=1
print(ans)
``` | output | 1 | 3,935 | 20 | 7,871 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10. | instruction | 0 | 3,936 | 20 | 7,872 |
Tags: brute force, implementation, math
Correct Solution:
```
def answer(n):
k=len(str(n))
count=2**(k-1)-1
arr=["1"]
for i in range(k-1):
temp=[]
for x in range(len(arr)):
temp.append(arr[x]+"1")
temp.append(arr[x]+"0")
arr=temp[:]
for i in arr:
if int(i)<=n:
count+=1
return count
t=int(input())
print(answer(t))
``` | output | 1 | 3,936 | 20 | 7,873 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10. | instruction | 0 | 3,937 | 20 | 7,874 |
Tags: brute force, implementation, math
Correct Solution:
```
n=int(input())
x=1
c=0
while(int(bin(x)[2:])<=n):
x+=1
c+=1
print(c)
``` | output | 1 | 3,937 | 20 | 7,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10. | instruction | 0 | 3,938 | 20 | 7,876 |
Tags: brute force, implementation, math
Correct Solution:
```
num=int(input())
li=[]
for i in range(1,520) :
li.append(int((bin(i)).replace("0b","")) )
count=0
for i in li :
if i<=num :
count+=1
print(count)
``` | output | 1 | 3,938 | 20 | 7,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10. | instruction | 0 | 3,939 | 20 | 7,878 |
Tags: brute force, implementation, math
Correct Solution:
```
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
# Hex nums
#flop [not conv to bin exact :))]
n,=I()
x=[]
for i in range(1,2**10+1):
k=format(i,'b');p=0
o=len(k)
for j in range(o):
if k[o-j-1]=='1':
p+=10**(j)
x.append(p)
an=0
for j in range(len(x)):
if x[j]>n:
an=j;break
print(an)
``` | output | 1 | 3,939 | 20 | 7,879 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10.
Submitted Solution:
```
n = input()
result = 2**len(n)-1
for i in range(len(n)):
if n[i]=='0':
result-=2**(len(n)-i-1)
elif n[i]=='1':
continue
else:
break
print(result)
``` | instruction | 0 | 3,940 | 20 | 7,880 |
Yes | output | 1 | 3,940 | 20 | 7,881 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10.
Submitted Solution:
```
import sys
sys_input = sys.stdin.readline
def inp():
return int(sys_input())
def minp():
return map(int,sys_input().split())
def linp():
return list(map(int,sys_input().split()))
def inpsl():
return list(input().split())
def write(s):
sys.stdout.write(s+" ")
def main():
n = inp()
cnt =0
for i in range(1,2**10):
if int(bin(i)[2:]) <= n:
cnt += 1
else:
break
print(cnt)
main()
``` | instruction | 0 | 3,941 | 20 | 7,882 |
Yes | output | 1 | 3,941 | 20 | 7,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10.
Submitted Solution:
```
n = 0
res = 0
def dfs(x):
global n
global res
if x > n:
return
res += 1
dfs(x * 10)
dfs(x * 10 + 1)
n = int(input())
dfs(1)
print(res)
``` | instruction | 0 | 3,942 | 20 | 7,884 |
Yes | output | 1 | 3,942 | 20 | 7,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10.
Submitted Solution:
```
n=int(input())
def jinzhi(a):
k=bin(a)
return int(k[2:])
i=1
while jinzhi(i)<=n:
i=i+1
print(i-1)
``` | instruction | 0 | 3,943 | 20 | 7,886 |
Yes | output | 1 | 3,943 | 20 | 7,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10.
Submitted Solution:
```
#http://codeforces.com/problemset/problem/9/C
#solved
a = [1, 10, 11]
b = [1, 10, 11, 100, 101, 110, 111]
c = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111]
d = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111]
e = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111, 100000, 100001, 100010, 100011, 100100, 100101, 100110, 100111, 101000, 101001, 101010, 101011, 101100, 101101, 101110, 101111, 110000, 110001, 110010, 110011, 110100, 110101, 110110, 110111, 111000, 111001, 111010, 111011, 111100, 111101, 111110, 111111]
f = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111, 100000, 100001, 100010, 100011, 100100, 100101, 100110, 100111, 101000, 101001, 101010, 101011, 101100, 101101, 101110, 101111, 110000, 110001, 110010, 110011, 110100, 110101, 110110, 110111, 111000, 111001, 111010, 111011, 111100, 111101, 111110, 111111, 1000000, 1000001, 1000010, 1000011, 1000100, 1000101, 1000110, 1000111, 1001000, 1001001, 1001010, 1001011, 1001100, 1001101, 1001110, 1001111, 1010000, 1010001, 1010010, 1010011, 1010100, 1010101, 1010110, 1010111, 1011000, 1011001, 1011010, 1011011, 1011100, 1011101, 1011110, 1011111, 1100000, 1100001, 1100010, 1100011, 1100100, 1100101, 1100110, 1100111, 1101000, 1101001, 1101010, 1101011, 1101100, 1101101, 1101110, 1101111, 1110000, 1110001, 1110010, 1110011, 1110100, 1110101, 1110110, 1110111, 1111000, 1111001, 1111010, 1111011, 1111100, 1111101, 1111110, 1111111]
g = [1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111, 100000, 100001, 100010, 100011, 100100, 100101, 100110, 100111, 101000, 101001, 101010, 101011, 101100, 101101, 101110, 101111, 110000, 110001, 110010, 110011, 110100, 110101, 110110, 110111, 111000, 111001, 111010, 111011, 111100, 111101, 111110, 111111, 1000000, 1000001, 1000010, 1000011, 1000100, 1000101, 1000110, 1000111, 1001000, 1001001, 1001010, 1001011, 1001100, 1001101, 1001110, 1001111, 1010000, 1010001, 1010010, 1010011, 1010100, 1010101, 1010110, 1010111, 1011000, 1011001, 1011010, 1011011, 1011100, 1011101, 1011110, 1011111, 1100000, 1100001, 1100010, 1100011, 1100100, 1100101, 1100110, 1100111, 1101000, 1101001, 1101010, 1101011, 1101100, 1101101, 1101110, 1101111, 1110000, 1110001, 1110010, 1110011, 1110100, 1110101, 1110110, 1110111, 1111000, 1111001, 1111010, 1111011, 1111100, 1111101, 1111110, 1111111, 10000000, 10000001, 10000010, 10000011, 10000100, 10000101, 10000110, 10000111, 10001000, 10001001, 10001010, 10001011, 10001100, 10001101, 10001110, 10001111, 10010000, 10010001, 10010010, 10010011, 10010100, 10010101, 10010110, 10010111, 10011000, 10011001, 10011010, 10011011, 10011100, 10011101, 10011110, 10011111, 10100000, 10100001, 10100010, 10100011, 10100100, 10100101, 10100110, 10100111, 10101000, 10101001, 10101010, 10101011, 10101100, 10101101, 10101110, 10101111, 10110000, 10110001, 10110010, 10110011, 10110100, 10110101, 10110110, 10110111, 10111000, 10111001, 10111010, 10111011, 10111100, 10111101, 10111110, 10111111, 11000000, 11000001, 11000010, 11000011, 11000100, 11000101, 11000110, 11000111, 11001000, 11001001, 11001010, 11001011, 11001100, 11001101, 11001110, 11001111, 11010000, 11010001, 11010010, 11010011, 11010100, 11010101, 11010110, 11010111, 11011000, 11011001, 11011010, 11011011, 11011100, 11011101, 11011110, 11011111, 11100000, 11100001, 11100010, 11100011, 11100100, 11100101, 11100110, 11100111, 11101000, 11101001, 11101010, 11101011, 11101100, 11101101, 11101110, 11101111, 11110000, 11110001, 11110010, 11110011, 11110100, 11110101, 11110110, 11110111, 11111000, 11111001, 11111010, 11111011, 11111100, 11111101, 11111110, 11111111]
h = [0, 1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111, 100000, 100001, 100010, 100011, 100100, 100101, 100110, 100111, 101000, 101001, 101010, 101011, 101100, 101101, 101110, 101111, 110000, 110001, 110010, 110011, 110100, 110101, 110110, 110111, 111000, 111001, 111010, 111011, 111100, 111101, 111110, 111111, 1000000, 1000001, 1000010, 1000011, 1000100, 1000101, 1000110, 1000111, 1001000, 1001001, 1001010, 1001011, 1001100, 1001101, 1001110, 1001111, 1010000, 1010001, 1010010, 1010011, 1010100, 1010101, 1010110, 1010111, 1011000, 1011001, 1011010, 1011011, 1011100, 1011101, 1011110, 1011111, 1100000, 1100001, 1100010, 1100011, 1100100, 1100101, 1100110, 1100111, 1101000, 1101001, 1101010, 1101011, 1101100, 1101101, 1101110, 1101111, 1110000, 1110001, 1110010, 1110011, 1110100, 1110101, 1110110, 1110111, 1111000, 1111001, 1111010, 1111011, 1111100, 1111101, 1111110, 1111111, 10000000, 10000001, 10000010, 10000011, 10000100, 10000101, 10000110, 10000111, 10001000, 10001001, 10001010, 10001011, 10001100, 10001101, 10001110, 10001111, 10010000, 10010001, 10010010, 10010011, 10010100, 10010101, 10010110, 10010111, 10011000, 10011001, 10011010, 10011011, 10011100, 10011101, 10011110, 10011111, 10100000, 10100001, 10100010, 10100011, 10100100, 10100101, 10100110, 10100111, 10101000, 10101001, 10101010, 10101011, 10101100, 10101101, 10101110, 10101111, 10110000, 10110001, 10110010, 10110011, 10110100, 10110101, 10110110, 10110111, 10111000, 10111001, 10111010, 10111011, 10111100, 10111101, 10111110, 10111111, 11000000, 11000001, 11000010, 11000011, 11000100, 11000101, 11000110, 11000111, 11001000, 11001001, 11001010, 11001011, 11001100, 11001101, 11001110, 11001111, 11010000, 11010001, 11010010, 11010011, 11010100, 11010101, 11010110, 11010111, 11011000, 11011001, 11011010, 11011011, 11011100, 11011101, 11011110, 11011111, 11100000, 11100001, 11100010, 11100011, 11100100, 11100101, 11100110, 11100111, 11101000, 11101001, 11101010, 11101011, 11101100, 11101101, 11101110, 11101111, 11110000, 11110001, 11110010, 11110011, 11110100, 11110101, 11110110, 11110111, 11111000, 11111001, 11111010, 11111011, 11111100, 11111101, 11111110, 11111111, 100000000, 100000001, 100000010, 100000011, 100000100, 100000101, 100000110, 100000111, 100001000, 100001001, 100001010, 100001011, 100001100, 100001101, 100001110, 100001111, 100010000, 100010001, 100010010, 100010011, 100010100, 100010101, 100010110, 100010111, 100011000, 100011001, 100011010, 100011011, 100011100, 100011101, 100011110, 100011111, 100100000, 100100001, 100100010, 100100011, 100100100, 100100101, 100100110, 100100111, 100101000, 100101001, 100101010, 100101011, 100101100, 100101101, 100101110, 100101111, 100110000, 100110001, 100110010, 100110011, 100110100, 100110101, 100110110, 100110111, 100111000, 100111001, 100111010, 100111011, 100111100, 100111101, 100111110, 100111111, 101000000, 101000001, 101000010, 101000011, 101000100, 101000101, 101000110, 101000111, 101001000, 101001001, 101001010, 101001011, 101001100, 101001101, 101001110, 101001111, 101010000, 101010001, 101010010, 101010011, 101010100, 101010101, 101010110, 101010111, 101011000, 101011001, 101011010, 101011011, 101011100, 101011101, 101011110, 101011111, 101100000, 101100001, 101100010, 101100011, 101100100, 101100101, 101100110, 101100111, 101101000, 101101001, 101101010, 101101011, 101101100, 101101101, 101101110, 101101111, 101110000, 101110001, 101110010, 101110011, 101110100, 101110101, 101110110, 101110111, 101111000, 101111001, 101111010, 101111011, 101111100, 101111101, 101111110, 101111111, 110000000, 110000001, 110000010, 110000011, 110000100, 110000101, 110000110, 110000111, 110001000, 110001001, 110001010, 110001011, 110001100, 110001101, 110001110, 110001111, 110010000, 110010001, 110010010, 110010011, 110010100, 110010101, 110010110, 110010111, 110011000, 110011001, 110011010, 110011011, 110011100, 110011101, 110011110, 110011111, 110100000, 110100001, 110100010, 110100011, 110100100, 110100101, 110100110, 110100111, 110101000, 110101001, 110101010, 110101011, 110101100, 110101101, 110101110, 110101111, 110110000, 110110001, 110110010, 110110011, 110110100, 110110101, 110110110, 110110111, 110111000, 110111001, 110111010, 110111011, 110111100, 110111101, 110111110, 110111111, 111000000, 111000001, 111000010, 111000011, 111000100, 111000101, 111000110, 111000111, 111001000, 111001001, 111001010, 111001011, 111001100, 111001101, 111001110, 111001111, 111010000, 111010001, 111010010, 111010011, 111010100, 111010101, 111010110, 111010111, 111011000, 111011001, 111011010, 111011011, 111011100, 111011101, 111011110, 111011111, 111100000, 111100001, 111100010, 111100011, 111100100, 111100101, 111100110, 111100111, 111101000, 111101001, 111101010, 111101011, 111101100, 111101101, 111101110, 111101111, 111110000, 111110001, 111110010, 111110011, 111110100, 111110101, 111110110, 111110111, 111111000, 111111001, 111111010, 111111011, 111111100, 111111101, 111111110, 111111111]
n = int(input())
dlugosc = len(str(n))
if dlugosc == 1:
print(1)
elif dlugosc == 2:
for i in range(len(a)):
if a[i] > n:
print(len(a[:i]))
exit()
print(len(a))
elif dlugosc == 3:
for i in range(len(b)):
if b[i] > n:
print(len(b[:i]))
exit()
print(len(b))
elif dlugosc == 4:
for i in range(len(c)):
if c[i] > n:
print(len(c[:i]))
exit()
print(len(c))
elif dlugosc == 5:
for i in range(len(d)):
if d[i] > n:
print(len(d[:i]))
exit()
print(len(d))
elif dlugosc == 6:
for i in range(len(e)):
if e[i] > n:
print(len(e[:i]))
exit()
print(len(e))
elif dlugosc == 7:
for i in range(len(f)):
if f[i] > n:
print(len(f[:i]))
exit()
print(len(f))
elif dlugosc == 8:
for i in range(len(g)):
if g[i] > n:
print(len(g[:i]))
exit()
print(len(g))
elif dlugosc == 2:
for i in range(len(h)):
if h[i] > n:
print(len(h[:i]))
exit()
print(len(h))
``` | instruction | 0 | 3,944 | 20 | 7,888 |
No | output | 1 | 3,944 | 20 | 7,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10.
Submitted Solution:
```
"""
from sys import stdin, stdout
import math
from functools import reduce
import statistics
import numpy as np
import itertools
import operator
"""
from math import sqrt
import os
import sys
from io import BytesIO, IOBase
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)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def prog_name():
# n = int(input())
# if n < 10:
# print(1)
# else:
# cnt = 0
# check = 9
# t = 9
# flag = True
# while flag:
# if check <= n:
# cnt += 2**(len(str(check)) - 1)
# check = check*10 + t
# else:
# flag = False
# num = (int('1'*len(str(n))))
# start = int(str(check)[:-1])
#
# if (min(n,num)) == num and n != start:
# cnt += 2 ** (len(str(check)) - 1)
# else:
# for x in range(start + 1,min(n,num) + 1):
# j = str(x)
# if j.count('0') + j.count('1') == len(j):
# cnt += 1
# print(cnt)
x = 1
n = int(input())
flag = True
while flag:
if int(bin(x)[2:]) < n:
x +=1
else:
flag = False
print(x - 1)
def main():
t = 1
for unique in range(t):
# print("Case #"+str(unique+1)+":",end = " ")
prog_name()
if __name__ == "__main__":
main()
``` | instruction | 0 | 3,945 | 20 | 7,890 |
No | output | 1 | 3,945 | 20 | 7,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10.
Submitted Solution:
```
x=input("saisir un entier ")
tab=list(x)
entry=int(x)
aid=str()
if entry==0 :
print("0");
elif entry<=9 :
print("2")
for i in range(len(tab)) :
tab[i]=int(tab[i])
if 1<tab[0]:
x=(2**len(tab))-1
elif tab[0]==1:
if 1<tab[1]:
x=(2**len(tab))-1
else:
x=(2**(len(tab)-1))-1
A=list()
a=str()
for i in range(len(tab)) :
if i == 0 :
A.append(1)
a=str(A[i])
else :
A.append(0)
a=a+str(A[i])
number=int(a)
b=str(number)
b=int(b,2)
while number<=entry :
x=x+1
alter=int(bin(b),2)+int(bin(1),2)
help=bin(alter)
aid=help[2:]
s=str(aid)
number=int(s)
b=str(number)
b=int(b,2)
print(x)
``` | instruction | 0 | 3,946 | 20 | 7,892 |
No | output | 1 | 3,946 | 20 | 7,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of n different natural numbers from 1 to n to obtain total control over her energy.
But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input
Input data contains the only number n (1 ≤ n ≤ 109).
Output
Output the only number — answer to the problem.
Examples
Input
10
Output
2
Note
For n = 10 the answer includes numbers 1 and 10.
Submitted Solution:
```
n = input()
ans = 2 ** len(n) - 1
i = 1
while i < len(n):
if n[i] == '0':
ans -= 2**(len(n)-i-1)
i += 1
print(ans)
``` | instruction | 0 | 3,947 | 20 | 7,894 |
No | output | 1 | 3,947 | 20 | 7,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Input
The input contains a single integer a (0 ≤ a ≤ 15).
Output
Output a single integer.
Example
Input
3
Output
13 | instruction | 0 | 4,207 | 20 | 8,414 |
Tags: bitmasks, brute force
Correct Solution:
```
n = int(input())
a = n & 1
b = n >> 1 & 1
c = n >> 2 & 1
d = n >> 3 & 1
d = 1 - d
if d:
c = 1 - c
if c and d:
b = 1 - b
if b and c and d:
a = 1 - a
ans = d << 3 | c << 2 | b << 1 | a
print(ans)
``` | output | 1 | 4,207 | 20 | 8,415 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Input
The input contains a single integer a (0 ≤ a ≤ 15).
Output
Output a single integer.
Example
Input
3
Output
13 | instruction | 0 | 4,208 | 20 | 8,416 |
Tags: bitmasks, brute force
Correct Solution:
```
Ans=[15,14,12,13,8,9,10,11,0,1,2,3,4,5,6,7]
n=int(input())
print(Ans[n])
``` | output | 1 | 4,208 | 20 | 8,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Input
The input contains a single integer a (0 ≤ a ≤ 15).
Output
Output a single integer.
Example
Input
3
Output
13 | instruction | 0 | 4,209 | 20 | 8,418 |
Tags: bitmasks, brute force
Correct Solution:
```
print([15, 14, 12, 13, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7][int(input())])
``` | output | 1 | 4,209 | 20 | 8,419 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Input
The input contains a single integer a (0 ≤ a ≤ 15).
Output
Output a single integer.
Example
Input
3
Output
13 | instruction | 0 | 4,211 | 20 | 8,422 |
Tags: bitmasks, brute force
Correct Solution:
```
a = int(input())
if a == 3:
print(13)
elif a == 0:
print(15)
elif a == 1:
print(14)
elif a == 2:
print(12)
elif a == 4:
print(8)
elif a == 5:
print(9)
elif a == 6:
print(10)
elif a == 7:
print(11)
elif a == 8:
print(0)
elif a == 9:
print(1)
elif a == 10:
print(2)
elif a == 11:
print(3)
elif a == 12:
print(4)
elif a == 13:
print(5)
elif a == 14:
print(6)
elif a == 15:
print(7)
``` | output | 1 | 4,211 | 20 | 8,423 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Input
The input contains a single integer a (0 ≤ a ≤ 15).
Output
Output a single integer.
Example
Input
3
Output
13 | instruction | 0 | 4,212 | 20 | 8,424 |
Tags: bitmasks, brute force
Correct Solution:
```
a=int(input())
if a==0 or a==6 or a==9 or a==15:
c=a
if a==2 or a==5 or a==7:
c=a*2
if a==4 or a==10 or a==14:
c=a//2
if a==1:
c=8
if a==8:
c=1
if a==3:
c=12
if a==12:
c=3
if a==11:
c=13
if a==13:
c=11
if a!=0:
e=c-1
else:
e=15
if e==0 or e==6 or e==9 or e==15:
f=e
if e==2 or e==5 or e==7:
f=e*2
if e==4 or e==10 or e==14:
f=e//2
if e==1:
f=8
if e==8:
f=1
if e==3:
f=12
if e==12:
f=3
if e==11:
f=13
if e==13:
f=11
#reverse
print(f)
``` | output | 1 | 4,212 | 20 | 8,425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Input
The input contains a single integer a (0 ≤ a ≤ 15).
Output
Output a single integer.
Example
Input
3
Output
13 | instruction | 0 | 4,213 | 20 | 8,426 |
Tags: bitmasks, brute force
Correct Solution:
```
n = int(input())
a, b, c, d = n%2, n//2%2, n//4%2, n//8
d ^= 1
if d == 1: c ^= 1
if d == 1 and c == 1: b ^= 1
if d == 1 and c == 1 and b == 1: a ^= 1
print(a+b*2+c*4+d*8)
``` | output | 1 | 4,213 | 20 | 8,427 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Input
The input contains a single integer a (0 ≤ a ≤ 15).
Output
Output a single integer.
Example
Input
3
Output
13 | instruction | 0 | 4,214 | 20 | 8,428 |
Tags: bitmasks, brute force
Correct Solution:
```
n=int(input(""))
a=[0,0,0,0]
a[0]=n%2
n=n//2
a[1]=n%2
n=n//2
a[2]=n%2
n=n//2
a[3]=n%2
def intnot(x):
return 0 if x==1 else 1
a[3]=intnot(a[3])
if(a[3]==1):
a[2]=intnot(a[2])
if(a[3]+a[2]==2):
a[1]=intnot(a[1])
if(a[3]+a[2]+a[1]==3):
a[0]=intnot(a[0])
n=8*a[3]+4*a[2]+2*a[1]+a[0]
print(n)
``` | output | 1 | 4,214 | 20 | 8,429 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998 | instruction | 0 | 4,255 | 20 | 8,510 |
Tags: math, number theory
Correct Solution:
```
mod=10**9+7
from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
from bisect import bisect_right as br #c++ upperbound
import itertools
import collections
import math
import heapq
from random import randint as rn
def modinv(n,p):
return pow(n,p-2,p)
def ncr(n,r,p): #for using this uncomment the lines calculating fact and ifact
t=((fact[n])*((ifact[r]*ifact[n-r])%p))%p
return t
def ain(): #takes array as input
return list(map(int,sin().split()))
def sin():
return input()
def inin():
return int(input())
def GCD(x,y):
while(y):
x, y = y, x % y
return x
"""*******************************************************"""
def main():
n=int(input())
a=[]
for i in range(n):
l=ain()
a.append(l)
x=1
l=1
r=1000000001
while l <= r:
mid = l + (r - l)//2;
midd= a[0][1]//mid
if (a[1][2]*mid==a[0][2]*midd):
break
# If x is greater, ignore left half
elif (a[1][2]*mid<a[0][2]*midd):
l = mid + 1
# If x is smaller, ignore right half
else:
r = mid - 1
# If we reach here, then the element
# was not present
z=int(mid)
print(z,end=" ")
for i in range(1,n):
print(a[0][i]//z,end=" ")
######## Python 2 and 3 footer by Pajenegod and c1729
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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)
input = lambda: sys.stdin.readline().rstrip('\r\n')
if __name__ == '__main__':
main()
#threading.Thread(target=main).start()
``` | output | 1 | 4,255 | 20 | 8,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998 | instruction | 0 | 4,256 | 20 | 8,512 |
Tags: math, number theory
Correct Solution:
```
from sys import stdin,stdout
from math import sqrt
from functools import reduce
input=stdin.readline
n=int(input())
a=list(map(int,input().split()))[1:]
p=a[0]*a[1]
p=int(sqrt(p//(list(map(int,input().split())))[2]))
for i in range(n-2):input().rstrip('\n')
print(p,*[i//p for i in a])
``` | output | 1 | 4,256 | 20 | 8,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998 | instruction | 0 | 4,257 | 20 | 8,514 |
Tags: math, number theory
Correct Solution:
```
#!/usr/bin/env python3
import atexit
import io
import sys
_I_B = sys.stdin.read().splitlines()
input = iter(_I_B).__next__
_O_B = io.StringIO()
sys.stdout = _O_B
@atexit.register
def write():
sys.__stdout__.write(_O_B.getvalue())
def main():
n=int(input())
m=[]
for i in range(n):
m.append(list(map(int,input().split())))
a1=int(((m[0][2]*m[0][1])//m[1][2])**0.5)
print(a1,end=" ")
for i in range(1,n):
print(m[0][i]//a1,end=" ")
if __name__=='__main__':
main()
``` | output | 1 | 4,257 | 20 | 8,515 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998 | instruction | 0 | 4,258 | 20 | 8,516 |
Tags: math, number theory
Correct Solution:
```
n = int(input())
M = []
for i in range(n):
M += [list(map(int,input().split()))]
arr = []
for k in range(n//2) :
arr += [int((M[k][k+1]*M[k][k+2] / M[k+1][k+2])**0.5)]
for k in range(n//2,n) :
arr += [int((M[k][k-1]*M[k][k-2] / M[k-1][k-2])**0.5)]
print(*arr)
``` | output | 1 | 4,258 | 20 | 8,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998 | instruction | 0 | 4,259 | 20 | 8,518 |
Tags: math, number theory
Correct Solution:
```
import math
n = int(input())
arr = []
for _ in range(n):
arr.append(list(map(int,input().split())))
# x/y = arr[1][2] / arr[0][2]
# x*y = arr[0][1]
s = int(math.sqrt(arr[0][1]*arr[0][2]//arr[1][2]))
print(s,end=" ")
for i in range(1,n):
print(arr[0][i]//s,end=" ")
``` | output | 1 | 4,259 | 20 | 8,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998 | instruction | 0 | 4,260 | 20 | 8,520 |
Tags: math, number theory
Correct Solution:
```
import math
n = int(input())
arr2 = []
arr = []
for _ in range(n):
arr2.append(list(map(int, input().split())))
x = arr2[1][0]
y = arr2[2][0]
z = arr2[2][1]
a1 = int(math.sqrt((x*y) // z))
arr.append(a1)
for h in range(1, n):
arr.append(arr2[h][0] // arr[0])
print(*arr)
``` | output | 1 | 4,260 | 20 | 8,521 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998 | instruction | 0 | 4,261 | 20 | 8,522 |
Tags: math, number theory
Correct Solution:
```
from math import *
n=int(input())
l=[[int(j) for j in input().split()] for i in range(n)]
g=[]
for x in range(n):
flag=0
d=0
for y in range(n):
if flag:
break
for z in range(n):
a=l[x][y]
b=l[x][z]
c=l[y][z]
if a and b and c:
flag=1
d=a*b//c
break
g.append(int(sqrt(d)))
print(*g)
``` | output | 1 | 4,261 | 20 | 8,523 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998 | instruction | 0 | 4,262 | 20 | 8,524 |
Tags: math, number theory
Correct Solution:
```
n = int(input())
a = [[int(i) for i in input().split()] for j in range(n)]
ans = []
a[0][0] = (a[2][0] * a[0][1]) // a[2][1]
ans.append(int(a[0][0] ** 0.5))
for i in range(1, n):
a[i][i] = (a[i - 1][i] * a[i][i - 1]) // a[i - 1][i - 1]
ans.append(int(a[i][i] ** 0.5))
print(*ans)
``` | output | 1 | 4,262 | 20 | 8,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998
Submitted Solution:
```
# for t in range(int(input())):
n = int(input())
from math import gcd, sqrt
m = [1 for i in range(n)]
l = [[] for i in range(n)]
for i in range(n):
l[i] = [int(j) for ct,j in enumerate(input().split())]
val = l[n-2][-1]
# ls = [[]]
prod = 1
for i in range(1,3):
prod *= l[n-3][n-3+i]
m[n-3] = int((prod/val)**0.5)
for i in range(1,3):
m[n-3+i] = l[n-3][n-3+i]//m[n-3]
for i in range(n-3, -1, -1):
m[i] = l[i][i+1]//m[i+1]
for i in range(n):
print(m[i], end = " ")
print()
``` | instruction | 0 | 4,263 | 20 | 8,526 |
Yes | output | 1 | 4,263 | 20 | 8,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998
Submitted Solution:
```
n=int(input())
p=[]
for i in range(n):
q=[]
q=list(map(int,input().split()))
p.append(q)
a=0
r=[]
a2=int(((p[0][2]*p[1][2])/p[0][1])**(1/2))
for j in range(1,n):
if(j!=2):
a=int((p[0][j]*a2)/p[0][2])
r.append(a)
a0=int(p[0][1]/r[0])
print(a0,end=" ")
print(r[0],end=" ")
print(a2,end=" ")
for i in range(0,n-3):
print(r[i+1],end=" ")
``` | instruction | 0 | 4,264 | 20 | 8,528 |
Yes | output | 1 | 4,264 | 20 | 8,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998
Submitted Solution:
```
import math
n=int(input())
lst=[]
a=[]
for i in range(n):
d=input()
d=d.split(" ")
d=[int(x) for x in d]
lst.append(d)
a.append(0)
a[0]=math.sqrt(lst[0][1]*lst[0][2]/lst[1][2])
for i in range(1,n):
a[i]=lst[0][i]/a[0]
for i in range(n):
a[i]=int(a[i])
print(*a)
``` | instruction | 0 | 4,265 | 20 | 8,530 |
Yes | output | 1 | 4,265 | 20 | 8,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998
Submitted Solution:
```
__author__ = 'Esfandiar'
from math import ceil,sqrt
#from collections import*
#from heapq import*
#n = int(input())
#a = list(map(int,input().split()))
n = int(input())
a = list()
res = [0]*n
for i in range(n):
a.append(list(map(int,input().split())))
a1 = int(sqrt(a[0][1]*a[0][2]//a[1][2]))
res[0] = a1
for i in range(1,n):
res[i] = a[0][i]//a1
print(*res)
'''
a1*a2 = a[0][1]
a1*a3 = a[0][2]
a2*a3 = a[1][2]
a3 = a[1][2]//a2
a1*a2 = a[0][1]
a1*(a[1][2]//a2) = a[0][2]
a2-(a[1][2]//a2) == a[0][1]-a[0][2]
'''
``` | instruction | 0 | 4,266 | 20 | 8,532 |
Yes | output | 1 | 4,266 | 20 | 8,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998
Submitted Solution:
```
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
n = int(input())
arr = []
for i in range(n):
q = list(map(int, input().split()))
arr.append(q)
a2 = gcd(arr[0][1], arr[1][2])
a1a2 = arr[0][1]
a1 = a1a2//a2
ans = [a1, a2]
for i in range(1, n-1):
ans.append(arr[i][i+1] // ans[-1])
print(*ans)
``` | instruction | 0 | 4,268 | 20 | 8,536 |
No | output | 1 | 4,268 | 20 | 8,537 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.