message stringlengths 2 59.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 37 108k | cluster float64 20 20 | __index_level_0__ int64 74 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Jack is working on his jumping skills recently. Currently he's located at point zero of the number line. He would like to get to the point x. In order to train, he has decided that he'll first jump by only one unit, and each subsequent jump will be exactly one longer than the previous one. He can go either left or right with each jump. He wonders how many jumps he needs to reach x.
Input
The input data consists of only one integer x ( - 109 ≤ x ≤ 109).
Output
Output the minimal number of jumps that Jack requires to reach x.
Examples
Input
2
Output
3
Input
6
Output
3
Input
0
Output
0 | instruction | 0 | 43,911 | 20 | 87,822 |
Tags: math
Correct Solution:
```
n=int(input())
if n!=0:
sum1 = 0
i = 1
while True:
sum1 += i
if sum1 - abs(n) >= 0 and (sum1 - abs(n)) % 2 == 0:
break
i += 1
print(i)
else:
print(0)
``` | output | 1 | 43,911 | 20 | 87,823 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jack is working on his jumping skills recently. Currently he's located at point zero of the number line. He would like to get to the point x. In order to train, he has decided that he'll first jump by only one unit, and each subsequent jump will be exactly one longer than the previous one. He can go either left or right with each jump. He wonders how many jumps he needs to reach x.
Input
The input data consists of only one integer x ( - 109 ≤ x ≤ 109).
Output
Output the minimal number of jumps that Jack requires to reach x.
Examples
Input
2
Output
3
Input
6
Output
3
Input
0
Output
0 | instruction | 0 | 43,914 | 20 | 87,828 |
Tags: math
Correct Solution:
```
n = int(input())
n = abs(n)
o = 0
i = 0
while True:
if o >= n and o % 2 == n % 2:
print(i)
break
else:
i += 1
o += i
``` | output | 1 | 43,914 | 20 | 87,829 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it. | instruction | 0 | 44,026 | 20 | 88,052 |
Tags: greedy, math
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
s = "9" * (n - (n - 1) // 4 - 1) + "8" * ((n - 1) // 4 + 1)
print(s)
``` | output | 1 | 44,026 | 20 | 88,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it. | instruction | 0 | 44,027 | 20 | 88,054 |
Tags: greedy, math
Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
t = int(input())
for _ in range(t):
n = int(input())
num_8s = (n + 3) // 4
num_9s = n - num_8s
print("9" * num_9s + "8" * num_8s)
``` | output | 1 | 44,027 | 20 | 88,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it. | instruction | 0 | 44,028 | 20 | 88,056 |
Tags: greedy, math
Correct Solution:
```
import sys
input = sys.stdin.readline
t=int(input())
for tests in range(t):
n=int(input())
x=(n+3)//4
print("9"*(n-x)+"8"*x)
``` | output | 1 | 44,028 | 20 | 88,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it. | instruction | 0 | 44,029 | 20 | 88,058 |
Tags: greedy, math
Correct Solution:
```
from collections import deque
from collections import OrderedDict
import math
import sys
import os
import threading
import bisect
import operator
import heapq
from atexit import register
from io import BytesIO
#sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
#sys.stdout = BytesIO()
#register(lambda: os.write(1, sys.stdout.getvalue()))
import io
#input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
#sys.stdin = open("F:\PY\\test.txt", "r")
input = lambda: sys.stdin.readline().rstrip("\r\n")
#input = sys.stdin.readline
def binary_rep(n):
l = []
while(n>0):
l.append(n%2)
n=n//2
#l.reverse()
return l
for t in range(int(input())):
n = int(input())
answer = []
for i in range(n):
answer.append(9)
for i in range(n//4+ (1 if n%4!=0 else 0)):
answer[i]=8
answer.reverse()
print(*answer, sep="")
``` | output | 1 | 44,029 | 20 | 88,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it. | instruction | 0 | 44,030 | 20 | 88,060 |
Tags: greedy, math
Correct Solution:
```
for _ in range(int(input())):
a= int(input())
d=a//4
if a%4==0:
pass
else:
d+=1
n=["9"]*(a-d)
f=["8"]*d
n.extend(f)
print("".join(n))
``` | output | 1 | 44,030 | 20 | 88,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it. | instruction | 0 | 44,031 | 20 | 88,062 |
Tags: greedy, math
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
eights = n // 4 if n % 4 == 0 else n // 4 + 1
print("9" * (n - eights) + "8" * eights)
``` | output | 1 | 44,031 | 20 | 88,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it. | instruction | 0 | 44,032 | 20 | 88,064 |
Tags: greedy, math
Correct Solution:
```
t = int(input())
for _ in range (t):
n = int(input())
toDelete,rem = divmod (n,4)
if rem == 0:
s = "9"*(n-toDelete) + "8"*toDelete
else:
s = "9"*(n-toDelete-1) + "8"*(toDelete+1)
print (s)
``` | output | 1 | 44,032 | 20 | 88,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it. | instruction | 0 | 44,033 | 20 | 88,066 |
Tags: greedy, math
Correct Solution:
```
import sys
import os
# import math
# input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def str_array():
return input().strip().split()
def gcd(a,b):
if b == 0:
return a
return gcd(b, a % b);x
def take_input():
if os.environ.get("check"):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
take_input()
######################### TEMPLATE ENDS HERE #################################
for _ in range(int(input())):
n = int(input());
ans = ['9' for i in range(n)];
N = n % 4;
for i in range(n // 4):
ans.pop();
if N:
ans.pop();
for _ in range(n // 4):
ans.append('8');
if N:
ans.append('8');
ans = ''.join(ans);
print(ans);
``` | output | 1 | 44,033 | 20 | 88,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
if n%4==0:
ei=n//4
else:
ei=(n//4)+1
ni=n-ei
for i in range(ni):
print(9,end="")
for i in range(ei):
print(8,end="")
print()
``` | instruction | 0 | 44,034 | 20 | 88,068 |
Yes | output | 1 | 44,034 | 20 | 88,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it.
Submitted Solution:
```
for t in range(int(input())):
n = int(input())
a=[]
b=(n+3)//4
a.append ('9'*(n-b))
a.append('8'*b)
a1=''.join(a)
print(int(a1))
``` | instruction | 0 | 44,035 | 20 | 88,070 |
Yes | output | 1 | 44,035 | 20 | 88,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it.
Submitted Solution:
```
for i in range(int(input())):
n = int(input())
p1 = (n+3)//4
p2 = n - p1
s = ''
for i in range(p2):
s+='9'
for i in range(p1):
s+='8'
print(int(s))
``` | instruction | 0 | 44,036 | 20 | 88,072 |
Yes | output | 1 | 44,036 | 20 | 88,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it.
Submitted Solution:
```
import math
t = int(input())
for _ in range(t):
n = int(input())
c = math.ceil(n / 4)
print("9" * (n - c) + "8" * c)
``` | instruction | 0 | 44,037 | 20 | 88,074 |
Yes | output | 1 | 44,037 | 20 | 88,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it.
Submitted Solution:
```
def solve(n):
k = n // 5 + 1
return "9" * (n - k) + "8" * k
def main():
t = int(input())
for i in range(t):
n = int(input())
print(solve(n))
main()
``` | instruction | 0 | 44,038 | 20 | 88,076 |
No | output | 1 | 44,038 | 20 | 88,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it.
Submitted Solution:
```
t = int(input())
for _ in range (t):
n = int(input())
toDelete,rem = divmod (n,4)
if rem == 0:
s = "9"*(n-toDelete)
else:
s = "9"*(n-toDelete-1)
s += "8"
print (s)
``` | instruction | 0 | 44,039 | 20 | 88,078 |
No | output | 1 | 44,039 | 20 | 88,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it.
Submitted Solution:
```
t= int(input())
ans=[]
for i in range(t):
n= int(input())
if n<=3:
x=1
else:
x=(n+1)//4
line=""
for i in range(n):
if i< n-x:
line+='9'
else:
line+='8'
ans.append(line)
for i in ans:
print(i)
``` | instruction | 0 | 44,040 | 20 | 88,080 |
No | output | 1 | 44,040 | 20 | 88,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Captain Flint and his crew keep heading to a savage shore of Byteland for several months already, drinking rum and telling stories. In such moments uncle Bogdan often remembers his nephew Denis. Today, he has told a story about how Denis helped him to come up with an interesting problem and asked the crew to solve it.
In the beginning, uncle Bogdan wrote on a board a positive integer x consisting of n digits. After that, he wiped out x and wrote integer k instead, which was the concatenation of binary representations of digits x consists of (without leading zeroes). For example, let x = 729, then k = 111101001 (since 7 = 111, 2 = 10, 9 = 1001).
After some time, uncle Bogdan understood that he doesn't know what to do with k and asked Denis to help. Denis decided to wipe last n digits of k and named the new number as r.
As a result, Denis proposed to find such integer x of length n that r (as number) is maximum possible. If there are multiple valid x then Denis is interested in the minimum one.
All crew members, including captain Flint himself, easily solved the task. All, except cabin boy Kostya, who was too drunk to think straight. But what about you?
Note: in this task, we compare integers (x or k) as numbers (despite what representations they are written in), so 729 < 1999 or 111 < 1000.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per test case. The one and only line of each test case contains the single integer n (1 ≤ n ≤ 10^5) — the length of the integer x you need to find.
It's guaranteed that the sum of n from all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the minimum integer x of length n such that obtained by Denis number r is maximum possible.
Example
Input
2
1
3
Output
8
998
Note
In the second test case (with n = 3), if uncle Bogdan had x = 998 then k = 100110011000. Denis (by wiping last n = 3 digits) will obtain r = 100110011.
It can be proved that the 100110011 is the maximum possible r Denis can obtain and 998 is the minimum x to obtain it.
Submitted Solution:
```
from sys import stdin
def r(): return stdin.readline().strip()
def r_t(tp): return map(tp, r().strip().split())
def r_a(tp): return list(r_t(tp))
def main():
c = int(r())
for _ in range(c):
n = int(r())
print("9"*(n-1) + str(8))
main()
``` | instruction | 0 | 44,041 | 20 | 88,082 |
No | output | 1 | 44,041 | 20 | 88,083 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z | instruction | 0 | 44,269 | 20 | 88,538 |
Tags: bitmasks, combinatorics, implementation, strings
Correct Solution:
```
mod=pow(10,9)+7
ans=1
d={}
string="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_"
for i in range(64):
for j in range(64):
if i&j in d:
d[i&j]+=1
else:
d[i&j]=1
s=input()
for i in s:
x=string.index(i)
ans=(((ans%mod)*(d[x]%mod))%mod)
print(ans)
``` | output | 1 | 44,269 | 20 | 88,539 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z | instruction | 0 | 44,270 | 20 | 88,540 |
Tags: bitmasks, combinatorics, implementation, strings
Correct Solution:
```
import sys
import bisect
try:
fin = open('in')
except:
fin = sys.stdin
input = lambda: fin.readline().strip()
s = input()
r = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'
t = sum(6 - bin(r.index(u)).count('1') for u in s)
ans = 1
mod = 10 ** 9 + 7
a = 3
while t:
if t & 1: ans = ans * a % mod
a = a * a % mod
t >>= 1
print (ans)
``` | output | 1 | 44,270 | 20 | 88,541 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z | instruction | 0 | 44,271 | 20 | 88,542 |
Tags: bitmasks, combinatorics, implementation, strings
Correct Solution:
```
import string
MOD = 1000000007
s = input()
convertion = string.digits + string.ascii_uppercase + string.ascii_lowercase + "-_"
cnt = [0]*64
for val in range(64):
for x in range(64):
for y in range(64):
if (x & y) == val:
cnt[val] += 1
ans = 1
for c in s:
ans *= cnt[convertion.find(c)]
ans %= MOD
print(ans)
``` | output | 1 | 44,271 | 20 | 88,543 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z | instruction | 0 | 44,272 | 20 | 88,544 |
Tags: bitmasks, combinatorics, implementation, strings
Correct Solution:
```
mod = 1000000007
resp = 1
def between(c, l, r):
return ord(c) >= ord(l) and ord(c) <= ord(r)
s = input()
for i in s:
if(between(i, '0', '9')):
i = ord(i) - ord('0')
elif(between(i, 'A', 'Z')):
i = ord(i) - ord('A') + 10
elif(between(i, 'a', 'z')):
i = ord(i) - ord('a') + 36
elif( i == '-'):
i = 62
else:
i = 63
for j in range(6):
if((i >> j) & 1 == 0):
resp = (3 * resp) % mod
print(resp)
``` | output | 1 | 44,272 | 20 | 88,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z | instruction | 0 | 44,273 | 20 | 88,546 |
Tags: bitmasks, combinatorics, implementation, strings
Correct Solution:
```
MOD = 1000000007
def main():
opts = [0] * 64
for i in range(64):
for j in range(64):
opts[i & j] += 1
s = input()
n = len(s)
ans = 1
for c in s:
if '0' <= c <= '9':
ans *= opts[ord(c) - ord('0')]
ans %= MOD
elif 'A' <= c <= 'Z':
ans *= opts[ord(c) - ord('A') + 10]
ans %= MOD
elif 'a' <= c <= 'z':
ans *= opts[ord(c) - ord('a') + 36]
ans %= MOD
elif c == '-':
ans *= opts[62]
ans %= MOD
else:
ans *= opts[63]
ans %= MOD
print(ans)
main()
``` | output | 1 | 44,273 | 20 | 88,547 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z | instruction | 0 | 44,274 | 20 | 88,548 |
Tags: bitmasks, combinatorics, implementation, strings
Correct Solution:
```
def rev(c):
if c.isdigit():
return ord(c) - ord('0')
elif c.isupper():
return 10 + ord(c) - ord('A')
elif c.islower():
return 36 + ord(c) - ord('a')
elif c == '-':
return 62
else:
return 63
counter = [0] * 64
for i in range(64):
for j in range(64):
counter[i & j] += 1
ans = 1
mod = int(1e9+7)
for s in input():
ans *= counter[rev(s)]
ans %= mod
print(ans)
``` | output | 1 | 44,274 | 20 | 88,549 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z | instruction | 0 | 44,275 | 20 | 88,550 |
Tags: bitmasks, combinatorics, implementation, strings
Correct Solution:
```
from math import factorial
b = [0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6]
d = {'N': 23, '9': 9, 'g': 42, '3': 3, '4': 4, 'Q': 26, 'K': 20, 'S': 28, 'A': 10, 'x': 59, 'B': 11, 'I': 18, 'n': 49, '7': 7, '-': 62, 'J': 19, 'm': 48, '5': 5, 'O': 24, 'L': 21, 'u': 56, 'r': 53, 'Z': 35, 'M': 22, 'j': 45, 'v': 57, 'q': 52, 'X': 33, 't': 55, 'a': 36, 's': 54, 'z': 61, 'Y': 34, 'd': 39, 'p': 51, 'o': 50, 'f': 41, 'P': 25, 'V': 31, '_': 63, 'w': 58, 'C': 12, 'R': 27, 'b': 37, 'E': 14, '0': 0, 'G': 16, 'k': 46, 'l': 47, 'D': 13, 'W': 32, 'T': 29, '8': 8, 'U': 30, 'F': 15, '2': 2, 'c': 38, 'h': 43, 'y': 60, 'i': 44, 'e': 40, '6': 6, 'H': 17, '1': 1}
MOD = 1e9 + 7
max_dig = 6
ans = 1
s = input()
for c in s:
nul_num = max_dig - b[d[c]]
ans *= 3**nul_num
ans %= MOD
print(int(ans))
``` | output | 1 | 44,275 | 20 | 88,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z
Submitted Solution:
```
ans=1
MOD=int(1e9+7)
cnt=[0]*64
for i in range(64):
for j in range(64):
cnt[i&j]+=1
s=input()
for i in s:
if i>='0' and i<='9':
ans*=cnt[ord(i)-ord('0')]
elif i>='A' and i<='Z':
ans*=cnt[ord(i)-ord('A')+10]
elif i>='a' and i<='z':
ans*=cnt[ord(i)-ord('a')+36]
elif i=='-':
ans*=cnt[62]
ans%=MOD
print(ans)
``` | instruction | 0 | 44,277 | 20 | 88,554 |
Yes | output | 1 | 44,277 | 20 | 88,555 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z
Submitted Solution:
```
# def next_row(prev_row):
# row = [prev_row[0]] * (len(prev_row) + 1)
# for idx in range(len(prev_row) - 1):
# row[idx + 1] = (prev_row[idx] + prev_row[idx + 1]) % 1000000007
# return row
#
#
# def binomial(n, k, cache=None):
# """
# 0 1
# 1 1 1
# 2 1 2 1
# 3 1 3 3 1
# 4 1 4 6 4 1
# """
# if k == 0 or k == n:
# return 1
# if k == 1 or k == n - 1:
# return n
#
# cache = cache or [[1]]
#
# while len(cache) <= n:
# cache.append(next_row(cache[-1]))
#
# return cache[n][k]
# c = []
# for n in range(150):
# for k in range(n + 1):
# print('n={n}, k={k} -> {b}'.format(n=n, k=k, b=binomial(n, k, c)))
s = input().strip()
m = {}
for i in range(10):
m[str(i)] = i
for i in range(ord('Z') - ord('A') + 1):
m[chr(ord('A') + i)] = 10 + i
for i in range(ord('z') - ord('a') + 1):
m[chr(ord('a') + i)] = 36 + i
m['-'] = 62
m['_'] = 63
zero_bits = 0
for c in s:
n = m[c]
for i in range(6):
zero_bits += int(not (n & 1))
n >>= 1
res = 1
for z in range(zero_bits):
res = res*3 % 1000000007
# for zero_bits in range(5):
# res = 0
# for z in range(zero_bits + 1):
# left_power = binomial(zero_bits, z)
# for zz in range(zero_bits - z + 1):
# right_power = binomial(zero_bits - z, zz)
# res = (res + left_power*right_power) % 1000000007
print(res)
``` | instruction | 0 | 44,278 | 20 | 88,556 |
Yes | output | 1 | 44,278 | 20 | 88,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z
Submitted Solution:
```
mod=pow(10,9)+7
ans=1
d={}
string="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_"
for i in range(64):
for j in range(64):
if string[i&j] in d:
d[string[i&j]]+=1
else:
d[string[i&j]]=1
s=input()
for i in s:
ans=(((ans%mod)*(d[i]%mod))%mod)
print(ans)
``` | instruction | 0 | 44,279 | 20 | 88,558 |
Yes | output | 1 | 44,279 | 20 | 88,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z
Submitted Solution:
```
import sys
read = lambda: sys.stdin.readline().strip()
readi = lambda: map(int, read().split())
from collections import *
import string
mapping = dict()
for key in string.digits:
mapping[key] = int(key)
start = 10
for key in string.ascii_uppercase:
mapping[key] = start
start += 1
for key in string.ascii_lowercase:
mapping[key] = start
start += 1
mapping['-'] = 62
mapping['_'] = 63
## Code starts here
def getCount(num):
count = 0
num = ~num
for i in range(6):
if num & 1 == 1:
count += 1
num = num >> 1
return count
for key in mapping.keys():
mapping[key] = getCount(mapping[key])
s = read()
ans = 1
mod = 10**9 + 7
for key in s:
# print(key, mapping[key])
ans = (ans * 3**mapping[key]) % mod
print(ans)
``` | instruction | 0 | 44,280 | 20 | 88,560 |
Yes | output | 1 | 44,280 | 20 | 88,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z
Submitted Solution:
```
alth = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
s = input()
ai = [729,243,243,81,243,81,81,27,243,81,81,27,81,27,27,9,243,81,81,27,81,27,27,9,81,27,27,9,27,9,9,3,243,81,81,27,81,27,27,9,81,27,27,9,27,9,9,3,81,27,27,9,27,9,9,3,27,9,9,3,9,3,3,1]
ans = 1
for i in s:
ans *= ai[alth.find(i)]
ans %= 1000000007
print(ans)
``` | instruction | 0 | 44,281 | 20 | 88,562 |
No | output | 1 | 44,281 | 20 | 88,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z
Submitted Solution:
```
mod=pow(10,9)+7
ans=1
d={}
string="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_"
for i in range(64):
for j in range(64):
if string[i&j] in d:
d[string[i&j]]+=1
else:
d[string[i&j]]=1
s=input()
print(d)
for i in s:
ans=(((ans%mod)*(d[i]%mod))%mod)
print(ans)
``` | instruction | 0 | 44,282 | 20 | 88,564 |
No | output | 1 | 44,282 | 20 | 88,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z
Submitted Solution:
```
zcount = [6, 5, 5, 4, 5, 4, 4, 3, 5, 4, 4, 3, 4, 3, 3, 2, 5, 4, 4, 3, 4, 3, 3, 2, 4, 3, 3, 2, 3, 2, 2, 1, 5, 4, 4, 3, 4, 3, 3, 2, 4, 3, 3, 2, 3, 2, 2, 1, 4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0]
digits = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'
s = input()
c = 0
for i in s:
c += zcount[digits.index(i)]
# k = c // 19
# kk = c % 19
k = 1
for j in range(c):
k *= 3
if k >= 1000000009: k = k % 1000000009
print(k)
``` | instruction | 0 | 44,283 | 20 | 88,566 |
No | output | 1 | 44,283 | 20 | 88,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules:
* digits from '0' to '9' correspond to integers from 0 to 9;
* letters from 'A' to 'Z' correspond to integers from 10 to 35;
* letters from 'a' to 'z' correspond to integers from 36 to 61;
* letter '-' correspond to integer 62;
* letter '_' correspond to integer 63.
Input
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
Output
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.
Examples
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
Note
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions:
1. z&_ = 61&63 = 61 = z
2. _&z = 63&61 = 61 = z
3. z&z = 61&61 = 61 = z
Submitted Solution:
```
modulo = 1000000007
saida = 1
def between(c,l,r):
return ord(c) >= ord(l) and ord(c) <= ord(r)
entrada = input()
for elem in entrada:
if(between(elem,'0','9')):
elem = ord(elem) - ord('0')
elif(between(elem,'a','z')):
elem = ord(elem) - ord('a') + 36
elif(between(elem,'A','Z')):
elem = ord(elem) - ord('A') + 10
elif(between(elem,'0','9')):
elem = ord(elem) - ord('0')
elif(elem=='-'):
elem = 62
else:
elem = 63
for pos in range(6):
if (((elem>>pos) and 1) == 0):
saida = (saida * 3) % modulo
print (saida)
``` | instruction | 0 | 44,284 | 20 | 88,568 |
No | output | 1 | 44,284 | 20 | 88,569 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vladik and Chloe decided to determine who of them is better at math. Vladik claimed that for any positive integer n he can represent fraction <image> as a sum of three distinct positive fractions in form <image>.
Help Vladik with that, i.e for a given n find three distinct positive integers x, y and z such that <image>. Because Chloe can't check Vladik's answer if the numbers are large, he asks you to print numbers not exceeding 109.
If there is no such answer, print -1.
Input
The single line contains single integer n (1 ≤ n ≤ 104).
Output
If the answer exists, print 3 distinct numbers x, y and z (1 ≤ x, y, z ≤ 109, x ≠ y, x ≠ z, y ≠ z). Otherwise print -1.
If there are multiple answers, print any of them.
Examples
Input
3
Output
2 7 42
Input
7
Output
7 8 56 | instruction | 0 | 44,312 | 20 | 88,624 |
Tags: brute force, constructive algorithms, math, number theory
Correct Solution:
```
#!/usr/bin/python
from sys import argv, exit
def get_str():
return input()
def get_int():
return int(input())
def get_ints():
return [int(i) for i in input().split(' ')]
def prnt(*args):
if '-v' in argv:
print(*args)
n = get_int()
if n == 1:
print('-1')
exit(0)
# Following the math in the tutorial
print('{} {} {}'.format(n, n+1, n*(n+1)))
``` | output | 1 | 44,312 | 20 | 88,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vladik and Chloe decided to determine who of them is better at math. Vladik claimed that for any positive integer n he can represent fraction <image> as a sum of three distinct positive fractions in form <image>.
Help Vladik with that, i.e for a given n find three distinct positive integers x, y and z such that <image>. Because Chloe can't check Vladik's answer if the numbers are large, he asks you to print numbers not exceeding 109.
If there is no such answer, print -1.
Input
The single line contains single integer n (1 ≤ n ≤ 104).
Output
If the answer exists, print 3 distinct numbers x, y and z (1 ≤ x, y, z ≤ 109, x ≠ y, x ≠ z, y ≠ z). Otherwise print -1.
If there are multiple answers, print any of them.
Examples
Input
3
Output
2 7 42
Input
7
Output
7 8 56
Submitted Solution:
```
n = int(input())
if n!=1:
print(str(n)+' '+str(n+1)+' '+str(n*(n+1)))
else:
print(-1)
``` | instruction | 0 | 44,313 | 20 | 88,626 |
Yes | output | 1 | 44,313 | 20 | 88,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vladik and Chloe decided to determine who of them is better at math. Vladik claimed that for any positive integer n he can represent fraction <image> as a sum of three distinct positive fractions in form <image>.
Help Vladik with that, i.e for a given n find three distinct positive integers x, y and z such that <image>. Because Chloe can't check Vladik's answer if the numbers are large, he asks you to print numbers not exceeding 109.
If there is no such answer, print -1.
Input
The single line contains single integer n (1 ≤ n ≤ 104).
Output
If the answer exists, print 3 distinct numbers x, y and z (1 ≤ x, y, z ≤ 109, x ≠ y, x ≠ z, y ≠ z). Otherwise print -1.
If there are multiple answers, print any of them.
Examples
Input
3
Output
2 7 42
Input
7
Output
7 8 56
Submitted Solution:
```
def ratios(n):
if n * (n + 1) <= 1000000000 and n != 1:
return n, n + 1, n * (n + 1)
return [-1]
print(*ratios(int(input())))
``` | instruction | 0 | 44,314 | 20 | 88,628 |
Yes | output | 1 | 44,314 | 20 | 88,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vladik and Chloe decided to determine who of them is better at math. Vladik claimed that for any positive integer n he can represent fraction <image> as a sum of three distinct positive fractions in form <image>.
Help Vladik with that, i.e for a given n find three distinct positive integers x, y and z such that <image>. Because Chloe can't check Vladik's answer if the numbers are large, he asks you to print numbers not exceeding 109.
If there is no such answer, print -1.
Input
The single line contains single integer n (1 ≤ n ≤ 104).
Output
If the answer exists, print 3 distinct numbers x, y and z (1 ≤ x, y, z ≤ 109, x ≠ y, x ≠ z, y ≠ z). Otherwise print -1.
If there are multiple answers, print any of them.
Examples
Input
3
Output
2 7 42
Input
7
Output
7 8 56
Submitted Solution:
```
n = int(input())
fll = 0
if n % 2 == 0:
print(-1, '\n')
fll = 1
if fll == 0:
for x in range(1, 1000 - 3):
fl = 0
for y in range(x + 1, 1000 - 2):
fl1 = 0
for z in range(y + 1, 1000):
if 2 / n == 1 / x + 1 / y + 1 / z:
print(x, ' ', y, ' ', z, '\n')
fl += 1
fl1 += 1
break
if fl1 == 1:
break
if fl == 1:
break
``` | instruction | 0 | 44,319 | 20 | 88,638 |
No | output | 1 | 44,319 | 20 | 88,639 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909 | instruction | 0 | 44,453 | 20 | 88,906 |
"Correct Solution:
```
n = int(input())
r=len(list(filter(lambda x: len(str(x))%2 != 0, range(1,n+1))))
print(r)
``` | output | 1 | 44,453 | 20 | 88,907 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909 | instruction | 0 | 44,454 | 20 | 88,908 |
"Correct Solution:
```
N=int(input())
ct=0
for i in range(1,N+1):
l=len(str(i))
if l%2==1:
ct+=1
print(ct)
``` | output | 1 | 44,454 | 20 | 88,909 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909 | instruction | 0 | 44,455 | 20 | 88,910 |
"Correct Solution:
```
n = int(input())
print(len(list(filter(lambda x: len(str(x))%2 == 1, range(1,n+1)))))
``` | output | 1 | 44,455 | 20 | 88,911 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909 | instruction | 0 | 44,456 | 20 | 88,912 |
"Correct Solution:
```
n=int(input())
cnt =0
for i in range(1,1+n):
if len(str(i)) % 2 == 1:
cnt += 1
print(cnt)
``` | output | 1 | 44,456 | 20 | 88,913 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909 | instruction | 0 | 44,457 | 20 | 88,914 |
"Correct Solution:
```
print(sum(len(str(i))%2 for i in range(1, int(input()) + 1)))
``` | output | 1 | 44,457 | 20 | 88,915 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909 | instruction | 0 | 44,458 | 20 | 88,916 |
"Correct Solution:
```
n=int(input(""))
list1=[i for i in range(1,n+1) if(len(str(i))%2!=0)]
print(len(list1))
``` | output | 1 | 44,458 | 20 | 88,917 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909 | instruction | 0 | 44,459 | 20 | 88,918 |
"Correct Solution:
```
a = 0
for i in range(1,int(input())+1):
if len(str(i))%2==1:
a += 1
print(a)
``` | output | 1 | 44,459 | 20 | 88,919 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909 | instruction | 0 | 44,460 | 20 | 88,920 |
"Correct Solution:
```
i = int(input())
c = 0
for l in range(1,i+1):
if (len(str(l)) % 2 == 1):
c += 1
print(c)
``` | output | 1 | 44,460 | 20 | 88,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909
Submitted Solution:
```
n=int(input())
c=0
for i in range(1,n+1):
if(len(str(i))%2==1):
c+=1
print(c)
``` | instruction | 0 | 44,461 | 20 | 88,922 |
Yes | output | 1 | 44,461 | 20 | 88,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909
Submitted Solution:
```
n=int(input())
c=0
for i in range(n):
if len(str(i+1))%2!=0:
c+=1
print(c)
``` | instruction | 0 | 44,462 | 20 | 88,924 |
Yes | output | 1 | 44,462 | 20 | 88,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909
Submitted Solution:
```
N = int(input())
c = 0
for i in range(1, N+1):
if len(str(i))%2 != 0:
c += 1
print(c)
``` | instruction | 0 | 44,463 | 20 | 88,926 |
Yes | output | 1 | 44,463 | 20 | 88,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909
Submitted Solution:
```
print(sum([len(str(n))%2 != 0 for n in range(1, 1+int(input()))]))
``` | instruction | 0 | 44,464 | 20 | 88,928 |
Yes | output | 1 | 44,464 | 20 | 88,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909
Submitted Solution:
```
a = input()
if len(a) ==6:
print(90909)
elif len(a) == 5:
print(90909-90000 +int(a)-9999)
elif len(a) == 4:
print(90909-90000)
elif len(a) ==3:
print(90909-90000-900b+int(a)-99)
elif len(a) ==2:
print(90909-90000-900)
else:
print(int(a))
``` | instruction | 0 | 44,465 | 20 | 88,930 |
No | output | 1 | 44,465 | 20 | 88,931 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.