message stringlengths 2 44.5k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 42 109k | cluster float64 5 5 | __index_level_0__ int64 84 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N balls. Initially, an integer A_i is written on the i-th ball.
He would like to rewrite the integer on some balls so that there are at most K different integers written on the N balls.
Find the minimum number of balls that Takahashi needs to rewrite the integers on them.
Constraints
* 1 \leq K \leq N \leq 200000
* 1 \leq A_i \leq N
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 ... A_N
Output
Print the minimum number of balls that Takahashi needs to rewrite the integers on them.
Examples
Input
5 2
1 1 2 2 5
Output
1
Input
4 4
1 1 2 2
Output
0
Input
10 3
5 1 3 2 4 1 1 2 3 4
Output
3
Submitted Solution:
```
from collections import Counter
n,k=map(int,input().split())
a=Counter(list(map(int,input().split())))
l=a.most_common()
ans=0
if k>=len(l):
print(0)
exit()
for i in range(k):
ans+=l[i][1]
print(n-ans)
``` | instruction | 0 | 61,338 | 5 | 122,676 |
Yes | output | 1 | 61,338 | 5 | 122,677 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N balls. Initially, an integer A_i is written on the i-th ball.
He would like to rewrite the integer on some balls so that there are at most K different integers written on the N balls.
Find the minimum number of balls that Takahashi needs to rewrite the integers on them.
Constraints
* 1 \leq K \leq N \leq 200000
* 1 \leq A_i \leq N
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 ... A_N
Output
Print the minimum number of balls that Takahashi needs to rewrite the integers on them.
Examples
Input
5 2
1 1 2 2 5
Output
1
Input
4 4
1 1 2 2
Output
0
Input
10 3
5 1 3 2 4 1 1 2 3 4
Output
3
Submitted Solution:
```
N, K = map(int, input().split())
A = map(int, input().split())
B = [0] * (N + 1)
for a in A:
B[a] += 1
B.sort()
B.reverse()
ans = 0
for i in range(K, N):
ans += B[i]
print(ans)
``` | instruction | 0 | 61,339 | 5 | 122,678 |
Yes | output | 1 | 61,339 | 5 | 122,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N balls. Initially, an integer A_i is written on the i-th ball.
He would like to rewrite the integer on some balls so that there are at most K different integers written on the N balls.
Find the minimum number of balls that Takahashi needs to rewrite the integers on them.
Constraints
* 1 \leq K \leq N \leq 200000
* 1 \leq A_i \leq N
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 ... A_N
Output
Print the minimum number of balls that Takahashi needs to rewrite the integers on them.
Examples
Input
5 2
1 1 2 2 5
Output
1
Input
4 4
1 1 2 2
Output
0
Input
10 3
5 1 3 2 4 1 1 2 3 4
Output
3
Submitted Solution:
```
import sys
def main():
# get inputs
num_ball = int(sys.argv[1])
lim_num_kind_of_ball = int(sys.argv[2])
arr_balls = {}
for i in range(3, len(sys.argv)):
ball = int(sys.argv[i])
if ball not in arr_balls.keys():
arr_balls[ball] = 1
else:
arr_balls[ball] += 1
num_kind_of_ball = len(arr_balls.keys())
writend_balls = 0
num_rewrite = 0
while(lim_num_kind_of_ball < num_kind_of_ball):
min_number = 200001
min_number_key = 0
for key, values in arr_balls.items():
if min_number > values:
min_number_key = key
min_number = values
num_kind_of_ball -= 1
num_rewrite += 1
# writend_balls += values
print(num_rewrite)
if __name__ == '__main__':
main()
``` | instruction | 0 | 61,340 | 5 | 122,680 |
No | output | 1 | 61,340 | 5 | 122,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N balls. Initially, an integer A_i is written on the i-th ball.
He would like to rewrite the integer on some balls so that there are at most K different integers written on the N balls.
Find the minimum number of balls that Takahashi needs to rewrite the integers on them.
Constraints
* 1 \leq K \leq N \leq 200000
* 1 \leq A_i \leq N
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 ... A_N
Output
Print the minimum number of balls that Takahashi needs to rewrite the integers on them.
Examples
Input
5 2
1 1 2 2 5
Output
1
Input
4 4
1 1 2 2
Output
0
Input
10 3
5 1 3 2 4 1 1 2 3 4
Output
3
Submitted Solution:
```
n,k = map(int,input().split())
a = list(map(int,input().split()))
kaburi = []
for i in range(n):
if not a[i] in kaburi:
kaburi.append(a[i])
kaisu = 0
while True:
p = n
q = 0
if k >= len(kaburi):
print(kaisu)
break
else:
for j in range(len(kaburi)):
p = min(p,a.count(kaburi[j]))
if p > a.count(kaburi[j]):
q = kaburi[j]
kaisu += p
print(p,q,kaisu,len(kaburi))
kaburi.remove(q)
``` | instruction | 0 | 61,341 | 5 | 122,682 |
No | output | 1 | 61,341 | 5 | 122,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N balls. Initially, an integer A_i is written on the i-th ball.
He would like to rewrite the integer on some balls so that there are at most K different integers written on the N balls.
Find the minimum number of balls that Takahashi needs to rewrite the integers on them.
Constraints
* 1 \leq K \leq N \leq 200000
* 1 \leq A_i \leq N
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 ... A_N
Output
Print the minimum number of balls that Takahashi needs to rewrite the integers on them.
Examples
Input
5 2
1 1 2 2 5
Output
1
Input
4 4
1 1 2 2
Output
0
Input
10 3
5 1 3 2 4 1 1 2 3 4
Output
3
Submitted Solution:
```
import collections
n, k, *a = map(int, open(0).read().split())
c = collections.Counter(a)
a_l = len(set(a))
if a_l -k > 0:
print(sum([d[1] for d in c.most_common()[:a_l-k:-1]]))
else:
print(0)
``` | instruction | 0 | 61,342 | 5 | 122,684 |
No | output | 1 | 61,342 | 5 | 122,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has N balls. Initially, an integer A_i is written on the i-th ball.
He would like to rewrite the integer on some balls so that there are at most K different integers written on the N balls.
Find the minimum number of balls that Takahashi needs to rewrite the integers on them.
Constraints
* 1 \leq K \leq N \leq 200000
* 1 \leq A_i \leq N
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 ... A_N
Output
Print the minimum number of balls that Takahashi needs to rewrite the integers on them.
Examples
Input
5 2
1 1 2 2 5
Output
1
Input
4 4
1 1 2 2
Output
0
Input
10 3
5 1 3 2 4 1 1 2 3 4
Output
3
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int,input().split()))
ans = []
for num in list(set(a)):
ans.append(a.count(num))
ans.sort(reverse=True)
for i in range(k):
ans.pop(0)
print(sum(ans))
``` | instruction | 0 | 61,343 | 5 | 122,686 |
No | output | 1 | 61,343 | 5 | 122,687 |
Provide a correct Python 3 solution for this coding contest problem.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0 | instruction | 0 | 61,376 | 5 | 122,752 |
"Correct Solution:
```
from collections import defaultdict, Counter
import sys
# dp[n][使った数字(bit)][合計] = count
dp = [defaultdict(Counter) for _ in [0]*11]
dp[0][0][0] = 1
for i in range(1, 11):
for used, counter in dp[i-1].items():
for j in filter(lambda x: used & 2**x == 0, range(10)):
for total, count in counter.items():
dp[i][used|2**j][total+j*i] += count
for n, s in (map(int, l.rstrip().split()) for l in sys.stdin):
print(sum(v for counter in dp[n].values() for k, v in counter.items() if k == s))
``` | output | 1 | 61,376 | 5 | 122,753 |
Provide a correct Python 3 solution for this coding contest problem.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0 | instruction | 0 | 61,377 | 5 | 122,754 |
"Correct Solution:
```
def solve(used,rest,sum,memo):
if rest==0:
return sum==0
else:
num=0
for i in range(10):
num*=2
if used[i]:num+=1
if (num,rest,sum) in memo:
return memo[(num,rest,sum)]
if sum<0:return 0
ans=0
for i in range(10):
if not used[i]:
used[i]=True
ans+=solve(used,rest-1,sum-(i)*rest,memo)
used[i]=False
memo[(num,rest,sum)]=ans
return memo[(num,rest,sum)]
memo={}
while True:
try:
n,s=map(int,input().split())
used=[False for i in range(10)]
ans=solve(used,n,s,memo)
print(ans)
except:
break
``` | output | 1 | 61,377 | 5 | 122,755 |
Provide a correct Python 3 solution for this coding contest problem.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0 | instruction | 0 | 61,378 | 5 | 122,756 |
"Correct Solution:
```
max = 0
for i in range(1,10):
max += i * (i + 1)
dp=[[[-1] * 1025 for i in range(max + 1)] for j in range(11)]
def solve(n,s,used):
if n == 0 and s == 0:
return 1;
if n <= 0 or s < 0:
return 0
if dp[n][s][used] != -1:
return dp[n][s][used]
sum = 0
for i in range(0,10):
if (used >> i) % 2 == 0:
used += 1 << i
sum += solve(n - 1,s - i * n,used)
used -= 1 << i
dp[n][s][used] = sum
return sum
while(1):
try:
n,s = (int(x) for x in input().split())
ans = 0
if s >= 0 and s <= max:
used = 0
ans = solve(n,s,used)
print(ans)
except:
break
``` | output | 1 | 61,378 | 5 | 122,757 |
Provide a correct Python 3 solution for this coding contest problem.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0 | instruction | 0 | 61,379 | 5 | 122,758 |
"Correct Solution:
```
from itertools import combinations
import sys
# dp[n][使った数字(bit)][合計] = count
dp = [[[0]*331 for _ in [0]*2048] for _ in [0]*11]
for i in range(11):
dp[1][2**i][i] = 1
for i in range(2, 11):
for used in (sum(comb) for comb in combinations([2**n for n in range(10)], i-1)):
for j in filter(lambda x: used & 2**x == 0, range(10)):
for total, count in filter(lambda p: p[1]>0, enumerate(dp[i-1][used])):
dp[i][used|2**j][total+j*i] += count
for n, s in (map(int, l.rstrip().split()) for l in sys.stdin):
print(sum(a[s] for a in dp[n] if a[s]) if s<331 else 0)
``` | output | 1 | 61,379 | 5 | 122,759 |
Provide a correct Python 3 solution for this coding contest problem.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0 | instruction | 0 | 61,380 | 5 | 122,760 |
"Correct Solution:
```
import sys
def memoize(f):
memo = {}
def main(*args):
if args in memo:
return memo[args]
result = memo[args] = f(*args)
return result
return main
def get_num(remains):
i = 0
while remains:
if remains & 1:
yield i
i += 1
remains >>= 1
@memoize
def calc(n, s, remains):
if n == 1:
if remains & (1 << s):
return 1
else:
return 0
if s <= 0:
return 0
return sum(calc(n - 1, s - n * m, remains ^ (1 << m)) for m in get_num(remains) if s - n * m >= 0)
for line in sys.stdin:
n, s = map(int, line.split())
print(calc(n, s, (1 << 10) - 1))
``` | output | 1 | 61,380 | 5 | 122,761 |
Provide a correct Python 3 solution for this coding contest problem.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0 | instruction | 0 | 61,381 | 5 | 122,762 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0070
"""
import sys
import time
from itertools import permutations
def solve1(pick, target):
# ????´???????????????????
# ??????????????°????????°????¢?????????¨?????????????????°????????????????¢???????????????§???????????????????????????
hit = 0 # ?????¶??????????????????????????°
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick): # ??¨????????°?????????pick????????°?????????????????????????????????
temp = []
# ?????????????????????????????????n=1?????????????????????????????????eval??§????¨????????¨??????????
for i in range(1, pick+1):
temp.append('{} * {}'.format(i, nums[0]))
nums = nums[1:]
exp = ' + '.join(temp)
ans = eval(exp)
if ans == target:
# print(exp)
hit += 1
return hit
def solve2(pick, target):
# ????????§??????????????£???????????§?????????????????§???????????????
# 10?????\?????????????????£??????????????????????????????40.0[s]??\???????????£??????????????§?????????????????§????????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
ans = 0 # n??????????????§???????¨????
for i in range(1, pick+1):
ans += (i * nums[i-1])
if ans > target: # ????¨???????????????????????????¨????????\????¶???????????????¶????????????????????§??????????????§???????????????
break
if ans == target:
hit += 1
return hit
def solve3(pick, target):
# zip()????????¨?????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = [x * y for x, y in zip(nums, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])]
ans = sum(temp)
if ans == target:
hit += 1
return hit
def calc_min_max(pick, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = range(1, pick+1)
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
numbers = numbers[-pick:]
temp = [x*y for x, y in zip(numbers, multiplier)]
max = sum(temp)
return min, max
def solve4(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# ??°??????1?????????????????????????????°????????????????????¨?????§??????????¨???????min, max???????¨?????????????
# ??????????????????????¨?????????°??????????????¨?????§?????????????????????????????°?????§??????????????§??????????????£?????¨????????§????????????????????¢??????????????????
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
p_min, p_max = calc_min_max(pick-1, lnumbers)
if target-(n*pick) > p_max or target-(n*pick) < p_min:
continue
else:
solve4(pick-1, target-(n*pick), lnumbers)
def has_possibility(pick, target, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§???????±???????
# ???????????°?????????????????????????????????????????????????????????
if pick == 1:
return numbers[0] <= target <= numbers[-1]
multiplier = range(1, pick+1)
max_numbers = numbers[-pick:] # ??§??????????????°??????pick????????????
max = sum(x*y for x, y in zip(max_numbers, multiplier))
if target > max:
return False
min_numbers = numbers[:pick]
#min_numbers.sort(reverse=True)
min_numbers.reverse() # .sort(reverse=True)?????????????????£????????????
min = sum(x*y for x, y in zip(min_numbers, multiplier))
if target < min:
return False
return True
Hit = 0
def solve5(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# ??°??????1?????????????????????????????°????????????????????¨?????§??????????¨???????min, max???????¨?????????????
# ??????????????????????¨?????????°??????????????¨?????§?????????????????????????????°?????§??????????????§??????????????£?????¨????????§????????????????????¢??????????????????
# 4.xx [s]
global Hit
if pick == 1:
if target in numbers:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
if has_possibility(pick-1, target-(n*pick), lnumbers):
solve5(pick-1, target-(n*pick), lnumbers)
else:
continue
def main(args):
global Hit
for line in sys.stdin:
pick, target = [int(x) for x in line.strip().split(' ')]
solve5(pick, target)
print(Hit)
Hit = 0
# solve5(8, 100)
# print(Hit)
# Hit = 0
# solve5(9, 150)
# print(Hit)
# Hit = 0
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 61,381 | 5 | 122,763 |
Provide a correct Python 3 solution for this coding contest problem.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0 | instruction | 0 | 61,382 | 5 | 122,764 |
"Correct Solution:
```
ans=[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 2, 1, 3, 3, 3, 4, 5, 4, 5, 5, 4, 5, 5, 4, 5, 5, 4, 5, 4, 3, 3, 3, 1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 3, 2, 6, 5, 6, 8, 13, 8, 16, 14, 14, 16, 23, 15, 26, 22, 21, 24, 30, 19, 31, 26, 22, 26,31, 19, 30, 24, 21, 22, 26, 15, 23, 16, 14, 14, 16, 8, 13, 8, 6, 5, 6, 2, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 4, 4, 9, 11, 14, 16, 25, 20, 32, 29, 38, 38, 56, 45, 70, 61, 74, 69, 92, 71, 103, 88, 105, 100, 136, 98, 131, 113, 131, 119, 150, 118, 150, 119, 160, 119, 150, 118, 150, 119, 131, 113, 131, 98, 136, 100, 105, 88, 103, 71, 92, 69, 74, 61, 70, 45, 56, 38, 38, 29, 32, 20, 25, 16, 14, 11, 9, 4, 4, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 5, 7, 13, 22, 25, 32, 49, 52, 62, 76, 88, 91, 119, 114, 146, 160, 170, 172, 231, 223, 249, 269, 298, 297, 372, 326, 375, 404, 407, 424, 484, 464,481, 514, 553, 533, 581, 554, 589, 653, 597, 601, 657, 630, 647, 660, 643, 643, 660, 647, 630, 657, 601,597, 653, 589, 554, 581, 533, 553, 514, 481, 464, 484, 424, 407, 404, 375, 326, 372, 297, 298, 269, 249,223, 231, 172, 170, 160, 146, 114, 119, 91, 88, 76, 62, 52, 49, 32, 25, 22, 13, 7, 5, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 11, 19, 38, 44, 62, 88, 106, 124, 170, 188, 221, 271, 276, 323, 397, 395, 438, 533, 544, 568, 687, 694, 769, 861, 893, 942, 1114, 1078, 1180, 1293, 1342, 1351, 1574, 1491, 1640, 1748, 1775, 1764, 2029, 1920, 2026, 2162, 2178, 2191, 2430, 2292, 2383, 2552, 2488, 2488, 2709, 2583, 2598, 2777, 2618, 2659, 2841, 2657, 2657, 2841, 2659, 2618, 2777, 2598, 2583, 2709, 2488, 2488, 2552, 2383, 2292, 2430, 2191, 2178, 2162, 2026, 1920, 2029, 1764, 1775, 1748, 1640, 1491, 1574, 1351, 1342, 1293, 1180, 1078, 1114, 942, 893,861, 769, 694, 687, 568, 544, 533, 438, 395, 397, 323, 276, 271, 221, 188, 170, 124, 106, 88, 62, 44, 38, 19, 11, 6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 7, 16, 28, 59, 75, 109, 151, 206, 234, 335, 360, 467, 529, 630, 675, 896, 878, 1053, 1141, 1340, 1294, 1632, 1571, 1895, 1896, 2184, 2129, 2632, 2485, 2926, 2909, 3356, 3190, 3911, 3583, 4259, 4158, 4663, 4477, 5370, 4886, 5622, 5475, 6171, 5776, 6772, 6186, 7073, 6776, 7435, 6953, 8178, 7344, 8270, 7927, 8551, 8030, 9184, 8285, 9227, 8758, 9408, 8650, 9937, 8868, 9716, 9281, 9870, 9035, 10092, 9035, 9870, 9281, 9716, 8868, 9937, 8650, 9408, 8758, 9227,8285, 9184, 8030, 8551, 7927, 8270, 7344, 8178, 6953, 7435, 6776, 7073, 6186, 6772, 5776, 6171, 5475, 5622, 4886, 5370, 4477, 4663, 4158, 4259, 3583, 3911, 3190, 3356, 2909, 2926, 2485, 2632, 2129, 2184, 1896,1895, 1571, 1632, 1294, 1340, 1141, 1053, 878, 896, 675, 630, 529, 467, 360, 335, 234, 206, 151, 109, 75, 59, 28, 16, 7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 8, 22, 40, 83, 122, 173, 248, 350, 408, 575, 669, 842, 963, 1211, 1264, 1652, 1767, 2083, 2248, 2752, 2671, 3274, 3352, 3928, 3978, 4624, 4554, 5428, 5384, 6115, 6158, 7195, 6897, 8052, 7886, 8928, 8772, 10083, 9670, 11309, 10830, 12110, 11865, 13681, 12871, 14740, 14098, 15900, 15138, 17241, 15947, 18464, 17353, 19307, 18345, 20745, 18949, 21681, 20236, 22624, 21027, 23607, 21467, 24536, 22553, 24793, 23187, 26012, 23373, 26355, 24094, 26581, 24463, 27187, 24377, 27453, 24768, 27006, 24768, 27453, 24377, 27187, 24463, 26581, 24094, 26355, 23373, 26012, 23187, 24793, 22553, 24536, 21467, 23607, 21027, 22624, 20236, 21681, 18949, 20745, 18345, 19307, 17353, 18464, 15947, 17241, 15138, 15900, 14098, 14740, 12871, 13681, 11865, 12110, 10830, 11309, 9670, 10083, 8772, 8928, 7886, 8052, 6897, 7195, 6158, 6115, 5384, 5428, 4554, 4624, 3978, 3928, 3352, 3274, 2671, 2752, 2248, 2083, 1767, 1652, 1264, 1211, 963, 842, 669, 575, 408, 350, 248, 173, 122, 83, 40, 22, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 28, 51, 107, 177, 234, 360, 498, 619, 819, 1040, 1252, 1528, 1824, 2010, 2533, 2837, 3180, 3676, 4305, 4493, 5130, 5672, 6156, 6909, 7424, 7830, 8773, 9392, 9892, 10678, 11647, 12141, 13026, 13918, 14519, 15611, 16278, 16780, 18686, 19280, 19586, 20795, 22385, 22896, 23948, 24970, 26012, 27096, 28467, 28427, 30540, 31272, 31774, 33264, 34748, 34499, 36299, 36596, 38456, 38926, 39984, 39386, 42068, 42848, 42424, 42925, 45044, 44584, 46040, 45496, 46890, 47036, 47341, 47646, 48887, 48840, 48044, 48540, 50066, 48970, 49062, 49062, 48970, 50066, 48540, 48044, 48840, 48887, 47646, 47341, 47036, 46890, 45496, 46040, 44584, 45044, 42925, 42424, 42848, 42068, 39386, 39984, 38926, 38456, 36596, 36299, 34499, 34748, 33264, 31774, 31272, 30540, 28427, 28467, 27096, 26012, 24970, 23948, 22896, 22385, 20795, 19586, 19280, 18686, 16780, 16278, 15611, 14519, 13918, 13026, 12141, 11647, 10678, 9892, 9392, 8773, 7830, 7424, 6909, 6156, 5672, 5130, 4493, 4305, 3676, 3180, 2837, 2533, 2010, 1824, 1528, 1252, 1040, 819, 619, 498, 360, 234, 177, 107, 51, 28, 9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 28, 51, 107, 177, 234,360, 498, 619, 819, 1040, 1252, 1528, 1824, 2010, 2533, 2837, 3180, 3676, 4305, 4493, 5130, 5672, 6156, 6909, 7424, 7830, 8773, 9392, 9892, 10678, 11647, 12141, 13026, 13918, 14519, 15611, 16278, 16780, 18686,19280, 19586, 20795, 22385, 22896, 23948, 24970, 26012, 27096, 28467, 28427, 30540, 31272, 31774, 33264,34748, 34499, 36299, 36596, 38456, 38926, 39984, 39386, 42068, 42848, 42424, 42925, 45044, 44584, 46040,45496, 46890, 47036, 47341, 47646, 48887, 48840, 48044, 48540, 50066, 48970, 49062, 49062, 48970, 50066,48540, 48044, 48840, 48887, 47646, 47341, 47036, 46890, 45496, 46040, 44584, 45044, 42925, 42424, 42848,42068, 39386, 39984, 38926, 38456, 36596, 36299, 34499, 34748, 33264, 31774, 31272, 30540, 28427, 28467,27096, 26012, 24970, 23948, 22896, 22385, 20795, 19586, 19280, 18686, 16780, 16278, 15611, 14519, 13918,13026, 12141, 11647, 10678, 9892, 9392, 8773, 7830, 7424, 6909, 6156, 5672, 5130, 4493, 4305, 3676, 3180, 2837, 2533, 2010, 1824, 1528, 1252, 1040, 819, 619, 498, 360, 234, 177, 107, 51, 28, 9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
while True:
try:
n, s = map(int, input().split())
except EOFError:
break
if s>330:
print(0)
else:
print(ans[n][s])
``` | output | 1 | 61,382 | 5 | 122,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0
Submitted Solution:
```
s_max = [0]
for i in range(1,11):
s = 0
for j in range(i):
s += (10 - j - 1)*(i - j)
s_max.append(s)
def check(u, r, s, m):
if r == 0:
return s == 0
n = 0
for i in range(10):
n *= 2
if u[i]:
n += 1
if (n, r, s) in m:
return m[(n, r, s)]
if s < 0 or s > s_max[r]:
return 0
ans = 0
for i in range(10):
if not u[i]:
u[i] = True
ans += check(u, r - 1, s - i*r, m)
u[i] = False
m[(n, r, s)] = ans
return m[(n, r, s)]
memo = {}
while True:
try:
n, s = map(int, input().split())
used = [False for i in range(10)]
ans = check(used, n, s, memo)
print(ans)
except:
break
``` | instruction | 0 | 61,384 | 5 | 122,768 |
Yes | output | 1 | 61,384 | 5 | 122,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0
Submitted Solution:
```
# AOJ 0070 Combination of Number Sequences
# Python3 2018.6.17 bal4u
vmin = [ 0, 0, 1, 4, 10, 20, 35, 56, 84, 120, 165 ]
vmax = [ 0, 9, 26, 50, 80, 115, 154, 196, 240, 285, 330 ]
lim = [ 0, 4, 13, 27, 45, 67, 94, 126, 162, 202, 247 ]
tbl = [ [ 0 ], \
[ 1, 1, 1, 1, 1 ], \
[ 1, 2, 1, 3, 3, 3, 4, 5, 4, 5, 5, 4, 5 ], \
[ 1, 3, 2, 6, 5, 6, 8, 13, 8, 16, 14, 14, 16, 23, 15, 26, 22, 21, 24, 30, 19, 31, 26, 22 ], \
[ 1, 4, 4, 9, 11, 14, 16, 25, 20, 32, 29, 38, 38, 56, 45, 70, 61, 74, 69, 92, 71, 103, 88, \
105, 100, 136, 98, 131, 113, 131, 119, 150, 118, 150, 119, 160 ], \
[ 1, 5, 7, 13, 22, 25, 32, 49, 52, 62, 76, 88, 91, 119, 114, 146, 160, 170, 172, 231, 223, \
249, 269, 298, 297, 372, 326, 375, 404, 407, 424, 484, 464, 481, 514, 553, 533, 581, 554, 589, 653, \
597, 601, 657, 630, 647, 660, 643 ], \
[ 1, 6, 11, 19, 38, 44, 62, 88, 106, 124, 170, 188, 221, 271, 276, 323, 397, 395, 438, 533, \
544, 568, 687, 694, 769, 861, 893, 942, 1114, 1078, 1180, 1293, 1342, 1351, 1574, 1491, 1640, 1748, \
1775, 1764, 2029, 1920, 2026, 2162, 2178, 2191, 2430, 2292, 2383, 2552, 2488, 2488, 2709, 2583, 2598, \
2777, 2618, 2659, 2841, 2657 ], \
[ 1, 7, 16, 28, 59, 75, 109, 151, 206, 234, 335, 360, 467, 529, 630, 675, 896, 878, 1053, \
1141, 1340, 1294, 1632, 1571, 1895, 1896, 2184, 2129, 2632, 2485, 2926, 2909, 3356, 3190, 3911, \
3583, 4259, 4158, 4663, 4477, 5370, 4886, 5622, 5475, 6171, 5776, 6772, 6186, 7073, 6776, 7435, \
6953, 8178, 7344, 8270, 7927, 8551, 8030, 9184, 8285, 9227, 8758, 9408, 8650, 9937, 8868, 9716, \
9281, 9870, 9035, 10092 ], \
[ 1, 8, 22, 40, 83, 122, 173, 248, 350, 408, 575, 669, 842, 963, 1211, 1264, 1652, 1767, \
2083, 2248, 2752, 2671, 3274, 3352, 3928, 3978, 4624, 4554, 5428, 5384, 6115, 6158, 7195, 6897, 8052, \
7886, 8928, 8772, 10083, 9670, 11309, 10830, 12110, 11865, 13681, 12871, 14740, 14098, 15900, 15138, \
17241, 15947, 18464, 17353, 19307, 18345, 20745, 18949, 21681, 20236, 22624, 21027, 23607, 21467, \
24536, 22553, 24793, 23187, 26012, 23373, 26355, 24094, 26581, 24463, 27187, 24377, 27453, 24768, 27006 ], \
[ 1, 9, 28, 51, 107, 177, 234, 360, 498, 619, 819, 1040, 1252, 1528, 1824, 2010, 2533, 2837, \
3180, 3676, 4305, 4493, 5130, 5672, 6156, 6909, 7424, 7830, 8773, 9392, 9892, 10678, 11647, 12141, \
13026, 13918, 14519, 15611, 16278, 16780, 18686, 19280, 19586, 20795, 22385, 22896, 23948, 24970, \
26012, 27096, 28467, 28427, 30540, 31272, 31774, 33264, 34748, 34499, 36299, 36596, 38456, 38926, \
39984, 39386, 42068, 42848, 42424, 42925, 45044, 44584, 46040, 45496, 46890, 47036, 47341, 47646, \
48887, 48840, 48044, 48540, 50066, 48970, 49062 ] ]
while True:
try: n, s = list(map(int, input().split()))
except: break
if n > 10 or s < vmin[n] or s > vmax[n]: ans = 0
else:
if s > lim[n]: s = vmax[n] + vmin[n] - s
s -= vmin[n]
if n == 10: n = 9
ans = tbl[n][s]
print(ans)
``` | instruction | 0 | 61,385 | 5 | 122,770 |
Yes | output | 1 | 61,385 | 5 | 122,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0070
"""
import sys
import time
from itertools import permutations
def solve1(pick, target):
# ????´???????????????????
# ??????????????°????????°????¢?????????¨?????????????????°????????????????¢???????????????§???????????????????????????
hit = 0 # ?????¶??????????????????????????°
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick): # ??¨????????°?????????pick????????°?????????????????????????????????
temp = []
# ?????????????????????????????????n=1?????????????????????????????????eval??§????¨????????¨??????????
for i in range(1, pick+1):
temp.append('{} * {}'.format(i, nums[0]))
nums = nums[1:]
exp = ' + '.join(temp)
ans = eval(exp)
if ans == target:
# print(exp)
hit += 1
return hit
def solve2(pick, target):
# ????????§??????????????£???????????§?????????????????§???????????????
# 10?????\?????????????????£??????????????????????????????40.0[s]??\???????????£??????????????§?????????????????§????????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
ans = 0 # n??????????????§???????¨????
for i in range(1, pick+1):
ans += (i * nums[i-1])
if ans > target: # ????¨???????????????????????????¨????????\????¶???????????????¶????????????????????§??????????????§???????????????
break
if ans == target:
hit += 1
return hit
def solve3(pick, target):
# zip()????????¨?????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = [x * y for x, y in zip(nums, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])]
ans = sum(temp)
if ans == target:
hit += 1
return hit
def calc_min_max(pick, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = range(1, pick+1)
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
numbers = numbers[-pick:]
temp = [x*y for x, y in zip(numbers, multiplier)]
max = sum(temp)
return min, max
def solve4(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# ??°??????1?????????????????????????????°????????????????????¨?????§??????????¨???????min, max???????¨?????????????
# ??????????????????????¨?????????°??????????????¨?????§?????????????????????????????°?????§??????????????§??????????????£?????¨????????§????????????????????¢??????????????????
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:] # ??????????????¨??§????????°???????????????????????§.remove()???????????§?????????????????????????????????????????????
lnumbers.remove(n)
p_min, p_max = calc_min_max(pick-1, lnumbers)
if target-(n*pick) > p_max or target-(n*pick) < p_min:
continue
else:
solve4(pick-1, target-(n*pick), lnumbers)
def has_possibility(pick, target, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§???????±???????
# ???????????°?????????????????????????????????????????????????????????
if pick == 1:
return numbers[0] <= target <= numbers[-1]
# ?????§????????§??????
multiplier = range(1, pick+1)
max_numbers = numbers[-pick:] # ??§??????????????°??????pick????????????
max = sum(x*y for x, y in zip(max_numbers, multiplier))
if target > max:
return False
# ????°?????????§??????
min_numbers = numbers[:pick]
#min_numbers.sort(reverse=True)
min_numbers.reverse() # .sort(reverse=True)?????????????????£????????????
min = sum(x*y for x, y in zip(min_numbers, multiplier))
if target < min:
return False
return True
Hit = 0
def solve5(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# ??°??????1?????????????????????????????°????????????????????¨?????§??????????¨???????min, max???????¨?????????????
# ??????????????????????¨?????????°??????????????¨?????§?????????????????????????????°?????§??????????????§??????????????£?????¨????????§????????????????????¢??????????????????
# 4.16 [s]
global Hit
if pick == 1: # ?????°????????????????????°???1???????´????????????????pick==1???????????§??????????????????
if target in numbers:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]# ??????????????¨??§????????°???????????????????????§.remove()???????????§?????????????????????????????????????????????
lnumbers.remove(n)
if has_possibility(pick-1, target-(n*pick), lnumbers):
solve5(pick-1, target-(n*pick), lnumbers) # ??????????????°???????????????????????????????????°????????????
def main(args):
global Hit
for line in sys.stdin:
pick, target = [int(x) for x in line.strip().split(' ')]
solve5(pick, target)
print(Hit)
Hit = 0
# solve5(8, 100)
# print(Hit)
# Hit = 0
# solve5(9, 150)
# print(Hit)
# Hit = 0
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 61,386 | 5 | 122,772 |
Yes | output | 1 | 61,386 | 5 | 122,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0
Submitted Solution:
```
import sys
readlines = sys.stdin.readlines
write = sys.stdout.write
def solve():
for line in readlines():
N, S = map(int, line.split())
memo = {}
def dfs(i, state, rest):
if i == N:
return +(rest == 0)
if rest < 0:
return 0
key = (state, rest)
if key in memo:
return memo[key]
r = 0
for k in range(10):
if state & (1 << k):
continue
r += dfs(i+1, state | (1 << k), rest - k*(i+1))
memo[key] = r
return r
write("%d\n" % dfs(0, 0, S))
solve()
``` | instruction | 0 | 61,387 | 5 | 122,774 |
Yes | output | 1 | 61,387 | 5 | 122,775 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0070
"""
import sys
from itertools import permutations
def solve1(pick, target):
# ????´???????????????????????????§???????????????????????????
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = []
for i in range(1, pick+1):
temp.append('{} * {}'.format(i, nums[0]))
nums = nums[1:]
exp = ' + '.join(temp)
ans = eval(exp)
if ans == target:
# print(exp)
hit += 1
return hit
def solve2(pick, target):
#
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
ans = 0
for i in range(1, pick+1):
ans += (i * nums[i-1])
if ans > target:
break
if ans == target:
hit += 1
return hit
def main(args):
for line in sys.stdin:
pick, target = [int(x) for x in line.strip().split(' ')]
result = solve2(pick, target)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 61,388 | 5 | 122,776 |
No | output | 1 | 61,388 | 5 | 122,777 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0
Submitted Solution:
```
from itertools import permutations
while True:
try:
line = input()
except EOFError:
break
n, s = map(int, line.split())
count = 0
for x in permutations(range(10), n):
if sum(x[i]*(i+1) for i in range(n)) == s:
count += 1
print(count)
``` | instruction | 0 | 61,389 | 5 | 122,778 |
No | output | 1 | 61,389 | 5 | 122,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0
Submitted Solution:
```
import sys
import itertools
for line in sys.stdin:
n,s=map(int,input().split())
cnt=0
for i in itertools.permutations(range(10),n):
sum=0
for j,k in enumerate(i):sum+=(j+1)*k
if sum==s:cnt+=1
print(cnt)
``` | instruction | 0 | 61,390 | 5 | 122,780 |
No | output | 1 | 61,390 | 5 | 122,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0
Submitted Solution:
```
# ??°??????????????????????????§???????????°??????
import sys
def get_max():
max_s = []
for i in range(1, 11):
sum = 0
for j in range(i):
sum += (9-j) * (i-j)
max_s.append(sum)
return max_s
def get_sequence(s, n, k, ks):
# s : ????¨?
# n : n????????°???
# k : k???????????°???????????????(1???10)
# ks: ?????¨?????????????????°????????????
if k == n:
if s % k == 0 and s // k in ks:
return 1
else:
return 0
if k > n:
return 0
cnt = 0
for i in ks:
s_copy = s
s_copy -= i * k
if s_copy < 0:
break
ks_copy = ks[:]
ks_copy.remove(i)
cnt += get_sequence(s_copy, n, k+1, ks_copy)
return cnt
def main():
max_s = get_max()
print(max_s)
while True:
line = sys.stdin.readline().strip()
if line is None or line == '':
break
data = line.split(' ')
n = int(data[0])
s = int(data[1])
if s > max_s[n-1]:
print(0)
else:
cnt = get_sequence(s, n, 1, list(range(10)))
#print(cnt)
if __name__ == '__main__':
main()
``` | instruction | 0 | 61,391 | 5 | 122,782 |
No | output | 1 | 61,391 | 5 | 122,783 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0 | instruction | 0 | 61,459 | 5 | 122,918 |
"Correct Solution:
```
def resolve():
input()
A = [int(i) for i in input().split()]
Q = int(input())
for _ in range(Q):
q = [int(i) for i in input().split()]
print(A[q[0]:q[1]].count(q[2]))
resolve()
``` | output | 1 | 61,459 | 5 | 122,919 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0 | instruction | 0 | 61,460 | 5 | 122,920 |
"Correct Solution:
```
def get_wall_index(ary, key, side):
left = 0
right = len(ary) - 1
while left <= right:
mid = (left + right) // 2
if ary[mid] < key:
left = mid + 1
elif key < ary[mid]:
right = mid - 1
else:
return mid + side
return left
def main():
input()
input_data = list(map(int,input().split()))
hash_list = {}
for i,num in enumerate(input_data):
if num not in hash_list:
hash_list[num] = []
hash_list[num].append(i)
query_size = int(input())
for _ in range(query_size):
begin, end, index = map(int,input().split())
if index in hash_list:
left_wall = get_wall_index(hash_list[index],begin,0)
right_wall = get_wall_index(hash_list[index],end-1,1)
print(right_wall - left_wall)
else:
print(0)
if __name__ == '__main__':
main()
``` | output | 1 | 61,460 | 5 | 122,921 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0 | instruction | 0 | 61,461 | 5 | 122,922 |
"Correct Solution:
```
N = int(input())
X = list(map(int,input().split()))
q = int(input())
for i in range(q):
a = input().split()
j = int(a[0])
t = int(a[1])
s = int(a[2])
count= 0
for p in X[j:t]:
if p == s:
count += 1
print(count)
``` | output | 1 | 61,461 | 5 | 122,923 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0 | instruction | 0 | 61,462 | 5 | 122,924 |
"Correct Solution:
```
n = int(input())
l = list(map(int, input().split()))
q = int(input())
for i in range(q):
b, e, k = map(int, input().split())
print(l[b:e].count(k))
``` | output | 1 | 61,462 | 5 | 122,925 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0 | instruction | 0 | 61,463 | 5 | 122,926 |
"Correct Solution:
```
input()
nums = list(map(int, input().split(' ')))
r = input()
for _ in range(int(r)):
f, l, v = list(map(int, input().split(' ')))
print(nums[f:l].count(v))
``` | output | 1 | 61,463 | 5 | 122,927 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0 | instruction | 0 | 61,464 | 5 | 122,928 |
"Correct Solution:
```
n=int(input())
A=list(map(int,input().split()))
q=int(input())
for i in range(q):
query=list(map(int,input().split()))
print(A[query[0]:query[1]].count(query[2]))
``` | output | 1 | 61,464 | 5 | 122,929 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0 | instruction | 0 | 61,465 | 5 | 122,930 |
"Correct Solution:
```
n = int(input())
A = list(map(int, input().split()))
q = int(input())
for _ in range(q):
b, e, k = map(int, input().split())
print(A[b:e].count(k))
``` | output | 1 | 61,465 | 5 | 122,931 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0 | instruction | 0 | 61,466 | 5 | 122,932 |
"Correct Solution:
```
N = int(input())
A = list(map(int,input().split()))
Q = int(input())
for _ in range(Q):
b,e,k = map(int,input().split())
print(A[b:e].count(k))
``` | output | 1 | 61,466 | 5 | 122,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0
Submitted Solution:
```
n=int(input())
a=list(map(int, input().split()))
q=int(input())
for i in range(q):
b,e,k=map(int,input().split())
cnt=0
cnt+=a[b:e].count(k)
print(cnt)
cnt=0
``` | instruction | 0 | 61,467 | 5 | 122,934 |
Yes | output | 1 | 61,467 | 5 | 122,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0
Submitted Solution:
```
if __name__ == '__main__':
n = int(input())
A = list(map(int,input().split()))
n2 = int(input())
for i in range(n2):
b,e,k = map(int,input().split())
print(A[b:e].count(k))
``` | instruction | 0 | 61,468 | 5 | 122,936 |
Yes | output | 1 | 61,468 | 5 | 122,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
q = int(input())
for i in range(q) :
b, e, k = map(int, input().split())
count = 0
for j in range(b, e) :
if a[j] == k :
count += 1
print(count)
``` | instruction | 0 | 61,469 | 5 | 122,938 |
Yes | output | 1 | 61,469 | 5 | 122,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0
Submitted Solution:
```
def main():
n = int(input())
A = list(map(int,input().split()))
q = int(input())
for _ in range(q):
a,b,c = map(int,input().split())
res = 0
for i in range(a,b):
if A[i]==c:res+=1
print (res)
if __name__ == '__main__':
main()
``` | instruction | 0 | 61,470 | 5 | 122,940 |
Yes | output | 1 | 61,470 | 5 | 122,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have received your birthday gifts — n triples of integers! The i-th of them is { a_{i}, b_{i}, c_{i} }. All numbers are greater than or equal to 0, and strictly smaller than 2^{k}, where k is a fixed integer.
One day, you felt tired playing with triples. So you came up with three new integers x, y, z, and then formed n arrays. The i-th array consists of a_i repeated x times, b_i repeated y times and c_i repeated z times. Thus, each array has length (x + y + z).
You want to choose exactly one integer from each array such that the XOR (bitwise exclusive or) of them is equal to t. Output the number of ways to choose the numbers for each t between 0 and 2^{k} - 1, inclusive, modulo 998244353.
Input
The first line contains two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 17) — the number of arrays and the binary length of all numbers.
The second line contains three integers x, y, z (0 ≤ x,y,z ≤ 10^{9}) — the integers you chose.
Then n lines follow. The i-th of them contains three integers a_{i}, b_{i} and c_{i} (0 ≤ a_{i} , b_{i} , c_{i} ≤ 2^{k} - 1) — the integers forming the i-th array.
Output
Print a single line containing 2^{k} integers. The i-th of them should be the number of ways to choose exactly one integer from each array so that their XOR is equal to t = i-1 modulo 998244353.
Examples
Input
1 1
1 2 3
1 0 1
Output
2 4
Input
2 2
1 2 1
0 1 2
1 2 3
Output
4 2 4 6
Input
4 3
1 2 3
1 3 7
0 2 5
1 0 6
3 3 2
Output
198 198 126 126 126 126 198 198
Note
In the first example, the array we formed is (1, 0, 0, 1, 1, 1), we have two choices to get 0 as the XOR and four choices to get 1.
In the second example, two arrays are (0, 1, 1, 2) and (1, 2, 2, 3). There are sixteen (4 ⋅ 4) choices in total, 4 of them (1 ⊕ 1 and 2 ⊕ 2, two options for each) give 0, 2 of them (0 ⊕ 1 and 2 ⊕ 3) give 1, 4 of them (0 ⊕ 2 and 1 ⊕ 3, two options for each) give 2, and finally 6 of them (0 ⊕ 3, 2 ⊕ 1 and four options for 1 ⊕ 2) give 3.
Submitted Solution:
```
n, k = [int(i) for i in input().split()]
x, y, z = [int(i) for i in input().split()]
data = []
for i in range(n):
data.append([int(i) for i in input().split()])
d1 = data[0]
d2 = []
for i in range(n - 1):
for n1 in d1:
for n2 in data[i + 1]:
d2.append(n1 ^ n2)
d1 = d2
d2 = []
amount = [x, y, z]
a = []
for i in range(n - 1):
for n1 in amount:
for n2 in [x, y, z]:
a.append(n1 * n2)
amount = a
a = []
result = [0]*2**k
for i in range(len(d1)):
result[d1[i]] += amount[i]
print(' '.join([str(r) for r in result]))
``` | instruction | 0 | 61,520 | 5 | 123,040 |
No | output | 1 | 61,520 | 5 | 123,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have received your birthday gifts — n triples of integers! The i-th of them is { a_{i}, b_{i}, c_{i} }. All numbers are greater than or equal to 0, and strictly smaller than 2^{k}, where k is a fixed integer.
One day, you felt tired playing with triples. So you came up with three new integers x, y, z, and then formed n arrays. The i-th array consists of a_i repeated x times, b_i repeated y times and c_i repeated z times. Thus, each array has length (x + y + z).
You want to choose exactly one integer from each array such that the XOR (bitwise exclusive or) of them is equal to t. Output the number of ways to choose the numbers for each t between 0 and 2^{k} - 1, inclusive, modulo 998244353.
Input
The first line contains two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 17) — the number of arrays and the binary length of all numbers.
The second line contains three integers x, y, z (0 ≤ x,y,z ≤ 10^{9}) — the integers you chose.
Then n lines follow. The i-th of them contains three integers a_{i}, b_{i} and c_{i} (0 ≤ a_{i} , b_{i} , c_{i} ≤ 2^{k} - 1) — the integers forming the i-th array.
Output
Print a single line containing 2^{k} integers. The i-th of them should be the number of ways to choose exactly one integer from each array so that their XOR is equal to t = i-1 modulo 998244353.
Examples
Input
1 1
1 2 3
1 0 1
Output
2 4
Input
2 2
1 2 1
0 1 2
1 2 3
Output
4 2 4 6
Input
4 3
1 2 3
1 3 7
0 2 5
1 0 6
3 3 2
Output
198 198 126 126 126 126 198 198
Note
In the first example, the array we formed is (1, 0, 0, 1, 1, 1), we have two choices to get 0 as the XOR and four choices to get 1.
In the second example, two arrays are (0, 1, 1, 2) and (1, 2, 2, 3). There are sixteen (4 ⋅ 4) choices in total, 4 of them (1 ⊕ 1 and 2 ⊕ 2, two options for each) give 0, 2 of them (0 ⊕ 1 and 2 ⊕ 3) give 1, 4 of them (0 ⊕ 2 and 1 ⊕ 3, two options for each) give 2, and finally 6 of them (0 ⊕ 3, 2 ⊕ 1 and four options for 1 ⊕ 2) give 3.
Submitted Solution:
```
n, k = [int(i) for i in input().split()]
x, y, z = [int(i) for i in input().split()]
data = []
for i in range(n):
"""a, b, c = [int(i) for i in input().split()]
data.append([a]*x + [b]*y + [c]*z)"""
data.append([int(i) for i in input().split()])
d1 = data[0]
d2 = []
for i in range(n - 1):
for n1 in d1:
for n2 in data[i + 1]:
d2.append(n1 ^ n2)
d1 = d2
d2 = []
amount = [x, y, z]
a = []
for i in range(n - 1):
for n1 in amount:
for n2 in [x, y, z]:
a.append(n1 * n2)
amount = a
a = []
result = [0]*2**k
for i in range(len(d1)):
result[d1[i]] += amount[i]
print(' '.join([str(r) for r in result]))
``` | instruction | 0 | 61,521 | 5 | 123,042 |
No | output | 1 | 61,521 | 5 | 123,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Input
The input contains a single integer a (0 ≤ a ≤ 63).
Output
Output a single number.
Examples
Input
2
Output
2
Input
5
Output
24
Input
35
Output
50
Submitted Solution:
```
s = bin(int(input()))[2:].zfill(6)
print(int(s[0]+s[5]+s[3]+s[2]+s[4]+s[1],2))
``` | instruction | 0 | 61,611 | 5 | 123,222 |
Yes | output | 1 | 61,611 | 5 | 123,223 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Input
The input contains a single integer a (0 ≤ a ≤ 63).
Output
Output a single number.
Examples
Input
2
Output
2
Input
5
Output
24
Input
35
Output
50
Submitted Solution:
```
x = int(input())
x = bin(x)[2:]
x = list(x)
x = ["0"]*(6-len(x)) + x
temp = x[5]
x[5] = x[1]
x[1] = temp
temp = x[2]
x[2] = x[3]
x[3] = temp
x = ''.join(x)
print(int(x,2))
``` | instruction | 0 | 61,612 | 5 | 123,224 |
Yes | output | 1 | 61,612 | 5 | 123,225 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Input
The input contains a single integer a (0 ≤ a ≤ 63).
Output
Output a single number.
Examples
Input
2
Output
2
Input
5
Output
24
Input
35
Output
50
Submitted Solution:
```
a = int(input())
digits = []
for i in range(6):
digits.append(a % 2)
a //= 2
digits = digits[::-1]
digits_reordered = [digits[0], digits[5], digits[3], digits[2], digits[4], digits[1]]
answer = 0
for d in digits_reordered:
answer = answer * 2 + d
print(answer)
``` | instruction | 0 | 61,614 | 5 | 123,228 |
Yes | output | 1 | 61,614 | 5 | 123,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Input
The input contains a single integer a (0 ≤ a ≤ 63).
Output
Output a single number.
Examples
Input
2
Output
2
Input
5
Output
24
Input
35
Output
50
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Apr 2 00:03:10 2020
@author: maruf
"""
n=int(input())
num=bin(n).replace("0b", "")
num2=[]
num_list=list(num)
t=0
while(t<(6-len(num_list))):
num2.append("0")
t+=1
num2=num2+num_list
#print("".join(num2))
num_2=num2[1]
num_6=num2[-1]
num_3=num2[2]
num_4=num2[3]
num2[1]=num_6
num2[-1]=num_2
num2[2]=num_4
num2[3]=num_2
original_number=str("".join(num2))
print(int(original_number,2))
``` | instruction | 0 | 61,615 | 5 | 123,230 |
No | output | 1 | 61,615 | 5 | 123,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Input
The input contains a single integer a (0 ≤ a ≤ 63).
Output
Output a single number.
Examples
Input
2
Output
2
Input
5
Output
24
Input
35
Output
50
Submitted Solution:
```
p = [0, 5, 3, 1, 4, 2]
s = bin(int(input()))[2:].zfill(6)
print(int("".join([s[x] for x in p]), 2))
``` | instruction | 0 | 61,616 | 5 | 123,232 |
No | output | 1 | 61,616 | 5 | 123,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Input
The input contains a single integer a (0 ≤ a ≤ 63).
Output
Output a single number.
Examples
Input
2
Output
2
Input
5
Output
24
Input
35
Output
50
Submitted Solution:
```
to_go = [4, 1, 3, 0, 2, 5]
n = int(input())
assert n != 3
old = ""
for i in range(6):
old += str(n % 2)
n //= 2
old = list(old)
# print(old)
new = [0] * 6
for i in range(6):
new[to_go[i]] = old[i]
new = reversed(new)
res = int("".join(new), 2)
print(res)
``` | instruction | 0 | 61,617 | 5 | 123,234 |
No | output | 1 | 61,617 | 5 | 123,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Input
The input contains a single integer a (0 ≤ a ≤ 63).
Output
Output a single number.
Examples
Input
2
Output
2
Input
5
Output
24
Input
35
Output
50
Submitted Solution:
```
def helper_to_binary(n):
ans = []
for i in range(6):
ans.append(n%2)
n = n//2
return ans[::-1]
def helper_from_binary(l):
ans = 0
for i in range(6):
ans += l[::-1][i]*2**i
return ans
n = int(input())
permute = [0,5,3,2,4,1]
print(helper_from_binary([helper_to_binary(5)[permute[i]] for i in range(6)]))
``` | instruction | 0 | 61,618 | 5 | 123,236 |
No | output | 1 | 61,618 | 5 | 123,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. Print a+b.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case is given as a line of two integers a and b (-1000 ≤ a, b ≤ 1000).
Output
Print t integers — the required numbers a+b.
Example
Input
4
1 5
314 15
-99 99
123 987
Output
6
329
0
1110 | instruction | 0 | 61,619 | 5 | 123,238 |
Tags: implementation
Correct Solution:
```
def solve():
nbCase= int(input())
for i in range(nbCase):
line= input()
inputs= list(map(int, line.split()))
res=inputs[0]+inputs[1]
print(res)
solve()
``` | output | 1 | 61,619 | 5 | 123,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. Print a+b.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case is given as a line of two integers a and b (-1000 ≤ a, b ≤ 1000).
Output
Print t integers — the required numbers a+b.
Example
Input
4
1 5
314 15
-99 99
123 987
Output
6
329
0
1110 | instruction | 0 | 61,620 | 5 | 123,240 |
Tags: implementation
Correct Solution:
```
def fsm(a,b):
print(a+b)
return
t=int(input())
for i in range(t):
T=input()
l = list(map(int,T.split(" ")))
fsm(l[0],l[1])
``` | output | 1 | 61,620 | 5 | 123,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. Print a+b.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case is given as a line of two integers a and b (-1000 ≤ a, b ≤ 1000).
Output
Print t integers — the required numbers a+b.
Example
Input
4
1 5
314 15
-99 99
123 987
Output
6
329
0
1110 | instruction | 0 | 61,621 | 5 | 123,242 |
Tags: implementation
Correct Solution:
```
n=int(input())
for i in range(n):
p,q=map(int,input().split())
print(p+q)
``` | output | 1 | 61,621 | 5 | 123,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. Print a+b.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case is given as a line of two integers a and b (-1000 ≤ a, b ≤ 1000).
Output
Print t integers — the required numbers a+b.
Example
Input
4
1 5
314 15
-99 99
123 987
Output
6
329
0
1110 | instruction | 0 | 61,622 | 5 | 123,244 |
Tags: implementation
Correct Solution:
```
n = int(input())
for i in range(n):
a, b = input().split()
print(int(a) + int(b))
``` | output | 1 | 61,622 | 5 | 123,245 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. Print a+b.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case is given as a line of two integers a and b (-1000 ≤ a, b ≤ 1000).
Output
Print t integers — the required numbers a+b.
Example
Input
4
1 5
314 15
-99 99
123 987
Output
6
329
0
1110 | instruction | 0 | 61,623 | 5 | 123,246 |
Tags: implementation
Correct Solution:
```
t = int(input())
for i in range(t):
a, b= [int(x) for x in input().split()]
print(a+b)
``` | output | 1 | 61,623 | 5 | 123,247 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. Print a+b.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case is given as a line of two integers a and b (-1000 ≤ a, b ≤ 1000).
Output
Print t integers — the required numbers a+b.
Example
Input
4
1 5
314 15
-99 99
123 987
Output
6
329
0
1110 | instruction | 0 | 61,624 | 5 | 123,248 |
Tags: implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
a,b = [int(i) for i in input().split()]
print(a+b)
``` | output | 1 | 61,624 | 5 | 123,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. Print a+b.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case is given as a line of two integers a and b (-1000 ≤ a, b ≤ 1000).
Output
Print t integers — the required numbers a+b.
Example
Input
4
1 5
314 15
-99 99
123 987
Output
6
329
0
1110 | instruction | 0 | 61,626 | 5 | 123,252 |
Tags: implementation
Correct Solution:
```
test_cases = int(input())
for i in range(test_cases) :
a, b = map(int , input().split(" "))
print(a + b)
``` | output | 1 | 61,626 | 5 | 123,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two integers a and b. Print a+b.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case is given as a line of two integers a and b (-1000 ≤ a, b ≤ 1000).
Output
Print t integers — the required numbers a+b.
Example
Input
4
1 5
314 15
-99 99
123 987
Output
6
329
0
1110
Submitted Solution:
```
for i in range(int(input())):
n,m = map(int,input().split())
print(n+m)
``` | instruction | 0 | 61,627 | 5 | 123,254 |
Yes | output | 1 | 61,627 | 5 | 123,255 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.