message stringlengths 2 59.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 37 108k | cluster float64 20 20 | __index_level_0__ int64 74 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all.
Submitted Solution:
```
n,t = list(map(int,input().split()))
s = list(input())
p = 0
index = n-1
for i in range(0,n):
if s[i] == '.':
p = i
if p == 0 :
continue
if s[i] >= '5' :
index = i
break
while s[index] >= '5' and index > p and t>0 :
if s[index-1] == '.' :
index = index - 1
break
index = index - 1
s[index] = str(int(s[index]) + 1)
t = t - 1
flag = 0
# print(index,p)
if p == index :
flag = 1
index = index - 1
while index >=0 and flag != 0 :
if s[index] == '9' :
s[index] = '0'
flag = 1
else :
s[index] = str( int(s[index]) + 1)
flag = 0
index = index -1
index = p - 1
if flag != 0 :
print(1, end = "")
for i in range(0,index+1) :
print(s[i],end = "")
print("")
``` | instruction | 0 | 30,573 | 20 | 61,146 |
No | output | 1 | 30,573 | 20 | 61,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all.
Submitted Solution:
```
long, T = (int(I) for I in input().split(' '))
W = list(input())
score = 0
for J in W:
if J != ".":
score *= 10
score += int(J)
max_score = score
#print(M)
K = len(W)-W.index('.')-1
#print(score)
for J in range(min(K,T)):
if score % (10**(J+1)) < 5:
#print("-> %d" % (score))
score //= 10**(J+1)
#print("-> %d" % (score))
score *= 10**(J+1)
#print("-> %d" % (score))
else:
score //= 10**(J)
#print("-> %d",score)
T = score//10 % 10
#print(T)
#print("-> %d",score)
score //= 100
#print("-> %d",score)
score *= 100
score += (T+1)*10
#print("-> %d",score)
score *= 10**(J)
#print("-> %d",score)
#print("#%d"%(score))
if score > max_score:
max_score = score
numbers = max_score // (10**K)
remain = max_score % (10**K)
if remain == 0:
print(numbers)
else:
while remain%10==0:
remain//=10
print("%d.%d" % (numbers,remain))
``` | instruction | 0 | 30,574 | 20 | 61,148 |
No | output | 1 | 30,574 | 20 | 61,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all.
Submitted Solution:
```
n,t=map(int,input().split())
s=input()
p=s.index('.')
#not taking s[p+1]
frac=s[p+2:]
print(frac)
temp=[]
for i in range(1,n-p):
if int(frac[i])>=5:
temp=i
break
#str(int(frac[temp])+1)
for i in range(t):
if temp<1:break
frac=frac[:temp-1]+str(int(frac[temp-1])+1)
if int(frac[-1])<5:break
temp-=1
print(frac)
if int(frac[-1])>=5:
print(s[:p+1]+str(int(s[p+1])+1))
else:
print(s[:p+1]+s[p+1]+frac[:temp+1])
#print(s[:p+1]+frac[:temp+1])
``` | instruction | 0 | 30,575 | 20 | 61,150 |
No | output | 1 | 30,575 | 20 | 61,151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all.
Submitted Solution:
```
INF = 2 * 10 ** 9
n, t = map(int, input().split(' '))
number = input()
dot = number.find('.')
number = "".join(number.split('.'))
res = [INF] * n
i = len(number) - 2
while i >= dot - 1:
if number[i+1] in {'5', '6', '7', '8', '9'}:
res[i] = 1
elif number[i+1] == '4':
res[i] = res[i+1] + 1
else :
res[i] = INF
i -= 1
for i, ch in enumerate(number):
if i == dot:
print('.', end='')
if res[i] > t:
print(ch, end='')
else:
print(int(ch) + 1, end='')
break
print()
``` | instruction | 0 | 30,576 | 20 | 61,152 |
No | output | 1 | 30,576 | 20 | 61,153 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1 | instruction | 0 | 31,009 | 20 | 62,018 |
Tags: brute force, implementation
Correct Solution:
```
k=int(input())
x=[k%4, max(-0.1,k-7)%4, max(-0.1,k-14)%4, max(-0.1,k-21)%4]
if x.count(0)==0: print("-1")
else:
y=7*x.index(0)
seven=x.index(0)
z=(k-y)//4
if z>=7:
seven+=z//7*4
z=z%7
print('4'*z+'7'*seven)
``` | output | 1 | 31,009 | 20 | 62,019 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1 | instruction | 0 | 31,010 | 20 | 62,020 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
count_num = 0
if n % 7 == 0:
print(int(n/7)*'7')
while n >=4 and n % 7 != 0:
n -= 4
count_num += 1
if n % 7 == 0 :
print(count_num*'4'+int(n/7)*'7')
if n % 7 != 0:
print('-1')
``` | output | 1 | 31,010 | 20 | 62,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1 | instruction | 0 | 31,011 | 20 | 62,022 |
Tags: brute force, implementation
Correct Solution:
```
from sys import *
input = lambda:stdin.readline()
int_arr = lambda : list(map(int,stdin.readline().strip().split()))
str_arr = lambda :list(map(str,stdin.readline().split()))
get_str = lambda : map(str,stdin.readline().strip().split())
get_int = lambda: map(int,stdin.readline().strip().split())
get_float = lambda : map(float,stdin.readline().strip().split())
mod = 1000000007
setrecursionlimit(1000)
n = int(input())
st = ''
while n > 0:
if n % 7 == 0:
n -= 7
st += '7'
elif n % 4 == 0:
n -= 4
st += '4'
else:
n -= 7
st += '7'
if n != 0:
print(-1)
else:
print(''.join(sorted(st)))
``` | output | 1 | 31,011 | 20 | 62,023 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1 | instruction | 0 | 31,012 | 20 | 62,024 |
Tags: brute force, implementation
Correct Solution:
```
import sys
from random import choice,randint
inp=sys.stdin.readline
out=sys.stdout.write
flsh=sys.stdout.flush
sys.setrecursionlimit(10**9)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def MI(): return map(int, inp().strip().split())
def LI(): return list(map(int, inp().strip().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]
def LI_(): return [int(x)-1 for x in inp().strip().split()]
def LF(): return [float(x) for x in inp().strip().split()]
def LS(): return inp().strip().split()
def I(): return int(inp().strip())
def F(): return float(inp().strip())
def S(): return inp().strip()
def pf(s): return out(s+'\n')
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
n = I()
q7 = n//7
r7 = n%7
r4 = r7%4
q4 = r7//4
if q7<r4:
print(-1)
else:
print("4"*(q4+2*r4)+"7"*(q7-r4))
if __name__ == "__main__":
main()
``` | output | 1 | 31,012 | 20 | 62,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1 | instruction | 0 | 31,013 | 20 | 62,026 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
C = 10 ** 9 + 7
memo = {0: (0, 0)}
for i in range(1, n + 1):
if i - 4 not in memo:
memo[i - 4] = (C, C)
if i - 7 not in memo:
memo[i - 7] = (C, C)
x1, y1 = memo[i - 4]
x1, y1 = memo[i - 4] if x1 == y1 == C else (x1 + 1, y1)
x2, y2 = memo[i - 7]
x2, y2 = memo[i - 7] if x2 == y2 == C else (x2, y2 + 1)
memo[i] = min((x1, y1), (x2, y2))
j, k = memo[n]
print(-1) if j == k == C else print("4" * j + "7" * k)
``` | output | 1 | 31,013 | 20 | 62,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1 | instruction | 0 | 31,014 | 20 | 62,028 |
Tags: brute force, implementation
Correct Solution:
```
n=int(input())
# n=4*a + 7*b 4......(a times) 7......(b times) mc is minimum value of a+b
b, a, mc=0, 0, [99999999999,0,0]
s= a*4 + b*7
d=99999999999
while s<=n:
b=(n-a*4)//7
s= a*4 + b*7
d=min(a+b,mc[0])
#print('wtf is going on,',a,b,d,s,mc)
if d!=mc[0] and s==n:
mc=[d,a,b]
a+=1
if a<0 or b<0:
break
print('4'*mc[1]+'7'*mc[2] if mc[1]>0 or mc[2]>0 else -1)
``` | output | 1 | 31,014 | 20 | 62,029 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1 | instruction | 0 | 31,015 | 20 | 62,030 |
Tags: brute force, implementation
Correct Solution:
```
count = 0
n = int(input())
while n >= 4 and n % 7 != 0:
n -= 4
count += 1
print("-1" if 0 < n < 4 else '4' * count + '7' * (n // 7))
``` | output | 1 | 31,015 | 20 | 62,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1 | instruction | 0 | 31,016 | 20 | 62,032 |
Tags: brute force, implementation
Correct Solution:
```
s=int(input())
x=0
ans=-1
#flag=True
while(True):
if s<0:
break
if s%7==0:
c=s//7
# if flag:
print('4'*x+'7'*c)
exit()
# flag=False
# else:
# ans=min(ans,int('4'*x+'7'*c))
s-=4
x+=1
print(ans)
``` | output | 1 | 31,016 | 20 | 62,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
Submitted Solution:
```
import sys
input = sys.stdin.readline
for _ in range(1):
n=int(input())
c4=0
while n%7!=0:
n-=4
c4+=1
if n<0:
print(-1)
else:
print('4'*c4+'7'*(n//7))
``` | instruction | 0 | 31,017 | 20 | 62,034 |
Yes | output | 1 | 31,017 | 20 | 62,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
Submitted Solution:
```
A = int(input())
ls = []
lss = []
i = 0
m = ''
k = A // 7
for a in range(k):
ls.append(7)
lss.append('7')
l = len(ls)
while i < l + 5:
P = 0
for b in ls:
P += b
if P == A:
print(m.join(lss))
i = 0
break
else:
ls.insert(0, 4)
lss.insert(0, '4')
if P > A:
del ls[-1]
del lss[-1]
i += 1
if i is not 0:
print(-1)
``` | instruction | 0 | 31,018 | 20 | 62,036 |
Yes | output | 1 | 31,018 | 20 | 62,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
Submitted Solution:
```
def main():
n = int(input())
for x in range(n, -1, -4):
if not x % 7:
print('4' * ((n - x) // 4) + '7' * (x // 7))
break
else:
print(-1)
if __name__ == '__main__':
main()
``` | instruction | 0 | 31,019 | 20 | 62,038 |
Yes | output | 1 | 31,019 | 20 | 62,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
Submitted Solution:
```
n = int(input())
rem7= n % 7
rem4= n % 4
if rem7 == 0:
answer = '7' * (n // 7)
print(answer)
elif rem7 != 0:
x = n - 4
fourCount = 1
sevenCount = 0
while x >= 7:
if x % 7 == 0:
sevenCount = x // 7
break
else:
x -= 4
fourCount += 1
if sevenCount == 0:
if rem4 == 0:
print('4' * (n // 4))
else:
print(-1)
else:
answer = '4' * (fourCount) + '7' * sevenCount
print(answer)
elif rem4 == 0:
print('4' * (n // 4))
else:
print(-1)
``` | instruction | 0 | 31,020 | 20 | 62,040 |
Yes | output | 1 | 31,020 | 20 | 62,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
Submitted Solution:
```
n=int(input())
for i in range(n//7+1):
if (n-7*i)%4==0:
j=(n-7*i)//4
if j>=0 and i>=0:
print('4'*j+'7'*i)
break
else:
print(-1)
``` | instruction | 0 | 31,021 | 20 | 62,042 |
No | output | 1 | 31,021 | 20 | 62,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
Submitted Solution:
```
n = int(input())
c = 0
dp = []
dp1 = []
while(n>1):
n = n-7
c += 1
if(n%4==0):
dp.append(int(n/4))
dp1.append(c)
four = dp[-1]
seven = dp1[-1]
s = ""
if(len(dp)==0 and n!=0):
print(-1)
elif(len(dp)==0 and n==0):
for i in range(c):
s += '7'
print(s)
else:
for i in range(four):
s += '4'
for j in range(seven):
s += '7'
print(s)
``` | instruction | 0 | 31,022 | 20 | 62,044 |
No | output | 1 | 31,022 | 20 | 62,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
Submitted Solution:
```
n=int(input())
if n%7==0:
print(n//7*"7")
elif n%4==0:
print(n//4*("4"))
else:
i = 0
while n>0 and n%4:
#print(n)
n-=7
i+=1
if n<0:
print(-1)
else:
j = int(n/4)
print((j)*"4"+i*"7")
``` | instruction | 0 | 31,023 | 20 | 62,046 |
No | output | 1 | 31,023 | 20 | 62,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.
Output
Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
Submitted Solution:
```
a=int(input())
c=(list(range(4,10000,4)))
d=(list(range(7,100000,7)))
e=(list(range(4,100000,7)))
f=(list(range(7,100000,4)))
x=(set(c+d+e+f))
if not a in x:
print("-1")
else:
ab=a//4
ac=a//7
if a%7==0:
print('7'*ac)
elif a%7!=0 and a%7==4:
print('4'+(ac*'7'))
elif a%7!=0 and a%7<=4:
print('4'*2+(ac-1)*'7')
elif a%4!=0:
print((ab-1)*'4'+'7')
elif a%4==0:
print('4'*ab)
``` | instruction | 0 | 31,024 | 20 | 62,048 |
No | output | 1 | 31,024 | 20 | 62,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a blackboard and initially only an odd number x is written on it. Your goal is to write the number 1 on the blackboard.
You may write new numbers on the blackboard with the following two operations.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their sum on the blackboard. The two numbers you have chosen remain on the blackboard.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) on the blackboard. The two numbers you have chosen remain on the blackboard.
Perform a sequence of operations such that at the end the number 1 is on the blackboard.
Input
The single line of the input contains the odd integer x (3 ≤ x ≤ 999,999).
Output
Print on the first line the number q of operations you perform. Then q lines should follow, each describing one operation.
* The "sum" operation is described by the line "a + b", where a, b must be integers already present on the blackboard.
* The "xor" operation is described by the line "a ^ b", where a, b must be integers already present on the blackboard.
The operation symbol (+ or ^) must be separated from a, b by a whitespace.
You can perform at most 100,000 operations (that is, q≤ 100,000) and all numbers written on the blackboard must be in the range [0, 5⋅10^{18}]. It can be proven that under such restrictions the required sequence of operations exists. You can output any suitable sequence of operations.
Examples
Input
3
Output
5
3 + 3
3 ^ 6
3 + 5
3 + 6
8 ^ 9
Input
123
Output
10
123 + 123
123 ^ 246
141 + 123
246 + 123
264 ^ 369
121 + 246
367 ^ 369
30 + 30
60 + 60
120 ^ 121 | instruction | 0 | 31,187 | 20 | 62,374 |
Tags: bitmasks, constructive algorithms, math, matrices, number theory
Correct Solution:
```
def pr(ans):
print(len(ans))
for i in ans:
if i[0] == 1:
print(i[1], "+", i[2])
else:
print(i[1], "^", i[2])
def fi2(st):
return pow(2,st - 1)
def colv(num, fi, mod):
return pow(num, fi - 1, mod)
step2 = set()
for i in range(64):
step2.add(pow(2,i))
a = int(input())
ans = []
x = a
k = 0
for i in range(100):
ans.append([1, x, a])
y = x + a
if y in step2:
k = y
break
ans.append([2, x, y])
x = y ^ x
if x in step2:
k = x
break
if k == 1:
pr(ans)
exit()
stk = 0
kcopy = k
while kcopy % 2 == 0:
stk += 1
kcopy //= 2
step = fi2(stk)
num = colv(a, step, k) - 1
tosteps = [a]
for i in range(1, 64):
ans.append([1, tosteps[-1], tosteps[-1]])
t = tosteps[-1] * 2
if t >= k:
ans.append([2, t, k])
t -= k
tosteps.append(t)
an = a
for i in range(64):
if num % 2 == 1:
ans.append([1, an, tosteps[i]])
an += tosteps[i]
if an > k:
ans.append([2, an, k])
an -= k
num //= 2
pr(ans)
``` | output | 1 | 31,187 | 20 | 62,375 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a blackboard and initially only an odd number x is written on it. Your goal is to write the number 1 on the blackboard.
You may write new numbers on the blackboard with the following two operations.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their sum on the blackboard. The two numbers you have chosen remain on the blackboard.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) on the blackboard. The two numbers you have chosen remain on the blackboard.
Perform a sequence of operations such that at the end the number 1 is on the blackboard.
Input
The single line of the input contains the odd integer x (3 ≤ x ≤ 999,999).
Output
Print on the first line the number q of operations you perform. Then q lines should follow, each describing one operation.
* The "sum" operation is described by the line "a + b", where a, b must be integers already present on the blackboard.
* The "xor" operation is described by the line "a ^ b", where a, b must be integers already present on the blackboard.
The operation symbol (+ or ^) must be separated from a, b by a whitespace.
You can perform at most 100,000 operations (that is, q≤ 100,000) and all numbers written on the blackboard must be in the range [0, 5⋅10^{18}]. It can be proven that under such restrictions the required sequence of operations exists. You can output any suitable sequence of operations.
Examples
Input
3
Output
5
3 + 3
3 ^ 6
3 + 5
3 + 6
8 ^ 9
Input
123
Output
10
123 + 123
123 ^ 246
141 + 123
246 + 123
264 ^ 369
121 + 246
367 ^ 369
30 + 30
60 + 60
120 ^ 121 | instruction | 0 | 31,188 | 20 | 62,376 |
Tags: bitmasks, constructive algorithms, math, matrices, number theory
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
print("500")
cnt = 500
x = int(input())
if x % 4 == 3:
print(str(x) + " + " + str(x))
print(str(2 * x) + " + " + str(x))
cnt -= 2
x *= 3
xCpy = x
bigX = x
while xCpy != 1:
print(str(bigX) + " + " + str(bigX))
cnt -= 1
xCpy //= 2
bigX *= 2
print(str(bigX) + " + " + str(x))
ans1 = bigX + x
print(str(bigX) + " ^ " + str(x))
ans2 = bigX ^ x
print(str(ans1) + " ^ " + str(ans2))
ans = ans1 ^ ans2
cnt -= 3
curX = x
while ans != 1:
curX = x
while curX != 0:
print(str(curX) + " + " + str(curX))
cnt -= 1
curX *= 2
if curX >= ans:
print(str(ans) + " ^ " + str(curX))
cnt -= 1
curX ^= ans
ans //= 2
if x >= ans:
print(str(x) + " ^ " + str(ans))
cnt -= 1
x ^= ans
while cnt > 0:
cnt -= 1
print(str(x) + " + " + str(x))
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | output | 1 | 31,188 | 20 | 62,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a blackboard and initially only an odd number x is written on it. Your goal is to write the number 1 on the blackboard.
You may write new numbers on the blackboard with the following two operations.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their sum on the blackboard. The two numbers you have chosen remain on the blackboard.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) on the blackboard. The two numbers you have chosen remain on the blackboard.
Perform a sequence of operations such that at the end the number 1 is on the blackboard.
Input
The single line of the input contains the odd integer x (3 ≤ x ≤ 999,999).
Output
Print on the first line the number q of operations you perform. Then q lines should follow, each describing one operation.
* The "sum" operation is described by the line "a + b", where a, b must be integers already present on the blackboard.
* The "xor" operation is described by the line "a ^ b", where a, b must be integers already present on the blackboard.
The operation symbol (+ or ^) must be separated from a, b by a whitespace.
You can perform at most 100,000 operations (that is, q≤ 100,000) and all numbers written on the blackboard must be in the range [0, 5⋅10^{18}]. It can be proven that under such restrictions the required sequence of operations exists. You can output any suitable sequence of operations.
Examples
Input
3
Output
5
3 + 3
3 ^ 6
3 + 5
3 + 6
8 ^ 9
Input
123
Output
10
123 + 123
123 ^ 246
141 + 123
246 + 123
264 ^ 369
121 + 246
367 ^ 369
30 + 30
60 + 60
120 ^ 121 | instruction | 0 | 31,190 | 20 | 62,380 |
Tags: bitmasks, constructive algorithms, math, matrices, number theory
Correct Solution:
```
import math
x = int(input())
ops = []
def ext_euc(a, b) :
s = 0
old_s = 1
t = 1
old_t = 0
while a != 0 :
q = b//a
r = b%a
m, n = old_s-s*q, old_t-t*q
b,a,old_s,old_t,s,t = a,r,s,t,m,n
return b,old_s,old_t
def get_mul(a, b) :
base = a
cur = 0
while b > 0 :
if b%2 == 1 :
if cur > 0 :
ops.append(str(cur) + ' + ' + str(base))
cur += base
ops.append(str(base) + ' + ' + str(base))
base = 2*base
b = b//2
return cur
# find two coprime
e = math.floor(math.log2(x))
for i in range(e) :
ops.append(str(x * (1 << i))+' + '+str(x * (1 << i)))
ops.append(str(x) + ' ^ ' + str((1 << e)*x))
y = ((1 << e)*x)^x
pair = ext_euc(x, -y)
p = pair[2]
q = pair[1]
while p < 0 or q < 0 :
p += y
q += x
if q % 2 == 1 :
p += y
q += x
# print(p)
# print(q)
pro1=get_mul(x,p)
pro2=get_mul(y,q)
ops.append(str(pro1) + ' ^ ' + str(pro2))
print(len(ops))
for i in ops :
print(i)
# print(p, q)
# print(y)
# print(x*p-y*q)
``` | output | 1 | 31,190 | 20 | 62,381 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a blackboard and initially only an odd number x is written on it. Your goal is to write the number 1 on the blackboard.
You may write new numbers on the blackboard with the following two operations.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their sum on the blackboard. The two numbers you have chosen remain on the blackboard.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) on the blackboard. The two numbers you have chosen remain on the blackboard.
Perform a sequence of operations such that at the end the number 1 is on the blackboard.
Input
The single line of the input contains the odd integer x (3 ≤ x ≤ 999,999).
Output
Print on the first line the number q of operations you perform. Then q lines should follow, each describing one operation.
* The "sum" operation is described by the line "a + b", where a, b must be integers already present on the blackboard.
* The "xor" operation is described by the line "a ^ b", where a, b must be integers already present on the blackboard.
The operation symbol (+ or ^) must be separated from a, b by a whitespace.
You can perform at most 100,000 operations (that is, q≤ 100,000) and all numbers written on the blackboard must be in the range [0, 5⋅10^{18}]. It can be proven that under such restrictions the required sequence of operations exists. You can output any suitable sequence of operations.
Examples
Input
3
Output
5
3 + 3
3 ^ 6
3 + 5
3 + 6
8 ^ 9
Input
123
Output
10
123 + 123
123 ^ 246
141 + 123
246 + 123
264 ^ 369
121 + 246
367 ^ 369
30 + 30
60 + 60
120 ^ 121 | instruction | 0 | 31,191 | 20 | 62,382 |
Tags: bitmasks, constructive algorithms, math, matrices, number theory
Correct Solution:
```
import sys
x = int(sys.stdin.readline())
ans = []
c = 0
while x > 1:
if bin(x).count("0") == 1:
z = x
while (2 * z) + x != (2 * z) ^ x:
ans.append(str(z) + " + " + str(z))
z = z + z
ans.append(str(x) + " + " + str(z))
z1 = x + z
ans.append(str(x) + " ^ " + str(z1))
z2 = x ^ z1
ans.append(str(x) + " + " + str(z2))
z3 = x + z2
ans.append(str(z1) + " ^ " + str(z3))
z4 = z1 ^ z3
ans.append(str(x) + " + " + str(x))
z5 = x + x
ans.append(str(z4) + " ^ " + str(z5))
z6 = z4 ^ z5
ans.append(str(x) + " ^ " + str(z6))
x = x ^ z6
else:
c = c + 1
z = x
s = bin(x)[2:]
i = 0
while bin(x + z).count("1") % bin(x).count("1") == 0:
i = i + 1
ans.append(str(z) + " + " + str(z))
z = z * 2
ans.append(str(x) + " + " + str(z))
y = x + z
while len(bin(z)) < len(bin(y)):
ans.append(str(z) + " + " + str(z))
z = z * 2
while y > x or y % 2 == 0:
if y > x:
while len(bin(z)) > len(bin(y)):
z = z // 2
ans.append(str(z) + " ^ " + str(y))
y = y ^ z
else:
while len(bin(y)) < len(bin(x)):
ans.append(str(y) + " + " + str(y))
y = y * 2
ans.append(str(x) + " ^ " + str(y))
y = x ^ y
x = y
print(len(ans))
for i in ans:
print(i)
``` | output | 1 | 31,191 | 20 | 62,383 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a blackboard and initially only an odd number x is written on it. Your goal is to write the number 1 on the blackboard.
You may write new numbers on the blackboard with the following two operations.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their sum on the blackboard. The two numbers you have chosen remain on the blackboard.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) on the blackboard. The two numbers you have chosen remain on the blackboard.
Perform a sequence of operations such that at the end the number 1 is on the blackboard.
Input
The single line of the input contains the odd integer x (3 ≤ x ≤ 999,999).
Output
Print on the first line the number q of operations you perform. Then q lines should follow, each describing one operation.
* The "sum" operation is described by the line "a + b", where a, b must be integers already present on the blackboard.
* The "xor" operation is described by the line "a ^ b", where a, b must be integers already present on the blackboard.
The operation symbol (+ or ^) must be separated from a, b by a whitespace.
You can perform at most 100,000 operations (that is, q≤ 100,000) and all numbers written on the blackboard must be in the range [0, 5⋅10^{18}]. It can be proven that under such restrictions the required sequence of operations exists. You can output any suitable sequence of operations.
Examples
Input
3
Output
5
3 + 3
3 ^ 6
3 + 5
3 + 6
8 ^ 9
Input
123
Output
10
123 + 123
123 ^ 246
141 + 123
246 + 123
264 ^ 369
121 + 246
367 ^ 369
30 + 30
60 + 60
120 ^ 121 | instruction | 0 | 31,192 | 20 | 62,384 |
Tags: bitmasks, constructive algorithms, math, matrices, number theory
Correct Solution:
```
x = int(input())
X = x
ans = []
t = x
st = set()
while x & t != 1:
#ans.append((t, '+', x))
#st.add(t + x)
t += x
# print(t)
ans.append((t, '+', x))
ans.append((t, '^', x))
ans.append((t + x, '+', t ^ x))
ans.append((t ^ x, '+', t ^ x))
ans.append((t + x + (t ^ x), '^', t + x + (t ^ x) - 2))
# st.add(t + x)
# st.add(t ^ x)
# st.add(t + x + (t ^ x))
# st.add((t ^ x) * 2)
# st.add((t + x + (t ^ x)) ^ (t + x + (t ^ x) - 2))
p = 2
while x > 1:
if x & p:
ans.append((p, '^', x))
x ^= p
ans.append((p, '+', p))
p += p
ans1 = []
q = t // X - 1
tmp = X
re = X
while q > 0:
if q & 1:
ans1.append((re, '+', tmp))
#st.add(re + tmp)
re += tmp
ans1.append((tmp, '+', tmp))
#st.add(tmp + tmp)
tmp += tmp
q >>= 1
ans = ans1 + ans
print(len(ans))
for row in ans:
print(*row)
``` | output | 1 | 31,192 | 20 | 62,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a blackboard and initially only an odd number x is written on it. Your goal is to write the number 1 on the blackboard.
You may write new numbers on the blackboard with the following two operations.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their sum on the blackboard. The two numbers you have chosen remain on the blackboard.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) on the blackboard. The two numbers you have chosen remain on the blackboard.
Perform a sequence of operations such that at the end the number 1 is on the blackboard.
Input
The single line of the input contains the odd integer x (3 ≤ x ≤ 999,999).
Output
Print on the first line the number q of operations you perform. Then q lines should follow, each describing one operation.
* The "sum" operation is described by the line "a + b", where a, b must be integers already present on the blackboard.
* The "xor" operation is described by the line "a ^ b", where a, b must be integers already present on the blackboard.
The operation symbol (+ or ^) must be separated from a, b by a whitespace.
You can perform at most 100,000 operations (that is, q≤ 100,000) and all numbers written on the blackboard must be in the range [0, 5⋅10^{18}]. It can be proven that under such restrictions the required sequence of operations exists. You can output any suitable sequence of operations.
Examples
Input
3
Output
5
3 + 3
3 ^ 6
3 + 5
3 + 6
8 ^ 9
Input
123
Output
10
123 + 123
123 ^ 246
141 + 123
246 + 123
264 ^ 369
121 + 246
367 ^ 369
30 + 30
60 + 60
120 ^ 121 | instruction | 0 | 31,193 | 20 | 62,386 |
Tags: bitmasks, constructive algorithms, math, matrices, number theory
Correct Solution:
```
import math
x = int(input())
ops = []
def ext_euc(a, b) :
s = 0
old_s = 1
t = 1
old_t = 0
while a != 0 :
q = b//a
r = b%a
m, n = old_s-s*q, old_t-t*q
b,a,old_s,old_t,s,t = a,r,s,t,m,n
return b,old_s,old_t
def get_mul(a, b) :
base = a
cur = 0
while b > 0 :
if b%2 == 1 :
if cur > 0 :
ops.append(str(cur) + ' + ' + str(base))
cur += base
ops.append(str(base) + ' + ' + str(base))
base = 2*base
b = b//2
return cur
# find two coprime
e = math.floor(math.log2(x))
for i in range(e) :
ops.append(str(x * (1 << i))+' + '+str(x * (1 << i)))
ops.append(str(x) + ' ^ ' + str((1 << e)*x))
y = ((1 << e)*x)^x
pair = ext_euc(x, -y)
p = pair[2]
q = pair[1]
while p < 0 or q < 0 :
p += y
q += x
if q % 2 == 1 :
p += y
q += x
# print(p)
# print(q)
pro1=get_mul(x,p)
pro2=get_mul(y,q)
ops.append(str(pro1) + ' ^ ' + str(pro2))
print(len(ops))
for i in ops :
print(i)
la=1+1
# print(p, q)
# print(y)
# print(x*p-y*q)
``` | output | 1 | 31,193 | 20 | 62,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a blackboard and initially only an odd number x is written on it. Your goal is to write the number 1 on the blackboard.
You may write new numbers on the blackboard with the following two operations.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their sum on the blackboard. The two numbers you have chosen remain on the blackboard.
* You may take two numbers (not necessarily distinct) already on the blackboard and write their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) on the blackboard. The two numbers you have chosen remain on the blackboard.
Perform a sequence of operations such that at the end the number 1 is on the blackboard.
Input
The single line of the input contains the odd integer x (3 ≤ x ≤ 999,999).
Output
Print on the first line the number q of operations you perform. Then q lines should follow, each describing one operation.
* The "sum" operation is described by the line "a + b", where a, b must be integers already present on the blackboard.
* The "xor" operation is described by the line "a ^ b", where a, b must be integers already present on the blackboard.
The operation symbol (+ or ^) must be separated from a, b by a whitespace.
You can perform at most 100,000 operations (that is, q≤ 100,000) and all numbers written on the blackboard must be in the range [0, 5⋅10^{18}]. It can be proven that under such restrictions the required sequence of operations exists. You can output any suitable sequence of operations.
Examples
Input
3
Output
5
3 + 3
3 ^ 6
3 + 5
3 + 6
8 ^ 9
Input
123
Output
10
123 + 123
123 ^ 246
141 + 123
246 + 123
264 ^ 369
121 + 246
367 ^ 369
30 + 30
60 + 60
120 ^ 121 | instruction | 0 | 31,194 | 20 | 62,388 |
Tags: bitmasks, constructive algorithms, math, matrices, number theory
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
print("1000")
cnt = 1000
x = int(input())
if x % 4 == 3:
print(str(x) + " + " + str(x))
print(str(2 * x) + " + " + str(x))
cnt -= 2
x *= 3
xCpy = x
bigX = x
while xCpy != 1:
print(str(bigX) + " + " + str(bigX))
cnt -= 1
xCpy //= 2
bigX *= 2
print(str(bigX) + " + " + str(x))
ans1 = bigX + x
print(str(bigX) + " ^ " + str(x))
ans2 = bigX ^ x
print(str(ans1) + " ^ " + str(ans2))
ans = ans1 ^ ans2
cnt -= 3
curX = x
while ans != 1:
curX = x
while curX != 0:
print(str(curX) + " + " + str(curX))
cnt -= 1
curX *= 2
if curX >= ans:
print(str(ans) + " ^ " + str(curX))
cnt -= 1
curX ^= ans
ans //= 2
if x >= ans:
print(str(x) + " ^ " + str(ans))
cnt -= 1
x ^= ans
while cnt > 0:
cnt -= 1
print(str(x) + " + " + str(x))
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | output | 1 | 31,194 | 20 | 62,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY invented a new message encryption method and now wants to check its performance. Checking it manually is long and tiresome, so he decided to ask the ABBYY Cup contestants for help.
A message is a sequence of n integers a1, a2, ..., an. Encryption uses a key which is a sequence of m integers b1, b2, ..., bm (m ≤ n). All numbers from the message and from the key belong to the interval from 0 to c - 1, inclusive, and all the calculations are performed modulo c.
Encryption is performed in n - m + 1 steps. On the first step we add to each number a1, a2, ..., am a corresponding number b1, b2, ..., bm. On the second step we add to each number a2, a3, ..., am + 1 (changed on the previous step) a corresponding number b1, b2, ..., bm. And so on: on step number i we add to each number ai, ai + 1, ..., ai + m - 1 a corresponding number b1, b2, ..., bm. The result of the encryption is the sequence a1, a2, ..., an after n - m + 1 steps.
Help the Beaver to write a program that will encrypt messages in the described manner.
Input
The first input line contains three integers n, m and c, separated by single spaces.
The second input line contains n integers ai (0 ≤ ai < c), separated by single spaces — the original message.
The third input line contains m integers bi (0 ≤ bi < c), separated by single spaces — the encryption key.
The input limitations for getting 30 points are:
* 1 ≤ m ≤ n ≤ 103
* 1 ≤ c ≤ 103
The input limitations for getting 100 points are:
* 1 ≤ m ≤ n ≤ 105
* 1 ≤ c ≤ 103
Output
Print n space-separated integers — the result of encrypting the original message.
Examples
Input
4 3 2
1 1 1 1
1 1 1
Output
0 1 1 0
Input
3 1 5
1 2 3
4
Output
0 1 2
Note
In the first sample the encryption is performed in two steps: after the first step a = (0, 0, 0, 1) (remember that the calculations are performed modulo 2), after the second step a = (0, 1, 1, 0), and that is the answer. | instruction | 0 | 31,248 | 20 | 62,496 |
Tags: data structures
Correct Solution:
```
n,m,c = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
pre=[0]*m
suf=[0]*(m+1)
ans=[0]*n
lp = min(m,n-m+1)
j=-2
for i in range(m):
pre[i]=(pre[i-1]+b[i])
for i in range(m-1,-1,-1):
suf[i]=suf[i+1]+b[i]
for i in range(lp):
ans[i]=(a[i]+pre[i])%c
if lp==m:
for i in range(lp , n-lp):
ans[i]=(a[i]+pre[lp-1])%c
else:
for i in range(lp , n-lp):
ans[i]=(a[i]+pre[i]-pre[i-lp])%c
for i in range(n-1,n-lp-1,-1):
ans[i]=(a[i]+suf[j])%c
j-=1
print(*ans)
``` | output | 1 | 31,248 | 20 | 62,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY invented a new message encryption method and now wants to check its performance. Checking it manually is long and tiresome, so he decided to ask the ABBYY Cup contestants for help.
A message is a sequence of n integers a1, a2, ..., an. Encryption uses a key which is a sequence of m integers b1, b2, ..., bm (m ≤ n). All numbers from the message and from the key belong to the interval from 0 to c - 1, inclusive, and all the calculations are performed modulo c.
Encryption is performed in n - m + 1 steps. On the first step we add to each number a1, a2, ..., am a corresponding number b1, b2, ..., bm. On the second step we add to each number a2, a3, ..., am + 1 (changed on the previous step) a corresponding number b1, b2, ..., bm. And so on: on step number i we add to each number ai, ai + 1, ..., ai + m - 1 a corresponding number b1, b2, ..., bm. The result of the encryption is the sequence a1, a2, ..., an after n - m + 1 steps.
Help the Beaver to write a program that will encrypt messages in the described manner.
Input
The first input line contains three integers n, m and c, separated by single spaces.
The second input line contains n integers ai (0 ≤ ai < c), separated by single spaces — the original message.
The third input line contains m integers bi (0 ≤ bi < c), separated by single spaces — the encryption key.
The input limitations for getting 30 points are:
* 1 ≤ m ≤ n ≤ 103
* 1 ≤ c ≤ 103
The input limitations for getting 100 points are:
* 1 ≤ m ≤ n ≤ 105
* 1 ≤ c ≤ 103
Output
Print n space-separated integers — the result of encrypting the original message.
Examples
Input
4 3 2
1 1 1 1
1 1 1
Output
0 1 1 0
Input
3 1 5
1 2 3
4
Output
0 1 2
Note
In the first sample the encryption is performed in two steps: after the first step a = (0, 0, 0, 1) (remember that the calculations are performed modulo 2), after the second step a = (0, 1, 1, 0), and that is the answer. | instruction | 0 | 31,249 | 20 | 62,498 |
Tags: data structures
Correct Solution:
```
len_message, len_key, mod = map(int, input().split())
message = list(map(int, input().split()))
key = list(map(int, input().split()))
sum, low, high = 0, 0, 0
result = message[:]
for i in range(len_message):
if high < len_key:
sum += key[high]
high += 1
if i + len_key > len_message:
sum -= key[low]
low += 1
result[i] = (result[i] + sum) % mod
print(' '.join(map(str, result)))
``` | output | 1 | 31,249 | 20 | 62,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY invented a new message encryption method and now wants to check its performance. Checking it manually is long and tiresome, so he decided to ask the ABBYY Cup contestants for help.
A message is a sequence of n integers a1, a2, ..., an. Encryption uses a key which is a sequence of m integers b1, b2, ..., bm (m ≤ n). All numbers from the message and from the key belong to the interval from 0 to c - 1, inclusive, and all the calculations are performed modulo c.
Encryption is performed in n - m + 1 steps. On the first step we add to each number a1, a2, ..., am a corresponding number b1, b2, ..., bm. On the second step we add to each number a2, a3, ..., am + 1 (changed on the previous step) a corresponding number b1, b2, ..., bm. And so on: on step number i we add to each number ai, ai + 1, ..., ai + m - 1 a corresponding number b1, b2, ..., bm. The result of the encryption is the sequence a1, a2, ..., an after n - m + 1 steps.
Help the Beaver to write a program that will encrypt messages in the described manner.
Input
The first input line contains three integers n, m and c, separated by single spaces.
The second input line contains n integers ai (0 ≤ ai < c), separated by single spaces — the original message.
The third input line contains m integers bi (0 ≤ bi < c), separated by single spaces — the encryption key.
The input limitations for getting 30 points are:
* 1 ≤ m ≤ n ≤ 103
* 1 ≤ c ≤ 103
The input limitations for getting 100 points are:
* 1 ≤ m ≤ n ≤ 105
* 1 ≤ c ≤ 103
Output
Print n space-separated integers — the result of encrypting the original message.
Examples
Input
4 3 2
1 1 1 1
1 1 1
Output
0 1 1 0
Input
3 1 5
1 2 3
4
Output
0 1 2
Note
In the first sample the encryption is performed in two steps: after the first step a = (0, 0, 0, 1) (remember that the calculations are performed modulo 2), after the second step a = (0, 1, 1, 0), and that is the answer. | instruction | 0 | 31,250 | 20 | 62,500 |
Tags: data structures
Correct Solution:
```
n, m, c = map(int, input().split())
N = list(map(int, input().split()))
M = list(map(int, input().split()))
SM = [0]
for v in M:
SM += [SM[-1] + v]
answer = []
for i, v in enumerate(N):
if i + len(M) < len(N):
l = 0
else:
l = len(M) - len(N) + i
if i < len(M):
r = i
else:
r = len(M) - 1
answer += [(N[i] + SM[r+1] - SM[l]) % c]
print(" ".join(map(str, answer)))
``` | output | 1 | 31,250 | 20 | 62,501 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY invented a new message encryption method and now wants to check its performance. Checking it manually is long and tiresome, so he decided to ask the ABBYY Cup contestants for help.
A message is a sequence of n integers a1, a2, ..., an. Encryption uses a key which is a sequence of m integers b1, b2, ..., bm (m ≤ n). All numbers from the message and from the key belong to the interval from 0 to c - 1, inclusive, and all the calculations are performed modulo c.
Encryption is performed in n - m + 1 steps. On the first step we add to each number a1, a2, ..., am a corresponding number b1, b2, ..., bm. On the second step we add to each number a2, a3, ..., am + 1 (changed on the previous step) a corresponding number b1, b2, ..., bm. And so on: on step number i we add to each number ai, ai + 1, ..., ai + m - 1 a corresponding number b1, b2, ..., bm. The result of the encryption is the sequence a1, a2, ..., an after n - m + 1 steps.
Help the Beaver to write a program that will encrypt messages in the described manner.
Input
The first input line contains three integers n, m and c, separated by single spaces.
The second input line contains n integers ai (0 ≤ ai < c), separated by single spaces — the original message.
The third input line contains m integers bi (0 ≤ bi < c), separated by single spaces — the encryption key.
The input limitations for getting 30 points are:
* 1 ≤ m ≤ n ≤ 103
* 1 ≤ c ≤ 103
The input limitations for getting 100 points are:
* 1 ≤ m ≤ n ≤ 105
* 1 ≤ c ≤ 103
Output
Print n space-separated integers — the result of encrypting the original message.
Examples
Input
4 3 2
1 1 1 1
1 1 1
Output
0 1 1 0
Input
3 1 5
1 2 3
4
Output
0 1 2
Note
In the first sample the encryption is performed in two steps: after the first step a = (0, 0, 0, 1) (remember that the calculations are performed modulo 2), after the second step a = (0, 1, 1, 0), and that is the answer. | instruction | 0 | 31,251 | 20 | 62,502 |
Tags: data structures
Correct Solution:
```
n, m, c = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s, k = 0, n - m
for i in range(n):
if i < m: s += b[i]
a[i] = (a[i] + s) % c
if i >= k: s -= b[i - k]
print(' '.join(str(i) for i in a))
``` | output | 1 | 31,251 | 20 | 62,503 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY invented a new message encryption method and now wants to check its performance. Checking it manually is long and tiresome, so he decided to ask the ABBYY Cup contestants for help.
A message is a sequence of n integers a1, a2, ..., an. Encryption uses a key which is a sequence of m integers b1, b2, ..., bm (m ≤ n). All numbers from the message and from the key belong to the interval from 0 to c - 1, inclusive, and all the calculations are performed modulo c.
Encryption is performed in n - m + 1 steps. On the first step we add to each number a1, a2, ..., am a corresponding number b1, b2, ..., bm. On the second step we add to each number a2, a3, ..., am + 1 (changed on the previous step) a corresponding number b1, b2, ..., bm. And so on: on step number i we add to each number ai, ai + 1, ..., ai + m - 1 a corresponding number b1, b2, ..., bm. The result of the encryption is the sequence a1, a2, ..., an after n - m + 1 steps.
Help the Beaver to write a program that will encrypt messages in the described manner.
Input
The first input line contains three integers n, m and c, separated by single spaces.
The second input line contains n integers ai (0 ≤ ai < c), separated by single spaces — the original message.
The third input line contains m integers bi (0 ≤ bi < c), separated by single spaces — the encryption key.
The input limitations for getting 30 points are:
* 1 ≤ m ≤ n ≤ 103
* 1 ≤ c ≤ 103
The input limitations for getting 100 points are:
* 1 ≤ m ≤ n ≤ 105
* 1 ≤ c ≤ 103
Output
Print n space-separated integers — the result of encrypting the original message.
Examples
Input
4 3 2
1 1 1 1
1 1 1
Output
0 1 1 0
Input
3 1 5
1 2 3
4
Output
0 1 2
Note
In the first sample the encryption is performed in two steps: after the first step a = (0, 0, 0, 1) (remember that the calculations are performed modulo 2), after the second step a = (0, 1, 1, 0), and that is the answer. | instruction | 0 | 31,252 | 20 | 62,504 |
Tags: data structures
Correct Solution:
```
n,m,c=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
sum=0
for i in range(n):
if i<m:
sum=(sum+b[i])%c
if i>=n-m+1:
sum=(c+sum-b[i-(n-m+1)])%c
a[i]=(a[i]+sum)%c
print(' '.join(map(str,a)))
``` | output | 1 | 31,252 | 20 | 62,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY invented a new message encryption method and now wants to check its performance. Checking it manually is long and tiresome, so he decided to ask the ABBYY Cup contestants for help.
A message is a sequence of n integers a1, a2, ..., an. Encryption uses a key which is a sequence of m integers b1, b2, ..., bm (m ≤ n). All numbers from the message and from the key belong to the interval from 0 to c - 1, inclusive, and all the calculations are performed modulo c.
Encryption is performed in n - m + 1 steps. On the first step we add to each number a1, a2, ..., am a corresponding number b1, b2, ..., bm. On the second step we add to each number a2, a3, ..., am + 1 (changed on the previous step) a corresponding number b1, b2, ..., bm. And so on: on step number i we add to each number ai, ai + 1, ..., ai + m - 1 a corresponding number b1, b2, ..., bm. The result of the encryption is the sequence a1, a2, ..., an after n - m + 1 steps.
Help the Beaver to write a program that will encrypt messages in the described manner.
Input
The first input line contains three integers n, m and c, separated by single spaces.
The second input line contains n integers ai (0 ≤ ai < c), separated by single spaces — the original message.
The third input line contains m integers bi (0 ≤ bi < c), separated by single spaces — the encryption key.
The input limitations for getting 30 points are:
* 1 ≤ m ≤ n ≤ 103
* 1 ≤ c ≤ 103
The input limitations for getting 100 points are:
* 1 ≤ m ≤ n ≤ 105
* 1 ≤ c ≤ 103
Output
Print n space-separated integers — the result of encrypting the original message.
Examples
Input
4 3 2
1 1 1 1
1 1 1
Output
0 1 1 0
Input
3 1 5
1 2 3
4
Output
0 1 2
Note
In the first sample the encryption is performed in two steps: after the first step a = (0, 0, 0, 1) (remember that the calculations are performed modulo 2), after the second step a = (0, 1, 1, 0), and that is the answer. | instruction | 0 | 31,253 | 20 | 62,506 |
Tags: data structures
Correct Solution:
```
n,m,c = map(int,input().split())
a = list(input().split())
b = list(input().split())
sum = 0
for i in range(n):
if i<m:
sum = sum + int(b[i])
sum = sum%c
if i >= n - m + 1:
sum = c - int(b[i-n+m-1]) + sum
sum = sum%c
print((int(a[i])+sum)%c,end = ' ')
``` | output | 1 | 31,253 | 20 | 62,507 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Smart Beaver from ABBYY invented a new message encryption method and now wants to check its performance. Checking it manually is long and tiresome, so he decided to ask the ABBYY Cup contestants for help.
A message is a sequence of n integers a1, a2, ..., an. Encryption uses a key which is a sequence of m integers b1, b2, ..., bm (m ≤ n). All numbers from the message and from the key belong to the interval from 0 to c - 1, inclusive, and all the calculations are performed modulo c.
Encryption is performed in n - m + 1 steps. On the first step we add to each number a1, a2, ..., am a corresponding number b1, b2, ..., bm. On the second step we add to each number a2, a3, ..., am + 1 (changed on the previous step) a corresponding number b1, b2, ..., bm. And so on: on step number i we add to each number ai, ai + 1, ..., ai + m - 1 a corresponding number b1, b2, ..., bm. The result of the encryption is the sequence a1, a2, ..., an after n - m + 1 steps.
Help the Beaver to write a program that will encrypt messages in the described manner.
Input
The first input line contains three integers n, m and c, separated by single spaces.
The second input line contains n integers ai (0 ≤ ai < c), separated by single spaces — the original message.
The third input line contains m integers bi (0 ≤ bi < c), separated by single spaces — the encryption key.
The input limitations for getting 30 points are:
* 1 ≤ m ≤ n ≤ 103
* 1 ≤ c ≤ 103
The input limitations for getting 100 points are:
* 1 ≤ m ≤ n ≤ 105
* 1 ≤ c ≤ 103
Output
Print n space-separated integers — the result of encrypting the original message.
Examples
Input
4 3 2
1 1 1 1
1 1 1
Output
0 1 1 0
Input
3 1 5
1 2 3
4
Output
0 1 2
Note
In the first sample the encryption is performed in two steps: after the first step a = (0, 0, 0, 1) (remember that the calculations are performed modulo 2), after the second step a = (0, 1, 1, 0), and that is the answer. | instruction | 0 | 31,254 | 20 | 62,508 |
Tags: data structures
Correct Solution:
```
from collections import defaultdict
for _ in range(1):
n,m,c=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
cur_sum=0
ans=[0]*n
for i,j in enumerate(a):
if i<m:
# print(':',i)
cur_sum+=b[i]
cur_sum%=c
if n-i<m:
# print(i)
cur_sum-=b[m-1-(n-i)]
cur_sum%=c
ans[i]=(j+cur_sum)%c
print(' '.join([str(i) for i in ans]) )
``` | output | 1 | 31,254 | 20 | 62,509 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1. | instruction | 0 | 31,314 | 20 | 62,628 |
Tags: greedy, math
Correct Solution:
```
from sys import stdin,stdout
st=lambda:list(stdin.readline().strip())
li=lambda:list(map(int,stdin.readline().split()))
mp=lambda:map(int,stdin.readline().split())
inp=lambda:int(stdin.readline())
pr=lambda n: stdout.write(str(n)+"\n")
from math import floor
mod=1000000007
INF= float('inf')
def solve():
n=inp()
l=li()
i=0
l.sort()
while i<n:
f=0
for j in range(n):
if i==j:
continue
if l[j]>l[i]:
l[j]-= l[i]*((l[j]-1)//l[i])
f=1
l.sort()
if f==0:
i+=1
pr(sum(l))
for _ in range(1):
solve()
``` | output | 1 | 31,314 | 20 | 62,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is written on a blackboard. Soon Sasha will come to the blackboard and start the following actions: let x and y be two adjacent numbers (x before y), then he can remove them and write x + 2y instead of them. He will perform these operations until one number is left. Sasha likes big numbers and will get the biggest possible number.
Nikita wants to get to the blackboard before Sasha and erase some of the numbers. He has q options, in the option i he erases all numbers to the left of the li-th number and all numbers to the right of ri-th number, i. e. all numbers between the li-th and the ri-th, inclusive, remain on the blackboard. For each of the options he wants to know how big Sasha's final number is going to be. This number can be very big, so output it modulo 109 + 7.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 105) — the number of integers on the blackboard and the number of Nikita's options.
The next line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the sequence on the blackboard.
Each of the next q lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n), describing Nikita's options.
Output
For each option output Sasha's result modulo 109 + 7.
Examples
Input
3 3
1 2 3
1 3
1 2
2 3
Output
17
5
8
Input
3 1
1 2 -3
1 3
Output
1000000006
Input
4 2
1 1 1 -1
1 4
3 4
Output
5
1000000006
Note
In the second sample Nikita doesn't erase anything. Sasha first erases the numbers 1 and 2 and writes 5. Then he erases 5 and -3 and gets -1. -1 modulo 109 + 7 is 109 + 6.
Submitted Solution:
```
#x+2y on string find max value
n, q = map(int, input().split(" "))
boardm = [int(i) for i in input().split(" ")]
memo = [[0 for _ in range(n)] for i in range(n)]
# x,y,answer
sub = 10**9 + 7
for cases in range(q):
li, lj = map(int, input().split(" "))
li -= 1
lj -= 1
board = boardm[li:lj+1]
dp = [0,0,0]
dp[0] = board[0]
dp[1] = board[1]
dp[2] = dp[0]+ (2*dp[1])
for _ in range(2,len(board)):
if board[_] <0:
dp[2] = dp[2] + 2*board[_]
else:
dp[2] = dp[0] + 2*(dp[1] + 2*board[_])
dp[0], dp[1] = dp[1], board[_]
print(dp[2]%sub)
``` | instruction | 0 | 31,496 | 20 | 62,992 |
No | output | 1 | 31,496 | 20 | 62,993 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is written on a blackboard. Soon Sasha will come to the blackboard and start the following actions: let x and y be two adjacent numbers (x before y), then he can remove them and write x + 2y instead of them. He will perform these operations until one number is left. Sasha likes big numbers and will get the biggest possible number.
Nikita wants to get to the blackboard before Sasha and erase some of the numbers. He has q options, in the option i he erases all numbers to the left of the li-th number and all numbers to the right of ri-th number, i. e. all numbers between the li-th and the ri-th, inclusive, remain on the blackboard. For each of the options he wants to know how big Sasha's final number is going to be. This number can be very big, so output it modulo 109 + 7.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 105) — the number of integers on the blackboard and the number of Nikita's options.
The next line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the sequence on the blackboard.
Each of the next q lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n), describing Nikita's options.
Output
For each option output Sasha's result modulo 109 + 7.
Examples
Input
3 3
1 2 3
1 3
1 2
2 3
Output
17
5
8
Input
3 1
1 2 -3
1 3
Output
1000000006
Input
4 2
1 1 1 -1
1 4
3 4
Output
5
1000000006
Note
In the second sample Nikita doesn't erase anything. Sasha first erases the numbers 1 and 2 and writes 5. Then he erases 5 and -3 and gets -1. -1 modulo 109 + 7 is 109 + 6.
Submitted Solution:
```
def find_max_ind(arr):
max_el, max_ind = arr[0], 0
for i in range(1, len(arr)):
el = arr[i]
if el >= max_el:
max_el = el
max_ind = i
return max_ind
def calc_max_prod(arr, l):
if l == 1:
return arr[0]
if l == 2:
a = arr[0] + arr[1] * 2
return a
max_ind = find_max_ind(arr)
if max_ind == 0:
a = calc_max_prod([calc_max_prod(arr[:2], 2)] + arr[2:], l - 1)
return a
before = arr[:max_ind - 1]
calc = arr[max_ind - 1:max_ind + 1]
after = arr[max_ind + 1:]
a = calc_max_prod(before + [calc_max_prod(calc, 2)] + after, l - 1)
return a
'''
def calc_max_prod(arr, l):
if l == 1:
return arr[0]
if l == 2:
return arr[0] + arr[1] * 2
max_prod = -float("inf")
for i in range(l - 1):
prod = calc_max_prod(arr[:i] + [calc_max_prod(arr[i:i + 2], 2)] + arr[i + 2:], l - 1)
max_prod = max(prod, max_prod)
return max_prod'''
n, q = list(map(int, input().split()))
nums = list(map(int, input().split()))
rem = [list(map(int, input().split())) for i in range(q)]
for i in range(q):
li, ri = rem[i]
print(calc_max_prod(nums[li - 1:ri], ri - li + 1) % (10 ** 9 + 7))
``` | instruction | 0 | 31,497 | 20 | 62,994 |
No | output | 1 | 31,497 | 20 | 62,995 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is written on a blackboard. Soon Sasha will come to the blackboard and start the following actions: let x and y be two adjacent numbers (x before y), then he can remove them and write x + 2y instead of them. He will perform these operations until one number is left. Sasha likes big numbers and will get the biggest possible number.
Nikita wants to get to the blackboard before Sasha and erase some of the numbers. He has q options, in the option i he erases all numbers to the left of the li-th number and all numbers to the right of ri-th number, i. e. all numbers between the li-th and the ri-th, inclusive, remain on the blackboard. For each of the options he wants to know how big Sasha's final number is going to be. This number can be very big, so output it modulo 109 + 7.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 105) — the number of integers on the blackboard and the number of Nikita's options.
The next line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the sequence on the blackboard.
Each of the next q lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n), describing Nikita's options.
Output
For each option output Sasha's result modulo 109 + 7.
Examples
Input
3 3
1 2 3
1 3
1 2
2 3
Output
17
5
8
Input
3 1
1 2 -3
1 3
Output
1000000006
Input
4 2
1 1 1 -1
1 4
3 4
Output
5
1000000006
Note
In the second sample Nikita doesn't erase anything. Sasha first erases the numbers 1 and 2 and writes 5. Then he erases 5 and -3 and gets -1. -1 modulo 109 + 7 is 109 + 6.
Submitted Solution:
```
from random import randint
def find_max_ind(arr):
max_el, max_ind = arr[0], 0
for i in range(1, len(arr)):
el = arr[i]
if el >= max_el:
max_el = el
max_ind = i
return max_ind
def calc_max_prod(arr, l):
if l == 1:
return arr[0]
if l == 2:
a = arr[0] + arr[1] * 2
return a
max_ind = find_max_ind(arr)
if max_ind == 0:
a = calc_max_prod([calc_max_prod(arr[:2], 2)] + arr[2:], l - 1)
return a
before = arr[:max_ind - 1]
calc = arr[max_ind - 1:max_ind + 1]
after = arr[max_ind + 1:]
a = calc_max_prod(before + [calc_max_prod(calc, 2)] + after, l - 1)
return a % (10 ** 9 + 7)
def calc_max_prod1(arr, l):
if l == 1:
return arr[0]
if l == 2:
return arr[0] + arr[1] * 2
max_prod = -float("inf")
for i in range(l - 1):
prod = calc_max_prod(arr[:i] + [calc_max_prod(arr[i:i + 2], 2)] + arr[i + 2:], l - 1)
max_prod = max(prod, max_prod)
return max_prod % (10 ** 9 + 7)
def gen_test():
n, q = randint(1, 5), randint(1, 10)
arr1 = []
for i in range(n):
arr1.append(randint(1, 100))
lri = []
for i in range(q):
li = randint(1, n - 2)
ri = randint(li + 1, n)
lri.append([li, ri])
test = [[n, q], arr1, lri]
return test
def test(number_tests):
for i in range(number_tests):
test = gen_test()
n, q = test[0]
arr = test[1]
lri = test[2]
for l in lri:
li, ri = l
res1 = calc_max_prod(arr[li - 1:ri], ri - li + 1)
res2 = calc_max_prod1(arr[li - 1:ri], ri - li + 1)
if res1 != res2:
print("Incorretc answer!!!")
print("Test:")
print(n, q)
print(arr)
print(li, ri)
print("First answer: ")
print(res1)
print("Correct answer: ")
print(res2)
def targ():
n, q = list(map(int, input().split()))
nums = list(map(int, input().split()))
rem = [list(map(int, input().split())) for i in range(q)]
for i in range(q):
li, ri = rem[i]
print(calc_max_prod1(nums[li - 1:ri], ri - li + 1))
DEBUG = False
NUMBER_TESTS = 10
if DEBUG:
test(NUMBER_TESTS)
else:
targ()
``` | instruction | 0 | 31,498 | 20 | 62,996 |
No | output | 1 | 31,498 | 20 | 62,997 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is written on a blackboard. Soon Sasha will come to the blackboard and start the following actions: let x and y be two adjacent numbers (x before y), then he can remove them and write x + 2y instead of them. He will perform these operations until one number is left. Sasha likes big numbers and will get the biggest possible number.
Nikita wants to get to the blackboard before Sasha and erase some of the numbers. He has q options, in the option i he erases all numbers to the left of the li-th number and all numbers to the right of ri-th number, i. e. all numbers between the li-th and the ri-th, inclusive, remain on the blackboard. For each of the options he wants to know how big Sasha's final number is going to be. This number can be very big, so output it modulo 109 + 7.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 105) — the number of integers on the blackboard and the number of Nikita's options.
The next line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the sequence on the blackboard.
Each of the next q lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n), describing Nikita's options.
Output
For each option output Sasha's result modulo 109 + 7.
Examples
Input
3 3
1 2 3
1 3
1 2
2 3
Output
17
5
8
Input
3 1
1 2 -3
1 3
Output
1000000006
Input
4 2
1 1 1 -1
1 4
3 4
Output
5
1000000006
Note
In the second sample Nikita doesn't erase anything. Sasha first erases the numbers 1 and 2 and writes 5. Then he erases 5 and -3 and gets -1. -1 modulo 109 + 7 is 109 + 6.
Submitted Solution:
```
def find_ind(arr):
max_ind, max_el = 0, arr[0]
for i in range(1, len(arr)):
el = arr[i]
if el > max_el:
max_el = el
max_ind = i
return max_ind
def calc_max(arr):
l = len(arr)
if l == 0:
return 0
if l == 1:
return arr[0]
if l == 2:
return arr[0] + arr[1] * 2
i = find_ind(arr)
return calc_max(arr[:i - 1] + [arr[i - 1] + 2 * (arr[i] + 2 * calc_max(arr[i + 1:]))])
n, q = list(map(int, input().split()))
arr = list(map(int, input().split()))
rem = [list(map(int, input().split())) for i in range(q)]
for d in rem:
li, ri = d
print(calc_max(arr[li - 1:ri]))
``` | instruction | 0 | 31,499 | 20 | 62,998 |
No | output | 1 | 31,499 | 20 | 62,999 |
Provide a correct Python 3 solution for this coding contest problem.
One very experienced problem writer decided to prepare a problem for April Fools Day contest. The task was very simple - given an arithmetic expression, return the result of evaluating this expression. However, looks like there is a bug in the reference solution...
Input
The only line of input data contains the arithmetic expression. The expression will contain between 2 and 10 operands, separated with arithmetic signs plus and/or minus. Each operand will be an integer between 0 and 255, inclusive.
Output
Reproduce the output of the reference solution, including the bug.
Examples
Input
8-7+6-5+4-3+2-1-0
Output
4
Input
2+2
Output
-46
Input
112-37
Output
375 | instruction | 0 | 31,520 | 20 | 63,040 |
"Correct Solution:
```
s = input().strip() + '+'
ans = 0
curr = 0
sign = 1
for c in s:
if c in '-+':
ans += sign*curr
curr = 0
if c == '-':
sign = -1
elif c == '+':
sign = 1
curr = curr*10 + (ord(c) - ord('0'))
print(ans)
``` | output | 1 | 31,520 | 20 | 63,041 |
Provide a correct Python 3 solution for this coding contest problem.
One very experienced problem writer decided to prepare a problem for April Fools Day contest. The task was very simple - given an arithmetic expression, return the result of evaluating this expression. However, looks like there is a bug in the reference solution...
Input
The only line of input data contains the arithmetic expression. The expression will contain between 2 and 10 operands, separated with arithmetic signs plus and/or minus. Each operand will be an integer between 0 and 255, inclusive.
Output
Reproduce the output of the reference solution, including the bug.
Examples
Input
8-7+6-5+4-3+2-1-0
Output
4
Input
2+2
Output
-46
Input
112-37
Output
375 | instruction | 0 | 31,522 | 20 | 63,044 |
"Correct Solution:
```
e = input()
nr = 0
nrs = []
signs = []
for c in e:
if not c.isdigit():
nrs += [nr]
signs += [c]
nr = 0
nr = nr*10 + ord(c) - ord('0')
nrs += [nr]
res = nrs[0]
for i in range(len(signs)):
if signs[i] == '+':
res += nrs[i+1]
else:
res -= nrs[i+1]
print(res)
``` | output | 1 | 31,522 | 20 | 63,045 |
Provide a correct Python 3 solution for this coding contest problem.
Palindrome
Problem Statement
Find the number of palindromes closest to the integer n.
Note that the non-negative integer x is the number of palindromes, which means that the character string in which x is expressed in decimal notation and the character string in which it is inverted are equal.
For example, 0,7,33,10301 is the number of palindromes, and 32,90,1010 is not the number of palindromes.
Constraints
* 1 ≤ n ≤ 10 ^ 4
Input
Input follows the following format. All given numbers are integers.
n
Output
Output the number of palindromes closest to n.
If there are multiple such numbers, output the smallest one.
Examples
Input
13
Output
11
Input
7447
Output
7447
Input
106
Output
101 | instruction | 0 | 31,746 | 20 | 63,492 |
"Correct Solution:
```
l1 = [i for i in range(10)]
l2 = [int(str(c) + str(c)) for c in range(1, 10)]
l3 = [int(str(c1) + str(c2) + str(c1)) for c1 in range(1, 10) for c2 in range(10)]
l4 = [int(str(c1) + str(c2) + str(c2) + str(c1)) for c1 in range(1, 10) for c2 in range(10)]
l5 = [10001]
lst = l1 + l2 + l3 + l4 + l5
n = int(input())
dist = 10 ** 6
ans = -1
for num in lst:
if abs(num - n) < dist:
dist = abs(num - n)
ans = num
elif abs(num - n) == dist and num < ans:
ans = num
print(ans)
``` | output | 1 | 31,746 | 20 | 63,493 |
Provide a correct Python 3 solution for this coding contest problem.
Palindrome
Problem Statement
Find the number of palindromes closest to the integer n.
Note that the non-negative integer x is the number of palindromes, which means that the character string in which x is expressed in decimal notation and the character string in which it is inverted are equal.
For example, 0,7,33,10301 is the number of palindromes, and 32,90,1010 is not the number of palindromes.
Constraints
* 1 ≤ n ≤ 10 ^ 4
Input
Input follows the following format. All given numbers are integers.
n
Output
Output the number of palindromes closest to n.
If there are multiple such numbers, output the smallest one.
Examples
Input
13
Output
11
Input
7447
Output
7447
Input
106
Output
101 | instruction | 0 | 31,747 | 20 | 63,494 |
"Correct Solution:
```
n = int(input())
s = list(range(10))
for i in range(1, 100):
t = str(i)
s.append(t+t[::-1])
for j in range(10):
s.append(t+str(j)+t[::-1])
s = list(map(int, s))
s.sort()
if n in s:
print(n)
else:
if n < s[0]:
print(s[0])
elif n > s[-1]:
print(s[-1])
else:
res = 0
diff = 1e9
for d in s:
if diff > abs(d-n):
diff = abs(d-n)
res = d
print(res)
``` | output | 1 | 31,747 | 20 | 63,495 |
Provide a correct Python 3 solution for this coding contest problem.
Palindrome
Problem Statement
Find the number of palindromes closest to the integer n.
Note that the non-negative integer x is the number of palindromes, which means that the character string in which x is expressed in decimal notation and the character string in which it is inverted are equal.
For example, 0,7,33,10301 is the number of palindromes, and 32,90,1010 is not the number of palindromes.
Constraints
* 1 ≤ n ≤ 10 ^ 4
Input
Input follows the following format. All given numbers are integers.
n
Output
Output the number of palindromes closest to n.
If there are multiple such numbers, output the smallest one.
Examples
Input
13
Output
11
Input
7447
Output
7447
Input
106
Output
101 | instruction | 0 | 31,748 | 20 | 63,496 |
"Correct Solution:
```
def f(n):
n=str(n)
if n==n[::-1]:return 1
a=b=int(input())
while 1:
if f(b): print(b);break
a-=1
if f(a):print(a);break
b+=1
``` | output | 1 | 31,748 | 20 | 63,497 |
Provide a correct Python 3 solution for this coding contest problem.
Palindrome
Problem Statement
Find the number of palindromes closest to the integer n.
Note that the non-negative integer x is the number of palindromes, which means that the character string in which x is expressed in decimal notation and the character string in which it is inverted are equal.
For example, 0,7,33,10301 is the number of palindromes, and 32,90,1010 is not the number of palindromes.
Constraints
* 1 ≤ n ≤ 10 ^ 4
Input
Input follows the following format. All given numbers are integers.
n
Output
Output the number of palindromes closest to n.
If there are multiple such numbers, output the smallest one.
Examples
Input
13
Output
11
Input
7447
Output
7447
Input
106
Output
101 | instruction | 0 | 31,749 | 20 | 63,498 |
"Correct Solution:
```
import bisect
rev=[]
for i in range(1,10002):
if str(i)==str(i)[::-1]:rev.append(i)
n=int(input())
ind= bisect.bisect_left(rev,n)
if abs(n-rev[ind-1])<=abs(n-rev[ind]):
print(rev[ind-1])
else:
print(rev[ind])
``` | output | 1 | 31,749 | 20 | 63,499 |
Provide a correct Python 3 solution for this coding contest problem.
Palindrome
Problem Statement
Find the number of palindromes closest to the integer n.
Note that the non-negative integer x is the number of palindromes, which means that the character string in which x is expressed in decimal notation and the character string in which it is inverted are equal.
For example, 0,7,33,10301 is the number of palindromes, and 32,90,1010 is not the number of palindromes.
Constraints
* 1 ≤ n ≤ 10 ^ 4
Input
Input follows the following format. All given numbers are integers.
n
Output
Output the number of palindromes closest to n.
If there are multiple such numbers, output the smallest one.
Examples
Input
13
Output
11
Input
7447
Output
7447
Input
106
Output
101 | instruction | 0 | 31,750 | 20 | 63,500 |
"Correct Solution:
```
def check(n):
n = str(n)
if n == n[::-1]:
return True
else:
return False
n = int(input())
if check(n):
print(n)
else:
base = n
while 1:
n -= 1
if check(n):
ans = n
break
diff = base - n
n = base
for i in range(base, base + diff):
if check(i):
print(i)
break
else:
print(ans)
``` | output | 1 | 31,750 | 20 | 63,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Palindrome
Problem Statement
Find the number of palindromes closest to the integer n.
Note that the non-negative integer x is the number of palindromes, which means that the character string in which x is expressed in decimal notation and the character string in which it is inverted are equal.
For example, 0,7,33,10301 is the number of palindromes, and 32,90,1010 is not the number of palindromes.
Constraints
* 1 ≤ n ≤ 10 ^ 4
Input
Input follows the following format. All given numbers are integers.
n
Output
Output the number of palindromes closest to n.
If there are multiple such numbers, output the smallest one.
Examples
Input
13
Output
11
Input
7447
Output
7447
Input
106
Output
101
Submitted Solution:
```
def check(n):
n = str(n)
if n == n[::-1]:
return True
else:
return False
n = int(input())
if check(n):
print(n)
else:
base = n
while 1:
n -= 1
if check(n):
ans = n
break
diff = base - n
n = base
for i in range(n, base):
if check(i):
print(i)
break
else:
print(ans)
``` | instruction | 0 | 31,751 | 20 | 63,502 |
No | output | 1 | 31,751 | 20 | 63,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It can be shown that any positive integer x can be uniquely represented as x = 1 + 2 + 4 + ... + 2k - 1 + r, where k and r are integers, k ≥ 0, 0 < r ≤ 2k. Let's call that representation prairie partition of x.
For example, the prairie partitions of 12, 17, 7 and 1 are:
12 = 1 + 2 + 4 + 5,
17 = 1 + 2 + 4 + 8 + 2,
7 = 1 + 2 + 4,
1 = 1.
Alice took a sequence of positive integers (possibly with repeating elements), replaced every element with the sequence of summands in its prairie partition, arranged the resulting numbers in non-decreasing order and gave them to Borys. Now Borys wonders how many elements Alice's original sequence could contain. Find all possible options!
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of numbers given from Alice to Borys.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1012; a1 ≤ a2 ≤ ... ≤ an) — the numbers given from Alice to Borys.
Output
Output, in increasing order, all possible values of m such that there exists a sequence of positive integers of length m such that if you replace every element with the summands in its prairie partition and arrange the resulting numbers in non-decreasing order, you will get the sequence given in the input.
If there are no such values of m, output a single integer -1.
Examples
Input
8
1 1 2 2 3 4 5 8
Output
2
Input
6
1 1 1 2 2 2
Output
2 3
Input
5
1 2 4 4 4
Output
-1
Note
In the first example, Alice could get the input sequence from [6, 20] as the original sequence.
In the second example, Alice's original sequence could be either [4, 5] or [3, 3, 3].
Submitted Solution:
```
from collections import Counter
from math import log2
powers = [2 ** p for p in range(64)]
def can():
near = Counter()
for num in set(nums):
p = int(log2(num))
near[p] += nums[num]
seq_cp = seqs - Counter()
for num in set(near):
cnt = near[num]
while cnt != 0 and num < 64:
dif = min(cnt, seq_cp[powers[num]])
cnt -= dif
seq_cp[powers[num]] -= dif
num += 1
if cnt > 0:
return False
return True
n = int(input())
seq = list(map(int, input().split()))
cnt = Counter(seq)
nums = Counter(seq)
seqs = Counter()
cur_cnt = cnt[1]
cur_pow = 1
while cur_cnt != 0:
nums[cur_pow] -= cur_cnt
cur_pow *= 2
if cur_cnt > cnt[cur_pow]:
seqs[cur_pow // 2] = cur_cnt - cnt[cur_pow]
cur_cnt = cnt[cur_pow]
for num in set(nums):
addition = nums[num]
nums[num] = 0
nums[2 ** int(log2(num))] += addition
# remove elements with zero count
nums -= Counter()
seqs -= Counter()
print(nums, seqs)
cur_len = sum(seqs[num] for num in set(seqs))
res = []
cur_pow = 1
while can():
res.append(cur_len)
while seqs[cur_pow] == 0 and cur_pow <= 2 ** 63:
cur_pow *= 2
if cur_pow > 2 ** 63:
break
other_pow = 1
while other_pow <= cur_pow:
nums[other_pow] += 1
other_pow *= 2
seqs[cur_pow] -= 1
cur_len -= 1
print(-1 if len(res) == 0 else ' '.join(map(str, reversed(res))))
``` | instruction | 0 | 32,139 | 20 | 64,278 |
No | output | 1 | 32,139 | 20 | 64,279 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It can be shown that any positive integer x can be uniquely represented as x = 1 + 2 + 4 + ... + 2k - 1 + r, where k and r are integers, k ≥ 0, 0 < r ≤ 2k. Let's call that representation prairie partition of x.
For example, the prairie partitions of 12, 17, 7 and 1 are:
12 = 1 + 2 + 4 + 5,
17 = 1 + 2 + 4 + 8 + 2,
7 = 1 + 2 + 4,
1 = 1.
Alice took a sequence of positive integers (possibly with repeating elements), replaced every element with the sequence of summands in its prairie partition, arranged the resulting numbers in non-decreasing order and gave them to Borys. Now Borys wonders how many elements Alice's original sequence could contain. Find all possible options!
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of numbers given from Alice to Borys.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1012; a1 ≤ a2 ≤ ... ≤ an) — the numbers given from Alice to Borys.
Output
Output, in increasing order, all possible values of m such that there exists a sequence of positive integers of length m such that if you replace every element with the summands in its prairie partition and arrange the resulting numbers in non-decreasing order, you will get the sequence given in the input.
If there are no such values of m, output a single integer -1.
Examples
Input
8
1 1 2 2 3 4 5 8
Output
2
Input
6
1 1 1 2 2 2
Output
2 3
Input
5
1 2 4 4 4
Output
-1
Note
In the first example, Alice could get the input sequence from [6, 20] as the original sequence.
In the second example, Alice's original sequence could be either [4, 5] or [3, 3, 3].
Submitted Solution:
```
from collections import Counter
from math import log2, ceil
MAX = ceil(log2(10 ** 12))
def can():
seqs_cp = Counter(seqs)
for num in set(nums):
cnt = nums[num]
while cnt != 0 and num <= MAX:
dif = min(cnt, seqs_cp[num])
cnt -= dif
seqs_cp[num] -= dif
num *= 2
if cnt > 0:
return False
return True
n = int(input())
seq = list(map(int, input().split()))
cnt = Counter(seq)
nums = Counter(seq)
seqs = Counter()
cur_cnt = cnt[1]
cur_pow = 1
while cur_cnt != 0:
nums[cur_pow] -= cur_cnt
cur_pow *= 2
if cur_cnt > cnt[cur_pow]:
seqs[cur_pow // 2] = cur_cnt - cnt[cur_pow]
cur_cnt = cnt[cur_pow]
for num in set(nums):
addition = nums[num]
nums[num] = 0
nums[2 ** int(log2(num))] += addition
# remove elements with zero count
nums -= Counter()
seqs -= Counter()
cur_len = sum(seqs[num] for num in set(seqs))
res = []
cur_pow = 1
while can():
res.append(cur_len)
while seqs[cur_pow] == 0 and cur_pow <= MAX:
cur_pow *= 2
if cur_pow > MAX:
break
other_pow = 1
while other_pow <= cur_pow:
nums[other_pow] += 1
other_pow *= 2
seqs[cur_pow] -= 1
cur_len -= 1
print(-1 if len(res) == 0 else ' '.join(map(str, reversed(res))))
``` | instruction | 0 | 32,140 | 20 | 64,280 |
No | output | 1 | 32,140 | 20 | 64,281 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It can be shown that any positive integer x can be uniquely represented as x = 1 + 2 + 4 + ... + 2k - 1 + r, where k and r are integers, k ≥ 0, 0 < r ≤ 2k. Let's call that representation prairie partition of x.
For example, the prairie partitions of 12, 17, 7 and 1 are:
12 = 1 + 2 + 4 + 5,
17 = 1 + 2 + 4 + 8 + 2,
7 = 1 + 2 + 4,
1 = 1.
Alice took a sequence of positive integers (possibly with repeating elements), replaced every element with the sequence of summands in its prairie partition, arranged the resulting numbers in non-decreasing order and gave them to Borys. Now Borys wonders how many elements Alice's original sequence could contain. Find all possible options!
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of numbers given from Alice to Borys.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1012; a1 ≤ a2 ≤ ... ≤ an) — the numbers given from Alice to Borys.
Output
Output, in increasing order, all possible values of m such that there exists a sequence of positive integers of length m such that if you replace every element with the summands in its prairie partition and arrange the resulting numbers in non-decreasing order, you will get the sequence given in the input.
If there are no such values of m, output a single integer -1.
Examples
Input
8
1 1 2 2 3 4 5 8
Output
2
Input
6
1 1 1 2 2 2
Output
2 3
Input
5
1 2 4 4 4
Output
-1
Note
In the first example, Alice could get the input sequence from [6, 20] as the original sequence.
In the second example, Alice's original sequence could be either [4, 5] or [3, 3, 3].
Submitted Solution:
```
from collections import Counter
from math import log2, ceil
MAX = ceil(log2(10 ** 12))
def can():
seqs_cp = Counter(seqs)
for num in set(nums):
cnt = nums[num]
while cnt != 0 and num < MAX:
dif = min(cnt, seqs_cp[num])
cnt -= dif
seqs_cp[num] -= dif
num *= 2
if cnt > 0:
return False
return True
n = int(input())
seq = list(map(int, input().split()))
cnt = Counter(seq)
nums = Counter(seq)
seqs = Counter()
cur_cnt = cnt[1]
cur_pow = 1
while cur_cnt != 0:
nums[cur_pow] -= cur_cnt
cur_pow *= 2
if cur_cnt > cnt[cur_pow]:
seqs[cur_pow // 2] = cur_cnt - cnt[cur_pow]
cur_cnt = cnt[cur_pow]
for num in set(nums):
addition = nums[num]
nums[num] = 0
nums[2 ** int(log2(num))] += addition
# remove elements with zero count
nums -= Counter()
seqs -= Counter()
cur_len = sum(seqs[num] for num in set(seqs))
res = []
cur_pow = 1
while can():
res.append(cur_len)
while seqs[cur_pow] == 0 and cur_pow <= MAX:
cur_pow *= 2
if cur_pow > MAX:
break
other_pow = 1
while other_pow <= cur_pow:
nums[other_pow] += 1
other_pow *= 2
seqs[cur_pow] -= 1
cur_len -= 1
print(-1 if len(res) == 0 else ' '.join(map(str, reversed(res))))
``` | instruction | 0 | 32,141 | 20 | 64,282 |
No | output | 1 | 32,141 | 20 | 64,283 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.