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.
A wavy number is such positive integer that for any digit of its decimal representation except for the first one and the last one following condition holds: the digit is either strictly larger than both its adjacent digits or strictly less than both its adjacent digits. For example, numbers 35270, 102, 747, 20 and 3 are wavy and numbers 123, 1000 and 2212 are not.
The task is to find the k-th smallest wavy number r that is divisible by n for the given integer values n and k.
You are to write a program that will find the value of r if it doesn't exceed 1014.
Input
The only line of input contains two integers n and k, separated by a single space (1 β€ n, k β€ 1014).
Output
Your task is to output the only integer r β the answer to the given problem. If such number does not exist or it is larger than 1014, then print "-1" (minus one without the quotes) instead.
Examples
Input
123 4
Output
1845
Input
100 1
Output
-1
Input
97461 457
Output
1805270103
Note
The values of the first four wavy numbers that are divisible by n for the first sample are: 492, 615, 738 and 1845.
Submitted Solution:
```
def f(x):
for i in range(1, len(x) - 1):
if not ((x[i] > x[i - 1] and x[i] > x[i + 1]) or (x[i] < x[i - 1] and x[i] < x[i + 1])):
return False
return True
n = input().split()
k = int(n[1])
n = int(n[0])
print (n, k)
i = 1
cont = 0
if n % 100 == 0:
print("-1")
else:
while True:
aux = n * i
if aux > 10 ** 14:
break
if f(str(aux)):
cont += 1
if cont == k:
break
i += 1
if cont == k:
print(aux)
else:
print ("-1")
``` | instruction | 0 | 84,573 | 20 | 169,146 |
No | output | 1 | 84,573 | 20 | 169,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A wavy number is such positive integer that for any digit of its decimal representation except for the first one and the last one following condition holds: the digit is either strictly larger than both its adjacent digits or strictly less than both its adjacent digits. For example, numbers 35270, 102, 747, 20 and 3 are wavy and numbers 123, 1000 and 2212 are not.
The task is to find the k-th smallest wavy number r that is divisible by n for the given integer values n and k.
You are to write a program that will find the value of r if it doesn't exceed 1014.
Input
The only line of input contains two integers n and k, separated by a single space (1 β€ n, k β€ 1014).
Output
Your task is to output the only integer r β the answer to the given problem. If such number does not exist or it is larger than 1014, then print "-1" (minus one without the quotes) instead.
Examples
Input
123 4
Output
1845
Input
100 1
Output
-1
Input
97461 457
Output
1805270103
Note
The values of the first four wavy numbers that are divisible by n for the first sample are: 492, 615, 738 and 1845.
Submitted Solution:
```
def wn(arr):
for i in range(1,len(arr)-1):
if arr[i-1]<arr[i]>arr[i+1] or arr[i-1]>arr[i]<arr[i+1]:
continue
else:
return 0
return 1
arr,k=map(int,input().split())
c=0
n=arr
i=1
while int(n)<10**4 and c<4:
n=str(arr*i)
a=[int(x) for x in n]
if wn(a):
c+=1
i+=1
if c==4:
print(n)
else:
print(-1)
#print(wn([1,8,4,5]))
``` | instruction | 0 | 84,574 | 20 | 169,148 |
No | output | 1 | 84,574 | 20 | 169,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John gave Jack a very hard problem. He wrote a very big positive integer A0 on a piece of paper. The number is less than 10200000 . In each step, Jack is allowed to put ' + ' signs in between some of the digits (maybe none) of the current number and calculate the sum of the expression. He can perform the same procedure on that sum and so on. The resulting sums can be labeled respectively by A1, A2 etc. His task is to get to a single digit number.
The problem is that there is not much blank space on the paper. There are only three lines of space, so he can't perform more than three steps. Since he wants to fill up the paper completely, he will perform exactly three steps.
Jack must not add leading zeros to intermediate results, but he can put ' + ' signs in front of digit 0. For example, if the current number is 1000100, 10 + 001 + 00 is a valid step, resulting in number 11.
Input
First line contains a positive integer N (1 β€ N β€ 200000), representing the number of digits of A0.
Second line contains a string of length N representing positive integer number A0. Each character is digit. There will be no leading zeros.
Output
Output exactly three lines, the steps Jack needs to perform to solve the problem. You can output any sequence of steps which results in a single digit number (and is logically consistent).
Every step consists of digits and ' + ' signs. Steps should not contain several ' + ' signs in a row, whitespaces, or ' + ' signs as the first or last character. They also need to be arithmetically consistent.
Solution might not be unique. Output any of them in that case.
Examples
Input
1
1
Output
1
1
1
Input
4
5806
Output
5+8+0+6
1+9
1+0
Note
In the first sample, Jack can't put ' + ' signs anywhere, so he just writes 1 in each line and solves the problem. Here, solution is unique.
In the second sample, Jack first puts ' + ' between every two consecutive digits, thus getting the result 5 + 8 + 0 + 6 = 19. He does the same on the second step, getting 1 + 9 = 10. Once more, he gets 1 + 0 = 1, so after three steps, the result is 1 and his solution is correct.
Submitted Solution:
```
input();a=input()
for _ in ' '*3:
print('+'.join(a));a=str(sum(map(int,a)))
``` | instruction | 0 | 84,714 | 20 | 169,428 |
No | output | 1 | 84,714 | 20 | 169,429 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John gave Jack a very hard problem. He wrote a very big positive integer A0 on a piece of paper. The number is less than 10200000 . In each step, Jack is allowed to put ' + ' signs in between some of the digits (maybe none) of the current number and calculate the sum of the expression. He can perform the same procedure on that sum and so on. The resulting sums can be labeled respectively by A1, A2 etc. His task is to get to a single digit number.
The problem is that there is not much blank space on the paper. There are only three lines of space, so he can't perform more than three steps. Since he wants to fill up the paper completely, he will perform exactly three steps.
Jack must not add leading zeros to intermediate results, but he can put ' + ' signs in front of digit 0. For example, if the current number is 1000100, 10 + 001 + 00 is a valid step, resulting in number 11.
Input
First line contains a positive integer N (1 β€ N β€ 200000), representing the number of digits of A0.
Second line contains a string of length N representing positive integer number A0. Each character is digit. There will be no leading zeros.
Output
Output exactly three lines, the steps Jack needs to perform to solve the problem. You can output any sequence of steps which results in a single digit number (and is logically consistent).
Every step consists of digits and ' + ' signs. Steps should not contain several ' + ' signs in a row, whitespaces, or ' + ' signs as the first or last character. They also need to be arithmetically consistent.
Solution might not be unique. Output any of them in that case.
Examples
Input
1
1
Output
1
1
1
Input
4
5806
Output
5+8+0+6
1+9
1+0
Note
In the first sample, Jack can't put ' + ' signs anywhere, so he just writes 1 in each line and solves the problem. Here, solution is unique.
In the second sample, Jack first puts ' + ' between every two consecutive digits, thus getting the result 5 + 8 + 0 + 6 = 19. He does the same on the second step, getting 1 + 9 = 10. Once more, he gets 1 + 0 = 1, so after three steps, the result is 1 and his solution is correct.
Submitted Solution:
```
def func(num):
l = list(str(num))
print('+'.join(l))
y = 0
for z in l:
y+=int(z)
return y
n = int(input())
n = func(n)
n = func(n)
n = func(n)
``` | instruction | 0 | 84,715 | 20 | 169,430 |
No | output | 1 | 84,715 | 20 | 169,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John gave Jack a very hard problem. He wrote a very big positive integer A0 on a piece of paper. The number is less than 10200000 . In each step, Jack is allowed to put ' + ' signs in between some of the digits (maybe none) of the current number and calculate the sum of the expression. He can perform the same procedure on that sum and so on. The resulting sums can be labeled respectively by A1, A2 etc. His task is to get to a single digit number.
The problem is that there is not much blank space on the paper. There are only three lines of space, so he can't perform more than three steps. Since he wants to fill up the paper completely, he will perform exactly three steps.
Jack must not add leading zeros to intermediate results, but he can put ' + ' signs in front of digit 0. For example, if the current number is 1000100, 10 + 001 + 00 is a valid step, resulting in number 11.
Input
First line contains a positive integer N (1 β€ N β€ 200000), representing the number of digits of A0.
Second line contains a string of length N representing positive integer number A0. Each character is digit. There will be no leading zeros.
Output
Output exactly three lines, the steps Jack needs to perform to solve the problem. You can output any sequence of steps which results in a single digit number (and is logically consistent).
Every step consists of digits and ' + ' signs. Steps should not contain several ' + ' signs in a row, whitespaces, or ' + ' signs as the first or last character. They also need to be arithmetically consistent.
Solution might not be unique. Output any of them in that case.
Examples
Input
1
1
Output
1
1
1
Input
4
5806
Output
5+8+0+6
1+9
1+0
Note
In the first sample, Jack can't put ' + ' signs anywhere, so he just writes 1 in each line and solves the problem. Here, solution is unique.
In the second sample, Jack first puts ' + ' between every two consecutive digits, thus getting the result 5 + 8 + 0 + 6 = 19. He does the same on the second step, getting 1 + 9 = 10. Once more, he gets 1 + 0 = 1, so after three steps, the result is 1 and his solution is correct.
Submitted Solution:
```
def parser():
while 1:
data = list(input().split(' '))
for number in data:
if len(number) > 0:
yield(number)
input_parser = parser()
def get_word():
global input_parser
return next(input_parser)
def get_number():
data = get_word()
try:
return int(data)
except ValueError:
return float(data)
n = get_number()
s = get_word()
temp_num = 0
ans = []
ts = ''
for j in range(3):
for i in s:
ts = ts + (i + '+')
temp_num += int(i)
s = str(temp_num)
ans.append(ts.strip('+'))
ts = ''
temp_num = 0
for s in ans:
print(s)
``` | instruction | 0 | 84,716 | 20 | 169,432 |
No | output | 1 | 84,716 | 20 | 169,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John gave Jack a very hard problem. He wrote a very big positive integer A0 on a piece of paper. The number is less than 10200000 . In each step, Jack is allowed to put ' + ' signs in between some of the digits (maybe none) of the current number and calculate the sum of the expression. He can perform the same procedure on that sum and so on. The resulting sums can be labeled respectively by A1, A2 etc. His task is to get to a single digit number.
The problem is that there is not much blank space on the paper. There are only three lines of space, so he can't perform more than three steps. Since he wants to fill up the paper completely, he will perform exactly three steps.
Jack must not add leading zeros to intermediate results, but he can put ' + ' signs in front of digit 0. For example, if the current number is 1000100, 10 + 001 + 00 is a valid step, resulting in number 11.
Input
First line contains a positive integer N (1 β€ N β€ 200000), representing the number of digits of A0.
Second line contains a string of length N representing positive integer number A0. Each character is digit. There will be no leading zeros.
Output
Output exactly three lines, the steps Jack needs to perform to solve the problem. You can output any sequence of steps which results in a single digit number (and is logically consistent).
Every step consists of digits and ' + ' signs. Steps should not contain several ' + ' signs in a row, whitespaces, or ' + ' signs as the first or last character. They also need to be arithmetically consistent.
Solution might not be unique. Output any of them in that case.
Examples
Input
1
1
Output
1
1
1
Input
4
5806
Output
5+8+0+6
1+9
1+0
Note
In the first sample, Jack can't put ' + ' signs anywhere, so he just writes 1 in each line and solves the problem. Here, solution is unique.
In the second sample, Jack first puts ' + ' between every two consecutive digits, thus getting the result 5 + 8 + 0 + 6 = 19. He does the same on the second step, getting 1 + 9 = 10. Once more, he gets 1 + 0 = 1, so after three steps, the result is 1 and his solution is correct.
Submitted Solution:
```
print(5)
``` | instruction | 0 | 84,717 | 20 | 169,434 |
No | output | 1 | 84,717 | 20 | 169,435 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya loves long lucky numbers very much. He is interested in the minimum lucky number d that meets some condition. Let cnt(x) be the number of occurrences of number x in number d as a substring. For example, if d = 747747, then cnt(4) = 2, cnt(7) = 4, cnt(47) = 2, cnt(74) = 2. Petya wants the following condition to fulfil simultaneously: cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. Petya is not interested in the occurrences of other numbers. Help him cope with this task.
Input
The single line contains four integers a1, a2, a3 and a4 (1 β€ a1, a2, a3, a4 β€ 106).
Output
On the single line print without leading zeroes the answer to the problem β the minimum lucky number d such, that cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. If such number does not exist, print the single number "-1" (without the quotes).
Examples
Input
2 2 1 1
Output
4774
Input
4 7 3 1
Output
-1 | instruction | 0 | 85,215 | 20 | 170,430 |
Tags: constructive algorithms
Correct Solution:
```
from math import *
from fractions import *
from sys import *
def li():
return list(map(int, input().split(" ")))
a = li()
if abs(a[2]-a[3]) > 1:
print(-1)
exit()
if a[2] == a[3]:
ans = "47"*a[2]+"4"
elif a[2] > a[3]:
ans = "47"*a[2]
else:
ans = "74"*a[3]
f = a[0]-ans.count("4")
s = a[1]-ans.count("7")
shit =False
if s < 0 or f < 0:
if(a[2] == a[3]):
ans = "74"*a[2]+"7"
shit = True
f = a[0]-ans.count("4")
s = a[1]-ans.count("7")
if s < 0 or f < 0:
ans = "-1"
elif s>0 or f>0:
s+=1
f+=1
if ans[:2] == "47":
if(ans[-1] == "4"):
ans = "4"*f + "7" + ans[2:-1] + "7"*(s-1) + "4"
else:
ans = "4"*f + "7" + ans[2:] + "7"*(s-1)
else:
if(ans[-1] == "4"):
ans = "7" + "4"*f + ans[2:-1] + "7"*(s-1) + "4"
else:
ans = "7" + "4"*f + ans[2:] + "7"*(s-1)
print(ans)
``` | output | 1 | 85,215 | 20 | 170,431 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya loves long lucky numbers very much. He is interested in the minimum lucky number d that meets some condition. Let cnt(x) be the number of occurrences of number x in number d as a substring. For example, if d = 747747, then cnt(4) = 2, cnt(7) = 4, cnt(47) = 2, cnt(74) = 2. Petya wants the following condition to fulfil simultaneously: cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. Petya is not interested in the occurrences of other numbers. Help him cope with this task.
Input
The single line contains four integers a1, a2, a3 and a4 (1 β€ a1, a2, a3, a4 β€ 106).
Output
On the single line print without leading zeroes the answer to the problem β the minimum lucky number d such, that cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. If such number does not exist, print the single number "-1" (without the quotes).
Examples
Input
2 2 1 1
Output
4774
Input
4 7 3 1
Output
-1 | instruction | 0 | 85,216 | 20 | 170,432 |
Tags: constructive algorithms
Correct Solution:
```
a1,a2,a3,a4=map(int,input().split())
L=[]
def Solve(a1,a2,a3,a4):
if(a3-a4<-1 or a3-a4>1 or a1<a3 or a1<a4 or a2<a3 or a2<a4):
return -1
elif(a3-a4==0):
Ans="47"*a3
Ans+="4"
if(a1-a3==0 and a2-a4==0):
return -1
elif(a1-a3==0):
return "74"*a3+"7"*(a2-a4)
return "4"*(a1-a3-1)+Ans[:len(Ans)-1]+"7"*(a2-a4)+"4"
elif(a3-a4==1):
if(a2==a4):
return -1
Ans="47"*a3
Ans="4"*(a1-a3)+Ans+"7"*(a2-a4-1)
return Ans
else:
if(a3==a1):
return -1
Ans="74"*a4
Ans="7"+"4"*(a1-a3-1)+Ans[1:len(Ans)-1]+"7"*(a2-a4)+"4"
return Ans
print(Solve(a1,a2,a3,a4))
# Made By Mostafa_Khaled
``` | output | 1 | 85,216 | 20 | 170,433 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya loves long lucky numbers very much. He is interested in the minimum lucky number d that meets some condition. Let cnt(x) be the number of occurrences of number x in number d as a substring. For example, if d = 747747, then cnt(4) = 2, cnt(7) = 4, cnt(47) = 2, cnt(74) = 2. Petya wants the following condition to fulfil simultaneously: cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. Petya is not interested in the occurrences of other numbers. Help him cope with this task.
Input
The single line contains four integers a1, a2, a3 and a4 (1 β€ a1, a2, a3, a4 β€ 106).
Output
On the single line print without leading zeroes the answer to the problem β the minimum lucky number d such, that cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. If such number does not exist, print the single number "-1" (without the quotes).
Examples
Input
2 2 1 1
Output
4774
Input
4 7 3 1
Output
-1 | instruction | 0 | 85,217 | 20 | 170,434 |
Tags: constructive algorithms
Correct Solution:
```
a1,a2,a3,a4=map(int,input().split())
if abs(a3-a4)>1:
print(-1)
elif min(a1,a2)<max(a3,a4):
print(-1)
elif a1==a2==a3==a4:
print(-1)
else:
if a3==a4:
if a1==a3:
print ('74'*a3+'7'*(a2-a3))
else:
print('4'*(a1-a3-1)+'47'*a3+'7'*(a2-a3)+'4')
elif a3>a4:
print('4'*(a1-a3)+'47'*a3+'7'*(a2-a3))
else:
print('7'+'4'*(a1-a3)+'74'*(a3-1)+'7'*(a2-a3)+'4')
``` | output | 1 | 85,217 | 20 | 170,435 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya loves long lucky numbers very much. He is interested in the minimum lucky number d that meets some condition. Let cnt(x) be the number of occurrences of number x in number d as a substring. For example, if d = 747747, then cnt(4) = 2, cnt(7) = 4, cnt(47) = 2, cnt(74) = 2. Petya wants the following condition to fulfil simultaneously: cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. Petya is not interested in the occurrences of other numbers. Help him cope with this task.
Input
The single line contains four integers a1, a2, a3 and a4 (1 β€ a1, a2, a3, a4 β€ 106).
Output
On the single line print without leading zeroes the answer to the problem β the minimum lucky number d such, that cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. If such number does not exist, print the single number "-1" (without the quotes).
Examples
Input
2 2 1 1
Output
4774
Input
4 7 3 1
Output
-1 | instruction | 0 | 85,218 | 20 | 170,436 |
Tags: constructive algorithms
Correct Solution:
```
a, b, c, d = map(int, input().split(' '))
if (a+b) - (c+d) < 1:
print(-1)
quit()
if c == d:
if a == c:
if (b-a < 0):
print(-1)
quit()
print('74' * d + '7' * (b-a))
quit()
if ((b-c) < 0 or (a-c-1) < 0):
print(-1)
quit()
print('4' * (a-c-1) + '47' * c + '7' * (b - c) + '4')
quit()
if c + 1 == d:
if (a-c-1 < 0 or b-c-1 < 0):
print(-1)
quit()
print('7' + '4' * (a-c-1) + '47' * c + '7' * (b-1-c) + '4')
quit()
if d + 1 == c:
if a-c < 0 or b-c < 0:
print(-1)
quit()
print('4'*(a-c) + '47' * (c) + '7' * (b-c))
quit()
print(-1)
quit()
``` | output | 1 | 85,218 | 20 | 170,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya loves long lucky numbers very much. He is interested in the minimum lucky number d that meets some condition. Let cnt(x) be the number of occurrences of number x in number d as a substring. For example, if d = 747747, then cnt(4) = 2, cnt(7) = 4, cnt(47) = 2, cnt(74) = 2. Petya wants the following condition to fulfil simultaneously: cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. Petya is not interested in the occurrences of other numbers. Help him cope with this task.
Input
The single line contains four integers a1, a2, a3 and a4 (1 β€ a1, a2, a3, a4 β€ 106).
Output
On the single line print without leading zeroes the answer to the problem β the minimum lucky number d such, that cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. If such number does not exist, print the single number "-1" (without the quotes).
Examples
Input
2 2 1 1
Output
4774
Input
4 7 3 1
Output
-1
Submitted Solution:
```
from math import *
from fractions import *
from sys import *
def li():
return list(map(int, input().split(" ")))
a = li()
if abs(a[2]-a[3]) > 1:
print(-1)
exit()
if a[2] == a[3]:
ans = "47"*a[2]+"4"
elif a[2] > a[3]:
ans = "47"*a[2]
else:
ans = "74"*a[3]
f = a[0]-ans.count("4")
s = a[1]-ans.count("7")
if s < 0 or f < 0:
if(a[2] == a[3]):
ans = "74"*a[2]+"7"
f = a[0]-ans.count("4")
s = a[1]-ans.count("7")
if s < 0 or f < 0:
ans = "-1"
elif s>0 or f>0:
s+=1
f+=1
if ans[:2] == "47":
ans = "4"*f + "7"*s + ans[2:]
else:
ans = "7" + "4"*f + ans[2:-1] + "7"*(s-1)
print(ans)
``` | instruction | 0 | 85,219 | 20 | 170,438 |
No | output | 1 | 85,219 | 20 | 170,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya loves long lucky numbers very much. He is interested in the minimum lucky number d that meets some condition. Let cnt(x) be the number of occurrences of number x in number d as a substring. For example, if d = 747747, then cnt(4) = 2, cnt(7) = 4, cnt(47) = 2, cnt(74) = 2. Petya wants the following condition to fulfil simultaneously: cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. Petya is not interested in the occurrences of other numbers. Help him cope with this task.
Input
The single line contains four integers a1, a2, a3 and a4 (1 β€ a1, a2, a3, a4 β€ 106).
Output
On the single line print without leading zeroes the answer to the problem β the minimum lucky number d such, that cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. If such number does not exist, print the single number "-1" (without the quotes).
Examples
Input
2 2 1 1
Output
4774
Input
4 7 3 1
Output
-1
Submitted Solution:
```
from math import *
from fractions import *
from sys import *
def li():
return list(map(int, input().split(" ")))
a = li()
if abs(a[2]-a[3]) > 1:
print(-1)
exit()
if a[2] == a[3]:
ans = "47"*a[2]+"4"
elif a[2] > a[3]:
ans = "47"*a[2]
else:
ans = "74"*a[3]
f = a[0]-ans.count("4")
s = a[1]-ans.count("7")
if s < 0 or f < 0:
ans = -1
elif s>0 or f>0:
s+=1
f+=1
if ans[:2] == "47":
ans = "4"*f + "7"*s + ans[2:]
else:
ans = "7"*s + "4"*f + ans[2:]
print(ans)
``` | instruction | 0 | 85,220 | 20 | 170,440 |
No | output | 1 | 85,220 | 20 | 170,441 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya loves long lucky numbers very much. He is interested in the minimum lucky number d that meets some condition. Let cnt(x) be the number of occurrences of number x in number d as a substring. For example, if d = 747747, then cnt(4) = 2, cnt(7) = 4, cnt(47) = 2, cnt(74) = 2. Petya wants the following condition to fulfil simultaneously: cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. Petya is not interested in the occurrences of other numbers. Help him cope with this task.
Input
The single line contains four integers a1, a2, a3 and a4 (1 β€ a1, a2, a3, a4 β€ 106).
Output
On the single line print without leading zeroes the answer to the problem β the minimum lucky number d such, that cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. If such number does not exist, print the single number "-1" (without the quotes).
Examples
Input
2 2 1 1
Output
4774
Input
4 7 3 1
Output
-1
Submitted Solution:
```
a, b, c, d = map(int, input().split(' '))
if (a+b) - (c+d) < 1:
print(-1)
quit()
if c == d:
if ((b-c) < 0 or (a-c-1) < 0):
print(-1)
quit()
if a == c:
print('74' * d + '7' * (b-a))
quit()
print('4' * (a-c-1) + '47' * c + '7' * (b - c) + '4')
quit()
if c + 1 == d:
if (a-c-1 < 0 or b-c-1 < 0):
print(-1)
quit()
print('7' + '4' * (a-c-1) + '47' * c + '7' * (b-1-c) + '4')
quit()
if d + 1 == c:
if a-c < 0 or b-c < 0:
print(-1)
quit()
print('4'*(a-c) + '47' * (c) + '7' * (b-c))
quit()
print(-1)
quit()
``` | instruction | 0 | 85,221 | 20 | 170,442 |
No | output | 1 | 85,221 | 20 | 170,443 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya loves long lucky numbers very much. He is interested in the minimum lucky number d that meets some condition. Let cnt(x) be the number of occurrences of number x in number d as a substring. For example, if d = 747747, then cnt(4) = 2, cnt(7) = 4, cnt(47) = 2, cnt(74) = 2. Petya wants the following condition to fulfil simultaneously: cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. Petya is not interested in the occurrences of other numbers. Help him cope with this task.
Input
The single line contains four integers a1, a2, a3 and a4 (1 β€ a1, a2, a3, a4 β€ 106).
Output
On the single line print without leading zeroes the answer to the problem β the minimum lucky number d such, that cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. If such number does not exist, print the single number "-1" (without the quotes).
Examples
Input
2 2 1 1
Output
4774
Input
4 7 3 1
Output
-1
Submitted Solution:
```
from math import *
from fractions import *
from sys import *
def li():
return list(map(int, input().split(" ")))
a = li()
if abs(a[2]-a[3]) > 1:
print(-1)
exit()
if a[2] == a[3]:
ans = "47"*a[2]+"4"
elif a[2] > a[3]:
ans = "47"*a[2]
else:
ans = "74"*a[3]
f = a[0]-ans.count("4")
s = a[1]-ans.count("7")
shit =False
if s < 0 or f < 0:
if(a[2] == a[3]):
ans = "74"*a[2]+"7"
shit = True
f = a[0]-ans.count("4")
s = a[1]-ans.count("7")
if s < 0 or f < 0:
ans = "-1"
elif s>0 or f>0:
s+=1
f+=1
if ans[:2] == "47":
if(ans[-1] == "4"):
ans = "4"*f + "7"*s + ans[2:]
else:
ans = "4"*f + "7" + ans[2:] + "7"*(s-1)
else:
if(ans[-1] == "4"):
ans = "7"*s + "4"*f + ans[2:]
else:
ans = "7" + "4"*f + ans[2:] + "7"*(s-1)
print(ans)
``` | instruction | 0 | 85,222 | 20 | 170,444 |
No | output | 1 | 85,222 | 20 | 170,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14 | instruction | 0 | 85,255 | 20 | 170,510 |
Tags: brute force, math, matrices
Correct Solution:
```
t= int(input())
n, m, List = 10000, 15000, []
def function(input):
if input == 0:
return (0, 1)
a, b = function(input >> 1)
a, b = ((2 * a * b - a * a) % n, (b * b + a * a) % n)
if input & 1:
a, b = (b % n, (a + b) % n)
return (a, b)
for j in range(m):
if function(j)[0] == t % n:
List.append(j)
while n <(10**13):
n *= 10;
Test = []
for i in List:
for j in range(10):
if function(i + j * m)[0] == t % n:
Test.append(i + j * m)
List = Test;
m *= 10
if List == []:
break
if List == []:
print(-1)
else:
List.sort()
print(List[0])
``` | output | 1 | 85,255 | 20 | 170,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14 | instruction | 0 | 85,256 | 20 | 170,512 |
Tags: brute force, math, matrices
Correct Solution:
```
ak=int(10**13)
f=int(input())
n,m,List=10000,15000,[]
def Fun1(input):
if input==0:
return (0,1)
a,b=Fun1(input>>1)
a,b=((2*a*b-a*a)%n,(b*b+a*a)%n)
if input&1:
a,b=(b%n,(a+b)%n)
return (a,b)
for j in range(m):
if Fun1(j)[0]==f%n:
List.append(j)
while n<ak:
n*=10;
Test=[]
for i in List:
for j in range(10):
if Fun1(i+j*m)[0]==f%n:
Test.append(i+j*m)
List=Test;m*=10
if List==[]:
break
if List==[]:
print(-1)
else:
List.sort()
print(List[0])
``` | output | 1 | 85,256 | 20 | 170,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14 | instruction | 0 | 85,257 | 20 | 170,514 |
Tags: brute force, math, matrices
Correct Solution:
```
low_n = 1000
high_m = 15000
limit = int(10 ** 13)
f = int(input())
inputList = []
def customFunction(i):
if i == 0:
return (0, 1)
a, b = customFunction(i >> 1)
a, b = ((2 * a * b - a * a) % low_n, (b * b + a * a) % low_n)
if i & 1:
a, b = (b % low_n, (a + b) % low_n)
return (a, b)
i = 0
while i < high_m:
if customFunction(i)[0] == f % low_n:
inputList.append(i)
i += 1
while low_n < limit:
low_n *= 10
tempList = []
for i in inputList:
for j in range(10):
if customFunction(i + j * high_m)[0] == f % low_n:
tempList.append(i + j * high_m)
inputList = tempList
high_m *= 10
if inputList == []:
break
if inputList == []:
print(-1)
else:
inputList = sorted(inputList)
print(inputList[0])
``` | output | 1 | 85,257 | 20 | 170,515 |
Provide tags and a correct Python 3 solution for this coding contest problem.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14 | instruction | 0 | 85,258 | 20 | 170,516 |
Tags: brute force, math, matrices
Correct Solution:
```
n,m,limn,f,L=10000,15000,int(10**13),int(input()),[]
def F(i):
if i==0:
return (0,1)
a,b=F(i>>1)
a,b=((2*a*b-a*a)%n,(b*b+a*a)%n)
if i&1:
a,b=(b%n,(a+b)%n)
return (a,b)
for i in range(m):
if F(i)[0]==f%n:
L.append(i)
while n<limn:
n*=10;
T=[]
for i in L:
for j in range(10):
if F(i+j*m)[0]==f%n:
T.append(i+j*m)
L=T;m*=10
if L==[]:
break
if L==[]:
print(-1)
else:
L.sort()
print(L[0])
``` | output | 1 | 85,258 | 20 | 170,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14 | instruction | 0 | 85,259 | 20 | 170,518 |
Tags: brute force, math, matrices
Correct Solution:
```
n,m,l,f,L=10000,15000,int(10**13),int(input()),[]
def F(i):
if i==0:
return (0,1)
x,y=F(i>>1)
x,y=((2*x*y-x*x)%n,(y*y+x*x)%n)
if i&1:
x,y=(y%n,(x+y)%n)
return (x,y)
for i in range(m):
if F(i)[0]==f%n:
L.append(i)
while n<l:
n*=10;
T=[]
for i in L:
for j in range(10):
if F(i+j*m)[0]==f%n:
T.append(i+j*m)
L=T;m*=10
if L==[]:
break
if L==[]:
print(-1)
else:
L.sort()
print(L[0])
``` | output | 1 | 85,259 | 20 | 170,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14 | instruction | 0 | 85,260 | 20 | 170,520 |
Tags: brute force, math, matrices
Correct Solution:
```
p, q, li, s, l = 10000, 15000, int(10 ** 13), int(input()), []
def Fibo(i):
if i == 0:
return (0, 1)
a, b = Fibo(i >> 1)
a, b = ((2 * a * b - a * a) % p, (b * b + a * a) % p)
if i & 1:
a, b = (b % p, (a + b) % p)
return (a, b)
for i in range(q):
if Fibo(i)[0] == s % p:
l.append(i)
while p < li:
p *= 10;
T = []
for i in l:
for j in range(10):
if Fibo(i + j * q)[0] == s % p:
T.append(i + j * q)
l = T;
q *= 10
if l == []:
break
if l == []:
print(-1)
else:
l.sort()
print(l[0])
``` | output | 1 | 85,260 | 20 | 170,521 |
Provide tags and a correct Python 3 solution for this coding contest problem.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14 | instruction | 0 | 85,261 | 20 | 170,522 |
Tags: brute force, math, matrices
Correct Solution:
```
n=1000
m=15000
limit=int(10**13)
x=int(input())
l=[]
def fun(i):
if i==0:
return(0,1)
a,b=fun(i>>1)
a,b=((2*a*b-a*a)%n,(b*b+a*a)%n)
if i & 1:
a,b=(b%n,(a+b)%n)
return (a,b)
i=0
while i<m:
if fun(i)[0]==x%n:
l.append(i)
i+=1
while n<limit:
n*=10
t=[]
for i in l:
for j in range(10):
if fun(i+j*m)[0]==x%n:
t.append(i+j*m)
l=t
m*=10
if l==[]:
break
if l==[]:
print(-1)
else:
l=sorted(l)
print(l[0])
``` | output | 1 | 85,261 | 20 | 170,523 |
Provide tags and a correct Python 3 solution for this coding contest problem.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14 | instruction | 0 | 85,262 | 20 | 170,524 |
Tags: brute force, math, matrices
Correct Solution:
```
mo = 10 ** 13
p = [
1, 60, 300, 1500, 15000, 150000, 1500000, 15000000,
150000000, 1500000000, 15000000000, 150000000000,
1500000000000, 15000000000000
]
class mat(object):
def __init__(self, a, b, c, d):
self.a, self.b, self.c, self.d = a, b, c, d
def times(self, k):
return mat(
(self.a * k.a + self.b * k.c) % mo,
(self.a * k.b + self.b * k.d) % mo,
(self.c * k.a + self.d * k.c) % mo,
(self.c * k.b + self.d * k.d) % mo
)
def copy(self):
return mat(self.a, self.b, self.c, self.d)
me, mt = mat(1, 0, 0, 1), mat(0, 1, 1, 1)
def fib(k):
ans, t = me.copy(), mt.copy()
while k > 0:
if k & 1:
ans = ans.times(t)
t = t.times(t)
k >>= 1
return ans.b
def gene(a, ta, b, tb, tab):
ab = []
for i in a:
for j in b:
y = -j // tb - 1
while j + y * tb < 0:
y += 1
while j + y * tb < tab:
if (j - i + y * tb) % ta == 0:
ab.append(j + y * tb)
y += 1
return ab
def filt(a, f, m):
r = f % m
return [i for i in a if (fib(i) % m == r)]
if __name__ == '__main__':
f = int(input())
a = filt(list(range(p[1])), f, 10)
b = a[:]
for i in range(2, 14):
m = 10 ** i
b = gene(a, p[1], b, p[i - 1], p[i])
b = filt(b, f, m)
print(min(b) if b else -1)
``` | output | 1 | 85,262 | 20 | 170,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14
Submitted Solution:
```
n, m, limn, f, L = 10000, 15000, int(10 ** 13), int(input()), []
def F(i):
if i == 0:
return (0, 1)
p, q = F(i >> 1)
p, q = ((2 * p * q - p * p) % n, (q * q + p * p) % n)
if i & 1:
p, q = (q % n, (p + q) % n)
return (p, q)
for i in range(m):
if F(i)[0] == f % n:
L.append(i)
while n < limn:
n *= 10;
Z = []
for i in L:
for j in range(10):
if F(i + j * m)[0] == f % n:
Z.append(i + j * m)
L = Z;
m *= 10
if L == []:
break
if L == []:
print(-1)
else:
L.sort()
print(L[0])
``` | instruction | 0 | 85,263 | 20 | 170,526 |
Yes | output | 1 | 85,263 | 20 | 170,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14
Submitted Solution:
```
#https://codeforces.com/contest/193/problem/E
n, m, limn, f, L = 10000, 15000, int(10 ** 13), int(input()), []
def F(i):
if i == 0:
return (0, 1)
a, b = F(i >> 1)
a, b = ((2 * a * b - a * a) % n, (b * b + a * a) % n)
if i & 1:
a, b = (b % n, (a + b) % n)
return (a, b)
for i in range(m):
if F(i)[0] == f % n:
L.append(i)
while n < limn:
n *= 10;
T = []
for i in L:
for j in range(10):
if F(i + j * m)[0] == f % n:
T.append(i + j * m)
L = T;
m *= 10
if L == []:
break
if L == []:
print(-1)
else:
L.sort()
print(L[0])
``` | instruction | 0 | 85,264 | 20 | 170,528 |
Yes | output | 1 | 85,264 | 20 | 170,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14
Submitted Solution:
```
x = int(10 ** 13)
f = int(input())
n, m, List = 10000, 15000, []
def Fun1(input):
if input == 0:
return (0, 1)
a, b = Fun1(input >> 1)
a, b = ((2 * a * b - a * a) % n, (b * b + a * a) % n)
if input & 1:
a, b = (b % n, (a + b) % n)
return (a, b)
for j in range(m):
if Fun1(j)[0] == f % n:
List.append(j)
while n < x:
n *= 10
Test = []
for i in List:
for j in range(10):
if Fun1(i + j * m)[0] == f % n:
Test.append(i + j * m)
List = Test
m *= 10
if List == []:
break
if List == []:
print(-1)
else:
List.sort()
print(List[0])
``` | instruction | 0 | 85,265 | 20 | 170,530 |
Yes | output | 1 | 85,265 | 20 | 170,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14
Submitted Solution:
```
n=int(input())
n1=0
n2=1
n3=1
i=1
if n<=1:
print(n)
else:
while n3<=n:
n3=n2+n1
n1=n2
n2=n3
i=i+1
print(i)
``` | instruction | 0 | 85,266 | 20 | 170,532 |
No | output | 1 | 85,266 | 20 | 170,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14
Submitted Solution:
```
n = int(input())
a1 = 1
a2 = 1
c=2
if(n == 2406684390626):
print(999999)
elif(n == 0):
print(0)
elif(n == 1):
print(1)
else:
while(a1 < n):
a1 += a2
a2 = a1 - a2
c+=1
#print(a1)
if(a1 == n):
print(c)
else:
print(-1)
``` | instruction | 0 | 85,267 | 20 | 170,534 |
No | output | 1 | 85,267 | 20 | 170,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14
Submitted Solution:
```
def fibonacciNum(num):
if (num <= 1):
return num
firstNum = 0
secondNum = 1
thirdNum = 1
count = 1
while (num > thirdNum):
thirdNum = firstNum + secondNum
count += 1
firstNum = secondNum
secondNum = thirdNum
return count
n = int(input())
print(fibonacciNum(n))
``` | instruction | 0 | 85,268 | 20 | 170,536 |
No | output | 1 | 85,268 | 20 | 170,537 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 β€ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 β€ f < 1013) β the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14
Submitted Solution:
```
fib_nums=[0,1]
while fib_nums[len(fib_nums)-1]<10000000000000:
fib_nums.append(fib_nums[len(fib_nums)-2]+fib_nums[len(fib_nums)-1])
n=int(input())
if n in fib_nums:
print(fib_nums.index(n))
else:
print(-1)
``` | instruction | 0 | 85,269 | 20 | 170,538 |
No | output | 1 | 85,269 | 20 | 170,539 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger | instruction | 0 | 85,376 | 20 | 170,752 |
Tags: implementation, strings
Correct Solution:
```
# your code goes here
a=int(input(""))
if a<=127 :
print("byte")
else :
if a<=32767 :
print("short")
else :
if a<=2147483647 :
print("int")
else :
if a<=9223372036854775807 :
print("long")
else :
print("BigInteger")
``` | output | 1 | 85,376 | 20 | 170,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger | instruction | 0 | 85,377 | 20 | 170,754 |
Tags: implementation, strings
Correct Solution:
```
num = int(input());
long = len(str(abs(num)));
if(num<0): num = abs(num+1);
if(num<=127): print("byte");
else:
if(num<=32767):print("short");
else:
if( num<=2147483647):print("int");
else:
if(num<=9223372036854775807):print("long");
else:print("BigInteger");
``` | output | 1 | 85,377 | 20 | 170,755 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger | instruction | 0 | 85,378 | 20 | 170,756 |
Tags: implementation, strings
Correct Solution:
```
x = int(input())
if(x >= -128 & x <= 127):
print ("byte")
elif(x >= -32768 & x <= 32767):
print("short")
elif(x >= -2147483648 & x <= 2147483647):
print("int")
elif(x >= -9223372036854775808 & x <= 9223372036854775807 ):
print("long")
else:
print("BigInteger")
``` | output | 1 | 85,378 | 20 | 170,757 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger | instruction | 0 | 85,379 | 20 | 170,758 |
Tags: implementation, strings
Correct Solution:
```
n = int(input())
if n >= -128 and n <= 127:
print("byte")
elif n >=-32768 and n <=32767:
print("short")
elif n >=-2147483648 and n <=2147483647:
print("int")
elif n >=-9223372036854775808 and n <=9223372036854775807:
print("long")
else :
print("BigInteger")
``` | output | 1 | 85,379 | 20 | 170,759 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger | instruction | 0 | 85,380 | 20 | 170,760 |
Tags: implementation, strings
Correct Solution:
```
#easy in python
n = int(input())
if n <= 127:
print("byte")
elif n <= 32767:
print("short")
elif n <= 2147483647:
print("int")
elif n <= 9223372036854775807:
print("long")
else:
print("BigInteger")
``` | output | 1 | 85,380 | 20 | 170,761 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger | instruction | 0 | 85,381 | 20 | 170,762 |
Tags: implementation, strings
Correct Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# mod=10**9+7
# sys.setrecursionlimit(10**6)
# from functools import lru_cache
def main():
n=input()
if len(n)>20:
print('BigInteger')
exit()
n=int(n)
if -128<=n<=127:
print("byte")
elif -32768<=n<=32767:
print("short")
elif -2147483648<=n<=2147483647:
print('int')
elif -9223372036854775808<=n<=9223372036854775807:
print('long')
else:
print('BigInteger')
#----------------------------------------------------------------------------------------
# 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 | 85,381 | 20 | 170,763 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger | instruction | 0 | 85,382 | 20 | 170,764 |
Tags: implementation, strings
Correct Solution:
```
b=127
s=32767
i=2147483647
l=9223372036854775807
inp=int(input())
if(inp<=b):
print('byte')
elif(inp<=s):
print('short')
elif(inp<=i):
print('int')
elif(inp<=l):
print('long')
else:
print('BigInteger')
``` | output | 1 | 85,382 | 20 | 170,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger | instruction | 0 | 85,383 | 20 | 170,766 |
Tags: implementation, strings
Correct Solution:
```
s = int(input ())
if (s >= -128 ) and (s <= 127):
print ("byte")
elif (s >= -32768)and(s <= 32767):
print ("short")
elif (s >= -2147483648)and(s <= 2147483647):
print ("int")
elif (s >= -9223372036854775808)and(s <= 9223372036854775807):
print ("long")
else:
print ("BigInteger")
``` | output | 1 | 85,383 | 20 | 170,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger
Submitted Solution:
```
i = int(input())
if(-128<=i and i<=127):
print("byte")
elif(-32768<=i and i<= 32767):
print("short")
elif(-2147483648<=i and i<=2147483647):
print("int")
elif(-9223372036854775808<=i and i<=9223372036854775807):
print("long")
else:
print("BigInteger")
``` | instruction | 0 | 85,384 | 20 | 170,768 |
Yes | output | 1 | 85,384 | 20 | 170,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger
Submitted Solution:
```
n = int(input())
if(n>= -127 and n<=127):
print("byte")
elif(n>= -32768 and n<= 32767):
print("short")
elif(n>= -2147483648 and n<= 2147483647):
print("int")
elif(n>= -9223372036854775808 and n<= 9223372036854775807):
print("long")
else:
print("BigInteger")
``` | instruction | 0 | 85,385 | 20 | 170,770 |
Yes | output | 1 | 85,385 | 20 | 170,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger
Submitted Solution:
```
a = int(input())
if 0<a<=127:
print('byte')
elif a<32768:
print('short')
elif a<2147483648:
print('int')
elif a<9223372036854775808:
print('long')
else:
print('BigInteger')
``` | instruction | 0 | 85,386 | 20 | 170,772 |
Yes | output | 1 | 85,386 | 20 | 170,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger
Submitted Solution:
```
s=int(input())
if(s>=-128 and s<=127):
print("byte")
elif(s>=-32768 and s<=32767):
print("short")
elif(s>=-2147483648 and s<=2147483647):
print("int")
elif(s>=-9223372036854775808 and s<=9223372036854775807):
print("long")
else:
print("BigInteger")
``` | instruction | 0 | 85,387 | 20 | 170,774 |
Yes | output | 1 | 85,387 | 20 | 170,775 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger
Submitted Solution:
```
n = int(input())
#heights = list(map(int, input().split()))
if n >= -128 and n <= 127:
print("byte")
elif n >= -32768 and n <= 32767:
print("short")
elif n >= -2147483648 and n <= 2147483647:
print("int")
else:
print("BigInteger")
``` | instruction | 0 | 85,388 | 20 | 170,776 |
No | output | 1 | 85,388 | 20 | 170,777 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger
Submitted Solution:
```
def main():
n = input()
n = int(n)
if n >= -127 and n <= 127:
print("byte")
elif n >= -32768 and n <= 32767 :
print("short")
elif n >= -2147483648 and n <= 2147483647:
print("intger")
elif n >= -9223372036854775808 and n <= 9223372036854775807:
print("long")
else:
print("Biginter")
main()
``` | instruction | 0 | 85,389 | 20 | 170,778 |
No | output | 1 | 85,389 | 20 | 170,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger
Submitted Solution:
```
n=int(input())
if n>=-128 and n<=127:
print('byte')
if n>=-32768 and n<=32767:
print('short')
if n>=-2147483648 and n<=2147483647:
print('int')
if n>=-9223372036854775808 and n<=9223372036854775807:
print('long')
else:
print('BigInteger')
``` | instruction | 0 | 85,390 | 20 | 170,780 |
No | output | 1 | 85,390 | 20 | 170,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger
Submitted Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# mod=10**9+7
# sys.setrecursionlimit(10**6)
# from functools import lru_cache
def main():
n=input()
if len(n)>20:
print('BigInteger')
exit()
n=int(n)
if -128<=n<=127:
print("byte")
elif -32768<=n<=32767:
print("short")
elif -9223372036854775808<=n<=9223372036854775807:
print('long')
else:
print('BigInteger')
#----------------------------------------------------------------------------------------
# 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()
``` | instruction | 0 | 85,391 | 20 | 170,782 |
No | output | 1 | 85,391 | 20 | 170,783 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has n integers: 1, 2, 3, ..., n. He wants to split these integers in two non-empty groups in such a way that the absolute difference of sums of integers in each group is as small as possible.
Help Petya to split the integers. Each of n integers should be exactly in one group.
Input
The first line contains a single integer n (2 β€ n β€ 60 000) β the number of integers Petya has.
Output
Print the smallest possible absolute difference in the first line.
In the second line print the size of the first group, followed by the integers in that group. You can print these integers in arbitrary order. If there are multiple answers, print any of them.
Examples
Input
4
Output
0
2 1 4
Input
2
Output
1
1 1
Note
In the first example you have to put integers 1 and 4 in the first group, and 2 and 3 in the second. This way the sum in each group is 5, and the absolute difference is 0.
In the second example there are only two integers, and since both groups should be non-empty, you have to put one integer in the first group and one in the second. This way the absolute difference of sums of integers in each group is 1. | instruction | 0 | 85,461 | 20 | 170,922 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
if __name__ == '__main__':
n = int(input().strip())
l1, l2 = [], []
s1, s2 = 0, 0
for i in range(n, 0, -1):
if s1 < s2:
s1 += i
l1.append(i)
else:
s2 += i
l2.append(i)
print(abs(s1 - s2))
print(len(l1), end=" ")
for i in l1:
print(i, end=" ")
``` | output | 1 | 85,461 | 20 | 170,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has n integers: 1, 2, 3, ..., n. He wants to split these integers in two non-empty groups in such a way that the absolute difference of sums of integers in each group is as small as possible.
Help Petya to split the integers. Each of n integers should be exactly in one group.
Input
The first line contains a single integer n (2 β€ n β€ 60 000) β the number of integers Petya has.
Output
Print the smallest possible absolute difference in the first line.
In the second line print the size of the first group, followed by the integers in that group. You can print these integers in arbitrary order. If there are multiple answers, print any of them.
Examples
Input
4
Output
0
2 1 4
Input
2
Output
1
1 1
Note
In the first example you have to put integers 1 and 4 in the first group, and 2 and 3 in the second. This way the sum in each group is 5, and the absolute difference is 0.
In the second example there are only two integers, and since both groups should be non-empty, you have to put one integer in the first group and one in the second. This way the absolute difference of sums of integers in each group is 1. | instruction | 0 | 85,462 | 20 | 170,924 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
n=int(input())
s=n
i=n-1
g=[n]
while i>0:
if s>0:
s-=i
else:
s+=i
g.append(i)
i-=1
print(s)
print(len(g),end=' ')
print(*g)
``` | output | 1 | 85,462 | 20 | 170,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has n integers: 1, 2, 3, ..., n. He wants to split these integers in two non-empty groups in such a way that the absolute difference of sums of integers in each group is as small as possible.
Help Petya to split the integers. Each of n integers should be exactly in one group.
Input
The first line contains a single integer n (2 β€ n β€ 60 000) β the number of integers Petya has.
Output
Print the smallest possible absolute difference in the first line.
In the second line print the size of the first group, followed by the integers in that group. You can print these integers in arbitrary order. If there are multiple answers, print any of them.
Examples
Input
4
Output
0
2 1 4
Input
2
Output
1
1 1
Note
In the first example you have to put integers 1 and 4 in the first group, and 2 and 3 in the second. This way the sum in each group is 5, and the absolute difference is 0.
In the second example there are only two integers, and since both groups should be non-empty, you have to put one integer in the first group and one in the second. This way the absolute difference of sums of integers in each group is 1. | instruction | 0 | 85,463 | 20 | 170,926 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
n = int(input())
if n % 4 == 0:
print(0)
data = []
for i in range(1, n + 1, 4):
data.append(str(i) + ' ' + str(i + 3))
elif n % 4 == 3:
print(0)
data = []
for i in range(4, n + 1, 4):
data.append(str(i) + ' ' + str(i + 3))
data.append('1 2')
elif n % 4 == 1:
print(1)
data = []
for i in range(2, n + 1, 4):
data.append(str(i) + ' ' + str(i + 3))
data.append('1')
else:
print(1)
data = []
for i in range(3, n + 1, 4):
data.append(str(i) + ' ' + str(i + 3))
data.append('1')
data = ' '.join(data).split()
print(len(data), ' '.join(data))
``` | output | 1 | 85,463 | 20 | 170,927 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has n integers: 1, 2, 3, ..., n. He wants to split these integers in two non-empty groups in such a way that the absolute difference of sums of integers in each group is as small as possible.
Help Petya to split the integers. Each of n integers should be exactly in one group.
Input
The first line contains a single integer n (2 β€ n β€ 60 000) β the number of integers Petya has.
Output
Print the smallest possible absolute difference in the first line.
In the second line print the size of the first group, followed by the integers in that group. You can print these integers in arbitrary order. If there are multiple answers, print any of them.
Examples
Input
4
Output
0
2 1 4
Input
2
Output
1
1 1
Note
In the first example you have to put integers 1 and 4 in the first group, and 2 and 3 in the second. This way the sum in each group is 5, and the absolute difference is 0.
In the second example there are only two integers, and since both groups should be non-empty, you have to put one integer in the first group and one in the second. This way the absolute difference of sums of integers in each group is 1. | instruction | 0 | 85,464 | 20 | 170,928 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
n = int(input())
if n % 4 == 0:
print(0)
print(n//2,end=" ")
step = 0
for i in range(1,n+1,2):
print(i+step,end=" ")
step = 1 - step
elif n % 4 == 3:
print(0)
print(n//2,end=" ")
step = 1
for i in range(2,n+1,2):
print(i+step,end=" ")
step = 1 - step
else:
print(1)
if n % 4 == 2:
print(n//2,end=" ")
step = 0
for i in range(1,n+1,2):
print(i+step,end=" ")
step = 1 - step
else:
print(n//2,end=" ")
step = 1
for i in range(2,n+1,2):
print(i+step,end=" ")
step = 1 - step
``` | output | 1 | 85,464 | 20 | 170,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has n integers: 1, 2, 3, ..., n. He wants to split these integers in two non-empty groups in such a way that the absolute difference of sums of integers in each group is as small as possible.
Help Petya to split the integers. Each of n integers should be exactly in one group.
Input
The first line contains a single integer n (2 β€ n β€ 60 000) β the number of integers Petya has.
Output
Print the smallest possible absolute difference in the first line.
In the second line print the size of the first group, followed by the integers in that group. You can print these integers in arbitrary order. If there are multiple answers, print any of them.
Examples
Input
4
Output
0
2 1 4
Input
2
Output
1
1 1
Note
In the first example you have to put integers 1 and 4 in the first group, and 2 and 3 in the second. This way the sum in each group is 5, and the absolute difference is 0.
In the second example there are only two integers, and since both groups should be non-empty, you have to put one integer in the first group and one in the second. This way the absolute difference of sums of integers in each group is 1. | instruction | 0 | 85,465 | 20 | 170,930 |
Tags: constructive algorithms, graphs, math
Correct Solution:
```
def chet(path):
n = len(path)
if n % 2 == 0:
if n == 2:
print(1)
print(1, 1)
if n > 2 and n % 4 != 0:
f_half = []
i = 0
while i + 1 < n // 2:
f_half.append(path[i])
f_half.append(path[-1 - i])
i = i + 2
f_half.append(path[n // 2 - 1])
print(1)
print(n // 2, *f_half)
elif n > 2 and n % 4 == 0:
f_half = []
i = 0
while i + 1 < n // 2:
f_half.append(path[i])
f_half.append(path[-1 - i])
i = i + 2
print(0)
print(n // 2, *f_half)
def nechet(path):
if sum(path) % 2 == 0:
if len(path) == 3:
print(0)
print(1, 3)
else:
f_half = [1, 2]
n = len(path[3:])
i = 0
while i + 1 < n // 2:
f_half.append(path[3:][i])
f_half.append(path[3:][-1 - i])
i = i + 2
print(0)
print(len(f_half), *f_half)
else:
f_half = [1]
n = len(path[1:])
i = 0
while i + 1 < n // 2:
f_half.append(path[1:][i])
f_half.append(path[1:][-1 - i])
i = i + 2
print(1)
print(len(f_half), *f_half)
n = int(input())
path = range(1, n+1)
if n % 2 == 0:
chet(path)
else:
nechet(path)
``` | output | 1 | 85,465 | 20 | 170,931 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.