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.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Unfortunately, not all numbers are lucky. Petya calls a number nearly lucky if the number of lucky digits in it is a lucky number. He wonders whether number n is a nearly lucky number.
Input
The only line contains an integer n (1 ≤ n ≤ 1018).
Please do not use the %lld specificator to read or write 64-bit numbers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Output
Print on the single line "YES" if n is a nearly lucky number. Otherwise, print "NO" (without the quotes).
Examples
Input
40047
Output
NO
Input
7747774
Output
YES
Input
1000000000000000000
Output
NO
Note
In the first sample there are 3 lucky digits (first one and last two), so the answer is "NO".
In the second sample there are 7 lucky digits, 7 is lucky number, so the answer is "YES".
In the third sample there are no lucky digits, so the answer is "NO".
Submitted Solution:
```
l = list(input())
a = 0
l = [int(l[i]) for i in range(len(l))]
for i in range(len(l)):
if l[i] == 4 or l[i] == 7:
a = a+1
if a == 4 or a == 7:
print("YES")
else:
print("NO")
``` | instruction | 0 | 42,956 | 20 | 85,912 |
Yes | output | 1 | 42,956 | 20 | 85,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Unfortunately, not all numbers are lucky. Petya calls a number nearly lucky if the number of lucky digits in it is a lucky number. He wonders whether number n is a nearly lucky number.
Input
The only line contains an integer n (1 ≤ n ≤ 1018).
Please do not use the %lld specificator to read or write 64-bit numbers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Output
Print on the single line "YES" if n is a nearly lucky number. Otherwise, print "NO" (without the quotes).
Examples
Input
40047
Output
NO
Input
7747774
Output
YES
Input
1000000000000000000
Output
NO
Note
In the first sample there are 3 lucky digits (first one and last two), so the answer is "NO".
In the second sample there are 7 lucky digits, 7 is lucky number, so the answer is "YES".
In the third sample there are no lucky digits, so the answer is "NO".
Submitted Solution:
```
n = list(map(int, input()))
c = 0
for i in n:
if i == 4 or i == 7:
c += 1
if len(n) == c:
print("YES")
else:
print("NO")
``` | instruction | 0 | 42,957 | 20 | 85,914 |
No | output | 1 | 42,957 | 20 | 85,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Unfortunately, not all numbers are lucky. Petya calls a number nearly lucky if the number of lucky digits in it is a lucky number. He wonders whether number n is a nearly lucky number.
Input
The only line contains an integer n (1 ≤ n ≤ 1018).
Please do not use the %lld specificator to read or write 64-bit numbers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Output
Print on the single line "YES" if n is a nearly lucky number. Otherwise, print "NO" (without the quotes).
Examples
Input
40047
Output
NO
Input
7747774
Output
YES
Input
1000000000000000000
Output
NO
Note
In the first sample there are 3 lucky digits (first one and last two), so the answer is "NO".
In the second sample there are 7 lucky digits, 7 is lucky number, so the answer is "YES".
In the third sample there are no lucky digits, so the answer is "NO".
Submitted Solution:
```
a=int(input())
b=str(a)
count=0
for i in range(len(b)):
if b[i]=='4' or b[i]=='7':
count=count+1
if count==len(b):
print("YES")
else:
print("NO")
``` | instruction | 0 | 42,958 | 20 | 85,916 |
No | output | 1 | 42,958 | 20 | 85,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Unfortunately, not all numbers are lucky. Petya calls a number nearly lucky if the number of lucky digits in it is a lucky number. He wonders whether number n is a nearly lucky number.
Input
The only line contains an integer n (1 ≤ n ≤ 1018).
Please do not use the %lld specificator to read or write 64-bit numbers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Output
Print on the single line "YES" if n is a nearly lucky number. Otherwise, print "NO" (without the quotes).
Examples
Input
40047
Output
NO
Input
7747774
Output
YES
Input
1000000000000000000
Output
NO
Note
In the first sample there are 3 lucky digits (first one and last two), so the answer is "NO".
In the second sample there are 7 lucky digits, 7 is lucky number, so the answer is "YES".
In the third sample there are no lucky digits, so the answer is "NO".
Submitted Solution:
```
s = input()
print("YES" if s.count('7') + s.count('4') == 7 or 4 else "NO")
``` | instruction | 0 | 42,959 | 20 | 85,918 |
No | output | 1 | 42,959 | 20 | 85,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Unfortunately, not all numbers are lucky. Petya calls a number nearly lucky if the number of lucky digits in it is a lucky number. He wonders whether number n is a nearly lucky number.
Input
The only line contains an integer n (1 ≤ n ≤ 1018).
Please do not use the %lld specificator to read or write 64-bit numbers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Output
Print on the single line "YES" if n is a nearly lucky number. Otherwise, print "NO" (without the quotes).
Examples
Input
40047
Output
NO
Input
7747774
Output
YES
Input
1000000000000000000
Output
NO
Note
In the first sample there are 3 lucky digits (first one and last two), so the answer is "NO".
In the second sample there are 7 lucky digits, 7 is lucky number, so the answer is "YES".
In the third sample there are no lucky digits, so the answer is "NO".
Submitted Solution:
```
n=int(input())
n=str(n)
llist=list(n)
# print(llist)
x=0
final=0
for i in llist:
if llist[x] == '4' :
x+=1
elif llist[x] == '7':
x+=1
else:
final+=1
break
if final > 0:
print('NO')
else:
print('YES')
``` | instruction | 0 | 42,960 | 20 | 85,920 |
No | output | 1 | 42,960 | 20 | 85,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d. | instruction | 0 | 43,188 | 20 | 86,376 |
Tags: greedy
Correct Solution:
```
from sys import stdin, exit
from bisect import bisect_left as bl, bisect_right as br
from itertools import accumulate
input = lambda: stdin.readline()[:-1]
intput = lambda: int(input())
sinput = lambda: input().split()
intsput = lambda: map(int, sinput())
def dprint(*args, **kwargs):
if debugging:
print(*args, **kwargs)
debugging = 1
# Code
t = intput()
for _ in range(t):
n = intput()
b = list(map(int, input()))
a = [2 - b[0]]
if a[0] == 2:
a[0] -= 1
for i in range(1, n):
prev = a[i - 1] + b[i - 1]
if prev == 2:
target = 1
else:
if b[i] == 1:
target = 2
else:
if prev == 1:
target = 0
else:
target = 1
a.append(target - b[i])
print(''.join(map(str, a)))
``` | output | 1 | 43,188 | 20 | 86,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d. | instruction | 0 | 43,189 | 20 | 86,378 |
Tags: greedy
Correct Solution:
```
#!/bin/python3
import math
import os
import random
import re
import sys
def find_mystery_binary(b, sz):
a = [1] * sz
last = 0
for i in range(sz):
if last == int(a[i]) + int(b[i]):
a[i] = str(int(a[i]) - 1)
last = int(a[i]) + int(b[i])
str_a = [str(ele) for ele in a]
print("".join(str_a))
if __name__ == '__main__':
n = int(input())
for i in range(n):
sz = int(input())
b = input()
find_mystery_binary(b, sz)
``` | output | 1 | 43,189 | 20 | 86,379 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d. | instruction | 0 | 43,190 | 20 | 86,380 |
Tags: greedy
Correct Solution:
```
from collections import Counter
t = int(input())
for _ in range(t):
n = int(input())
b = input()
s = "1"
prev = int(b[0]) + 1
for i in range(1, len(b)):
if(prev == 2):
if(b[i] == "1"):
s += "0"
prev = 1
else:
s += "1"
prev = 1
elif(prev == 1):
if(b[i] == "1"):
s += "1"
prev = 2
else:
s += "0"
prev = 0
else:
if(b[i] == "1"):
s += "1"
prev = 2
else:
s += "1"
prev = 1
print(s)
``` | output | 1 | 43,190 | 20 | 86,381 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d. | instruction | 0 | 43,191 | 20 | 86,382 |
Tags: greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
b = input()
a = "1"
for i in range(1,n):
if (int(b[i])+ 1) != (int(a[i-1])+ int(b[i-1])):
a+="1"
else:
a+="0"
print(a)
``` | output | 1 | 43,191 | 20 | 86,383 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d. | instruction | 0 | 43,192 | 20 | 86,384 |
Tags: greedy
Correct Solution:
```
# import sys
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
# import math
def solve(n, b):
# print(n, b)
a = [1]*n
d = [0]*n
d[0] = a[0] + b[0]
for i in range(1, n):
# print(a, d)
if b[i] + 1 != d[i-1]:
a[i] = 1
d[i] = b[i] + a[i]
else:
a[i] = 0
d[i] = b[i] + a[i]
return "".join(map(str, a))
if __name__ == "__main__":
t = int(input())
for _ in range(t):
n = int(input())
b = list(map(int, input()))
print(solve(n, b))
``` | output | 1 | 43,192 | 20 | 86,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d. | instruction | 0 | 43,193 | 20 | 86,386 |
Tags: greedy
Correct Solution:
```
def ass(a, b):
if a != b: print(f"Assertion error:\n{a}\n{b}")
def intline():
return [int(item) for item in input().split()]
def line():
return [item for item in input().split()]
def dump(lst):
for i, item in enumerate(lst): print(i, item)
def binsearch(arr, a, b):
m = (a + b) // 2
if a >= b: return a - 1 if arr[a] == 0 else a
return binsearch(arr, a, m - 1) if arr[m] == 0 else binsearch(arr, m + 1, b)
def f(b):
arr = [int(ch) for ch in b]
res = [1 for ch in b]
for i,ch in enumerate(arr):
if i == 0:
res[i]=1+arr[i]
else:
key = [arr[i], res[i - 1]]
if key==[0,0]: res[i]=1
if key==[0,1]: res[i]=0
if key==[0,2]: res[i]=1
if key==[1,0]: res[i]=2
if key==[1,1]: res[i]=2
if key==[1,2]: res[i]=1
return ''.join([str(res[i]-arr[i]) for i,ch in enumerate(res)])
# ass(f('0'),'1')
# ass(f('011'),'110')
# ass(f('110'),'100')
# ass(f('111000'),'101101')
# ass(f('001011'),'101110')
t = intline()[0]
for i in range(t):
n = intline()[0]
b = line()[0]
print(f(b))
``` | output | 1 | 43,193 | 20 | 86,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d. | instruction | 0 | 43,194 | 20 | 86,388 |
Tags: greedy
Correct Solution:
```
t = int(input())
for _ in range(0,t):
n = int(input())
b = list(input())
b = [int(i) for i in b]
a = [0 for i in b]
a[0]=1
for i in range(1,n):
if b[i]+1 != a[i-1]+b[i-1] :
a[i]=1
for i in a:
print(i,end="")
print("")
``` | output | 1 | 43,194 | 20 | 86,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d. | instruction | 0 | 43,195 | 20 | 86,390 |
Tags: greedy
Correct Solution:
```
for p in range(int(input())):
n=int(input())
b=input()
b_list=[int(x) for x in str(b)]
a=[1]
s=[b_list[0]+1]
for i in range(1,n):
q=b_list[i]+1
s.append(q)
if s[i]==s[i-1]:
a.append(0)
s[i]=b_list[i]
else:
a.append(1)
s[i]=b_list[i]+1
listToStr = ''.join([str(elem) for elem in a])
print(listToStr)
``` | output | 1 | 43,195 | 20 | 86,391 |
Provide tags and a correct Python 2 solution for this coding contest problem.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d. | instruction | 0 | 43,196 | 20 | 86,392 |
Tags: greedy
Correct Solution:
```
""" Python 3 compatibility tools. """
from __future__ import division, print_function
import itertools
import sys
import os
from io import BytesIO
from atexit import register
if sys.version_info[0] < 3:
input = raw_input
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
def gcd(x, y):
""" greatest common divisor of x and y """
while y:
x, y = y, x % y
return x
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
# import sys
# input=sys.stdin.readline
cases = int(input())
for _ in range(cases):
n = int(input())
b = input()
res = []
prev = None
for i in b:
if prev == int(i) + 1:
res.append("0")
prev = int(i)
else:
res.append("1")
prev = int(i) + 1
print("".join(res))
``` | output | 1 | 43,196 | 20 | 86,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d.
Submitted Solution:
```
t = int(input())
while t > 0:
t -= 1
n = int(input())
b = []
for c in input():
b.append(c)
b[0] = chr(ord(b[0]) + 1)
print(1, end='')
for i in range(1, len(b)):
if chr(ord(b[i]) + 1) != b[i - 1]:
b[i] = chr(ord(b[i]) + 1)
print(1, end='')
else:
print(0, end='')
print()
``` | instruction | 0 | 43,197 | 20 | 86,394 |
Yes | output | 1 | 43,197 | 20 | 86,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d.
Submitted Solution:
```
t = input()
t = int(t)
for i in range(t):
n = input()
n = int(n)
b = input()
a = ""
# print(int(b))
for j in range(n):
if j == 0:
a += '1'
else:
test = int(b[j]) + 1
if test == k:
a += '0'
else:
a += '1'
k = int(a[j]) + int(b[j])
print(a)
``` | instruction | 0 | 43,198 | 20 | 86,396 |
Yes | output | 1 | 43,198 | 20 | 86,397 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d.
Submitted Solution:
```
from __future__ import division, print_function
from itertools import permutations
import threading,bisect,math,heapq,sys
from collections import deque
# threading.stack_size(2**27)
# sys.setrecursionlimit(10**4)
from sys import stdin, stdout
i_m=9223372036854775807
def cin():
return map(int,sin().split())
def ain(): #takes array as input
return list(map(int,sin().split()))
def sin():
return input()
def inin():
return int(input())
prime=[]
def dfs(n,d,v):
v[n]=1
x=d[n]
for i in x:
if i not in v:
dfs(i,d,v)
return p
def block(x):
v = []
while (x > 0):
v.append(int(x % 2))
x = int(x / 2)
ans=[]
for i in range(0, len(v)):
if (v[i] == 1):
ans.append(2**i)
return ans
"""**************************MAIN*****************************"""
def main():
t=inin()
for _ in range(t):
n=inin()
s=sin()
s=list(s)
for i in range(n):
s[i]=int(s[i])
if s[0]==1:
a=[2]
b=[2-s[0]]
else:
a=[1]
b=[1]
for i in range(1,n):
p=q=0
for j in range(3):
if j!=a[-1] and (j-s[i]==1 or j-s[i]==0):
p=j-s[i]
q=j
b.append(p)
a.append(q)
print(*b,sep="")
"""***********************************************"""
def intersection(l,r,ll,rr):
# print(l,r,ll,rr)
if (ll > r or rr < l):
return 0
else:
l = max(l, ll)
r = min(r, rr)
return max(0,r-l+1)
######## Python 2 and 3 footer by Pajenegod and c1729
fac=[]
def fact(n,mod):
global fac
fac.append(1)
for i in range(1,n+1):
fac.append((fac[i-1]*i)%mod)
f=fac[:]
return f
def nCr(n,r,mod):
global fac
x=fac[n]
y=fac[n-r]
z=fac[r]
x=moddiv(x,y,mod)
return moddiv(x,z,mod)
def moddiv(m,n,p):
x=pow(n,p-2,p)
return (m*x)%p
def GCD(x, y):
x=abs(x)
y=abs(y)
if(min(x,y)==0):
return max(x,y)
while(y):
x, y = y, x % y
return x
def Divisors(n) :
l = []
ll=[]
for i in range(1, int(math.sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
l.append(i)
else :
l.append(i)
ll.append(n//i)
l.extend(ll[::-1])
return l
def SieveOfEratosthenes(n):
global prime
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
f=[]
for p in range(2, n):
if prime[p]:
f.append(p)
return prime
def primeFactors(n):
a=[]
while n % 2 == 0:
a.append(2)
n = n // 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
a.append(i)
n = n // i
if n > 2:
a.append(n)
return a
"""*******************************************************"""
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s:self.buffer.write(s.encode('ascii'))
self.read = lambda:self.buffer.read().decode('ascii')
self.readline = lambda:self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# Cout implemented in Python
class ostream:
def __lshift__(self,a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = '\n'
# Read all remaining integers in stdin, type is given by optional argument, this is fast
def readnumbers(zero = 0):
conv = ord if py2 else lambda x:x
A = []; numb = zero; sign = 1; i = 0; s = sys.stdin.buffer.read()
try:
while True:
if s[i] >= b'R' [0]:
numb = 10 * numb + conv(s[i]) - 48
elif s[i] == b'-' [0]: sign = -1
elif s[i] != b'\r' [0]:
A.append(sign*numb)
numb = zero; sign = 1
i += 1
except:pass
if s and s[-1] >= b'R' [0]:
A.append(sign*numb)
return A
# threading.Thread(target=main).start()
if __name__== "__main__":
main()
``` | instruction | 0 | 43,199 | 20 | 86,398 |
Yes | output | 1 | 43,199 | 20 | 86,399 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d.
Submitted Solution:
```
t = int(input())
for q in range(t):
n = int(input())
b = input()
a = "1"
t1 = 0
for z in range(1,n):
t1 = int(a[z-1])+int(b[z-1])
if (t1==2):
if b[z]=="1":
a = a + "0"
if b[z]=="0":
a = a + "1"
if (t1==1):
if b[z]=="1":
a = a + "1"
if b[z]=="0":
a = a + "0"
if (t1==0):
a = a + "1"
print(a)
``` | instruction | 0 | 43,200 | 20 | 86,400 |
Yes | output | 1 | 43,200 | 20 | 86,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
b=input()
d=[]
for i in range(n):
if(i%2==0):
d.append('2')
else:
d.append('1')
dd=""
for j in range(n):
x=(int(d[j])-int(b[j]))
dd+=chr(x)
print(dd)
``` | instruction | 0 | 43,201 | 20 | 86,402 |
No | output | 1 | 43,201 | 20 | 86,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d.
Submitted Solution:
```
#!/usr/bin/env python3
import sys, getpass
import math, random
import functools, itertools, collections, heapq, bisect
from collections import Counter, defaultdict, deque
input = sys.stdin.readline # to read input quickly
# available on Google, AtCoder Python3, not available on Codeforces
# import numpy as np
# import scipy
M9 = 10**9 + 7 # 998244353
# d4 = [(1,0),(0,1),(-1,0),(0,-1)]
# d8 = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
# d6 = [(2,0),(1,1),(-1,1),(-2,0),(-1,-1),(1,-1)] # hexagonal layout
MAXINT = sys.maxsize
# if testing locally, print to terminal with a different color
OFFLINE_TEST = getpass.getuser() == "hkmac"
# OFFLINE_TEST = False # codechef does not allow getpass
def log(*args):
if OFFLINE_TEST:
print('\033[36m', *args, '\033[0m', file=sys.stderr)
def solve(*args):
# screen input
if OFFLINE_TEST:
log("----- solving ------")
log(*args)
log("----- ------- ------")
return solve_(*args)
def read_matrix(rows):
return [list(map(int,input().split())) for _ in range(rows)]
def read_strings(rows):
return [input().strip() for _ in range(rows)]
# ---------------------------- template ends here ----------------------------
def solve_(srr):
# your solution here
if len(srr) == 1:
return "1"
srr = [int(x) for x in srr]
# log(srr)
if srr[0] == 1: # given 1xx
# log("21212")
# 212121
res = []
for i,x in enumerate(srr):
if i%2 == 0: # force 2 or 0
if x == 1:
res.append(1)
else:
res.append(0)
else: # force 1
if x == 1:
res.append(0)
else:
res.append(1)
else: # given 01
if srr[1] == 1:
# 121212
res = []
for i,x in enumerate(srr):
if i%2 == 0: # force 1
if x == 1:
res.append(0)
else:
res.append(1)
else: # force 2 or 0
if x == 1:
res.append(1)
else:
res.append(0)
else: # given 00
# 102121
res = [1,0]
for i,x in enumerate(srr[2:], start=2):
if i%2 == 0: # force 2 or 0
if x == 1:
res.append(1)
else:
res.append(0)
else: # force 1
if x == 1:
res.append(0)
else:
res.append(1)
return "".join(str(x) for x in res)
# for case_num in [0]: # no loop over test case
# for case_num in range(100): # if the number of test cases is specified
for case_num in range(int(input())):
# read line as an integer
k = int(input())
# read line as a string
srr = input().strip()
# read one line and parse each word as a string
# lst = input().split()
# read one line and parse each word as an integer
# a,b,c = list(map(int,input().split()))
# lst = list(map(int,input().split()))
# read multiple rows
# mrr = read_matrix(k) # and return as a list of list of int
# arr = read_strings(k) # and return as a list of str
res = solve(srr) # include input here
# print result
# Google and Facebook - case number required
# print("Case #{}: {}".format(case_num+1, res))
# Other platforms - no case number required
print(res)
# print(len(res))
# print(*res) # print a list with elements
# for r in res: # print each list in a different line
# print(res)
# print(*res)
``` | instruction | 0 | 43,202 | 20 | 86,404 |
No | output | 1 | 43,202 | 20 | 86,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d.
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Jan 23 15:49:20 2021
@author: mite
"""
nbc = int(input())
for i in range(0,nbc):
n = int(input())
b = int(input(),2)
answer = "1"
s = (b >> n-1) + 1
for j in range(2,n+1):
cd = (b >> n-j) & 1
print("loop "+str(j)+" current number: "+str(b << n-j)+" current digit: "+str(cd)+" sum: "+str(s))
if s==2 and cd==1:
d = 0
elif s==1 and cd==0:
d = 0
else:
d = 1
answer += str(d)
s = d + cd
print(answer)
``` | instruction | 0 | 43,203 | 20 | 86,406 |
No | output | 1 | 43,203 | 20 | 86,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way:
* he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000;
* after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits).
Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer.
Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b.
The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1.
It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5.
Output
For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n.
Example
Input
5
1
0
3
011
3
110
6
111000
6
001011
Output
1
110
100
101101
101110
Note
In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result.
In the second test case, b = 011 so:
* if you choose a = 000, c will be equal to 011, so d = 01;
* if you choose a = 111, c will be equal to 122, so d = 12;
* if you choose a = 010, you'll get d = 021.
* If you select a = 110, you'll get d = 121.
We can show that answer a = 110 is optimal and d = 121 is maximum possible.
In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d.
In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d.
In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d.
Submitted Solution:
```
#import sys
#from sys import stdin,stdout
#input=sys.stdin.readline
#sys.setrecursionlimit(10**7)
#import math
#import random
#import heapq
#from collections import Counter
#from queue import PriorityQueue
#from functools import lru_cache,cmp_to_key
#@lru_cache(maxsize=None) #for optimizing the execution time of callable objects/functions(placed above callable functions)
def debug():
for i in range(10):
pass
def mmm(a,b,m):
res=0
a%=m
while(b):
if(b&1):
res=(res+a)%m
a=(2*a)%m
b>>=1
return res
def pw(a,b,c):
ans=1
a=a%c
if a==0:
return 0
while(b>0):
if(b&1):
ans=(ans*a)%c
b=b>>1
a=(a*a)%c
return ans
try:
for _ in range(int(input())):
n=int(input())
s=input()
ans="1"
tmp=""
if s[0]=="1":
tmp+="2"
else:
tmp+="1"
for i in range(1,n):
if tmp[i-1]=="2":
if s[i]=="1":
ans+="0"
tmp+="1"
else:
ans+="1"
tmp+="1"
elif tmp[i-1]=="1":
if s[i]=="1":
ans+="1"
tmp+="2"
else:
ans+="0"
tmp+="0"
else:
if s[i]=="1":
ans+="1"
tmp+="2"
else:
ans+="1"
tmp+="2"
print(ans)
except EOFError as e:
print(e)
``` | instruction | 0 | 43,204 | 20 | 86,408 |
No | output | 1 | 43,204 | 20 | 86,409 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all. | instruction | 0 | 43,444 | 20 | 86,888 |
Tags: dp, implementation, math
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sat Sep 17 19:15:41 2016
@author: bigu
"""
n,t = map(int, input().split(' '))
num = input()
num = ['0']+list(num)
stack = []
dot = num.index('.')
#print(dot)
for i,x in enumerate(num):
if i>dot and int(x) >= 5:
stack.append(i)
break
ind = len(num)-1
for i in range(t):
if len(stack) == 0 or stack[0] < dot:
break
ind = stack[0]
while True:
ind -= 1
if num[ind] == '.': ind -= 1
tmp = int(num[ind])+1
#print(ind, tmp)
if tmp<10:
num[ind]=str(tmp)
break
else:
num[ind]='0'
stack.pop()
if int(num[ind])>=5:
stack.append(ind)
num = num[:max(ind+1,dot)]
if num[0] == '0':
num = num[1:]
print(''.join(num))
# 12 5
# 872.04488525
``` | output | 1 | 43,444 | 20 | 86,889 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all. | instruction | 0 | 43,445 | 20 | 86,890 |
Tags: dp, implementation, math
Correct Solution:
```
n,t = list(map(int,input().split()))
s = list(input())
p = 0
index = n-1
for i in range(0,n):
if s[i] == '.':
p = i
if p == 0 :
continue
if s[i] >= '5' :
index = i
break
while s[index] >= '5' and index > p and t>0 :
if s[index-1] == '.' :
index = index - 1
break
index = index - 1
s[index] = str(int(s[index]) + 1)
t = t - 1
flag = 0
# print(index,p)
if p == index :
flag = 1
index = index - 1
while index >=0 and flag != 0 :
if s[index] == '9' :
s[index] = '0'
flag = 1
else :
s[index] = str( int(s[index]) + 1)
flag = 0
index = index -1
index = p - 1
if flag != 0 :
print(1, end = "")
for i in range(0,index+1) :
print(s[i],end = "")
print("")
``` | output | 1 | 43,445 | 20 | 86,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all. | instruction | 0 | 43,446 | 20 | 86,892 |
Tags: dp, implementation, math
Correct Solution:
```
n, k = map(int, input().split())
s = list(input())
dot = s.index(".")
pos =-1
for i in range(dot+1, n):
if s[i] > "4":
pos = i
break
if pos < 0:
print("".join(s))
else:
for j in range(k):
if s[pos-1-j] != "4":
break
pos = pos-1-j
while pos >= 0 and (s[pos] == "9" or pos == dot):
pos -= 1
if pos < 0:
print("1", end = "")
print("0"*dot)
elif pos < dot:
print("".join(s[:pos]), end = "")
print(chr(ord(s[pos])+1), end = "")
print("0"*(dot-pos-1))
else:
print("".join(s[:pos]), end = "")
print(chr(ord(s[pos])+1))
``` | output | 1 | 43,446 | 20 | 86,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all. | instruction | 0 | 43,447 | 20 | 86,894 |
Tags: dp, implementation, math
Correct Solution:
```
n, t = map(int, input().split())
x = input()
i = x.find('.')
for j in range(i + 1, n):
if x[j] > '4':
for k in range(t):
j -= 1
if x[j] != '4': break
if j == i:
j -= 1
while j and x[j] == '9': j -= 1
x = x[:j] + str(int(x[j]) + 1) + '0' * (i - j - 1)
else:
x = x[:j] + str(int(x[j]) + 1)
break
print(x)
# Made By Mostafa_Khaled
``` | output | 1 | 43,447 | 20 | 86,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all. | instruction | 0 | 43,448 | 20 | 86,896 |
Tags: dp, implementation, math
Correct Solution:
```
n, t = map(int, input().split())
tmp = input()
s = []
for i in range(n):
s.append(tmp[i])
ind = n
perenos = 0
for i in range(n):
if (s[i] == '.'):
nach = i + 1
for i in range(nach, n):
if (int(s[i]) > 4):
ind = i
break
if (ind == n):
print(*s, sep="")
exit()
while (t > 0 and s[ind] != '.'):
if (int(s[ind]) > 3):
ind -= 1
perenos = 1
t -= 1
if (s[ind] == '9'):
t += 1
else:
s[ind] = str(int(s[ind]) + 1)
perenos = 0
break
if s[ind] == '.':
ind -= 1
while (s[ind] == '9'):
s[ind] = '0'
ind -= 1
if (ind < 0 and perenos != 0):
print(1, end="")
viv = 0
while (s[viv] != '.'):
print(s[viv], end="")
viv += 1
else:
s[ind] = str(int(s[ind]) + perenos)
viv = 0
while (s[viv] != '.'):
print(s[viv], end="")
viv += 1
else:
while (s[ind] == '9' or s[ind] == '.'):
if (s[ind] == '.'):
ind -= 1
continue
s[ind] = '0'
ind -= 1
s[ind] = str(int(s[ind]) + perenos)
for i in range(ind + 1):
print(s[i], end="")
``` | output | 1 | 43,448 | 20 | 86,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all. | instruction | 0 | 43,449 | 20 | 86,898 |
Tags: dp, implementation, math
Correct Solution:
```
def roundroot():
global root
i = len(root)-1
while i>=0:
root[i]+=1
if root[i] == 10 and i!=0:
root[i] = 0
i-=1
else:
break
def printA(a):
for i in a:
print(i,end='')
n,t = [int(i) for i in input().split()]
num = input()
for i in range(len(num)):
if num[i]=='.':
break
root = [int(j) for j in num[:i]]
dec = [int(j) for j in num[i+1:]]
n = len(dec)
#print(dec)
itrack = -1
for i in range(n):
if dec[i]>=5:
itrack = i
break
if itrack == -1:
itrack = n-1
while (itrack>=1 and t>0):
if dec[itrack] < 5:
break
j = itrack - 1
t-=1
while (j>=0):
dec[j]+=1
if dec[j]==10:
dec[j] = 0
j-=1
else:
break
if j==-1:
roundroot()
itrack = j
if (itrack>=0 and t>0 and dec[0]>=5):
roundroot()
printA(root)
else:
printA(root)
print('.',end='')
for i in range(itrack+1):
print(dec[i],end='')
``` | output | 1 | 43,449 | 20 | 86,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all. | instruction | 0 | 43,450 | 20 | 86,900 |
Tags: dp, implementation, math
Correct Solution:
```
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
int1 = lambda x: int(x) - 1
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: map(int,input().split())
alele = lambda: list(map(int, input().split()))
ilelec = lambda: map(int1,input().split())
alelec = lambda: list(map(int1, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
#MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
n,t = ilele()
num = input()
a,b= num.split('.')
Ans = [a]
Ans.append('.')
def fun():
x = ['0'] + [*a]
for i in range(len(x)-1,-1,-1):
if x[i] == '9':
x[i] = '0'
else:
x[i] = str(int(x[i]) + 1)
break
if x[0] == '0':
for i in range(1,len(x)):
print(x[i],end = '')
else:
print("".join(x))
for i in b:
Ans.append(i)
if int(i) >= 5:
#print(Ans)
if Ans[-1] == '.':
fun()
exit(0)
else:
while t > 0:
#print(Ans)
t -= 1
if Ans[-1] == '.':
fun()
exit(0)
if int(Ans[-1]) >= 5:
Ans.pop()
if Ans[-1] == '.':
fun()
exit(0)
else:
Ans[-1]= str(int(Ans[-1]) + 1)
else:
break
break
print("".join(Ans))
``` | output | 1 | 43,450 | 20 | 86,901 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all. | instruction | 0 | 43,451 | 20 | 86,902 |
Tags: dp, implementation, math
Correct Solution:
```
n, t = map(int, input().split())
mark = input().split('.')
shift = False
fraction = []
for digit in map(int, mark[1]):
if digit > 4:
t -= 1
if fraction:
fraction[-1] += 1
while t and fraction and fraction[-1] > 4:
t -= 1
fraction.pop()
if fraction:
fraction[-1] += 1
else:
shift = True
else:
shift = True
break
fraction.append(digit)
if shift:
last_digits = [int(mark[0][-1]) + 1]
i = -1
while last_digits[-1] > 9:
last_digits[-1] -= 10
i -= 1
if -i <= len(mark[0]):
last_digits.append(int(mark[0][i]) + 1)
else:
last_digits.append(1)
print(mark[0][:i], *last_digits[::-1], sep='', end='')
else:
print(mark[0], end='')
if fraction:
print('.', *fraction, sep='')
``` | output | 1 | 43,451 | 20 | 86,903 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all.
Submitted Solution:
```
n, t = map(int, input().split())
xs = list(input())
dot = xs.index('.')
pos = -1
for i in range(dot+1, n):
if xs[i] >= '4':
pos = i
break
if pos < 0:
print("".join(xs))
else:
for j in range(t):
if xs[pos-1-j] != '4':
break
pos = pos - 1 - j
while pos >= 0 and (xs[pos] == '9' or pos == dot):
pos -= 1
if pos < 0:
print("1", end="")
print("0"*dot)
elif pos < dot:
print("".join(xs[:pos]), end="")
print(chr(ord(xs[pos])+1), end="")
print("0"*(dot-pos-1))
else:
print("".join(xs[:pos]), end="")
print(chr(ord(xs[pos])+1))
``` | instruction | 0 | 43,452 | 20 | 86,904 |
No | output | 1 | 43,452 | 20 | 86,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all.
Submitted Solution:
```
n, t = map(int, input().split())
s = input()
INF = 10**9 + 1
j = s.find(".")
a = [int(s[i])for i in range(j + 1, len(s))]
dp = [INF for _ in range(len(a))]
for i in range(len(a) - 1, -1, -1):
if a[i] >= 5:
dp[i] = 1
elif a[i] == 4 and i < len(a) - 1:
dp[i] = 1 + dp[i + 1]
i = 0
f = False
while dp[i] > t and i < len(dp) - 1:
i += 1
if dp[i] <= t:
f = True
if i == 0 and f:
print(s[:j - 1] + str(int(s[j - 1]) + 1))
elif f:
print(s[:j + 1] + str(int(''.join(str(_) for _ in a[:i])) + 1))
else:
print(s)
``` | instruction | 0 | 43,453 | 20 | 86,906 |
No | output | 1 | 43,453 | 20 | 86,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all.
Submitted Solution:
```
n, t = map(int, input().split())
mark = input().split('.')
shift = False
fraction = []
for digit in map(int, mark[1]):
if digit > 4:
t -= 1
if fraction:
fraction[-1] += 1
while t and fraction and fraction[-1] > 4:
t -= 1
fraction.pop()
if fraction:
fraction[-1] += 1
else:
shift = True
else:
shift = True
break
fraction.append(digit)
if shift:
last_digits = [int(mark[0][-1]) + 1]
i = -1
while last_digits[-1] > 9:
last_digits[-1] -= 10
i -= 1
if -i < len(mark[0]):
last_digits.append(int(mark[0][i]) + 1)
else:
last_digits.append(0)
last_digits.append(1)
print(mark[0][:i], *last_digits[::-1], sep='', end='')
else:
print(mark[0], end='')
if fraction:
print('.', *fraction, sep='')
``` | instruction | 0 | 43,454 | 20 | 86,908 |
No | output | 1 | 43,454 | 20 | 86,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer).
There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.
In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.
For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.
Input
The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.
Output
Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.
Examples
Input
6 1
10.245
Output
10.25
Input
6 2
10.245
Output
10.3
Input
3 100
9.2
Output
9.2
Note
In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sat Sep 17 19:15:41 2016
@author: bigu
"""
n,t = map(int, input().split(' '))
num = input()
head,tail = num.split('.')
tail = ['0']+list(tail)
if n == 200000 and t == 255209090:
print(len(head),len(tail))
exit()
stack = []
for i,x in enumerate(tail):
if int(x)>=5:
stack.append(i)
break
last = len(tail)
for _ in range(t):
if len(stack)==0:
break
ind = stack[-1]-1
while True:
#print('ind: ', ind)
tmp = int(tail[ind])+1
#print('tmp: ',tmp)
if tmp<10:
tail[ind]=str(tmp)
break
else:
tail[ind]='0'
ind -= 1
last = ind
stack.pop()
if int(tail[ind])>=5:
stack.append(ind)
head = str(int(head)+int(tail[0]))
tail = ''.join(tail[1:last+1])
print(head+'.'+tail)
# 12 5
# 872.04488525
``` | instruction | 0 | 43,455 | 20 | 86,910 |
No | output | 1 | 43,455 | 20 | 86,911 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa. | instruction | 0 | 43,528 | 20 | 87,056 |
Tags: strings
Correct Solution:
```
s=input()
a=s.index('.')
v=' '
for i in range (0,a):
v+=s[i]
if(s[a-1]=='9'):
print('GOTO Vasilisa.')
else:
if(int(s[a+1])>=5):
print(int(v)+1)
else:
print(int(v))
``` | output | 1 | 43,528 | 20 | 87,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa. | instruction | 0 | 43,529 | 20 | 87,058 |
Tags: strings
Correct Solution:
```
X = input()
print("GOTO Vasilisa." if X[X.index(".") - 1] == "9" else (
X[:X.index(".")] if X[X.index(".") + 1] < "5" else int(X[:X.index(".")]) + 1))
``` | output | 1 | 43,529 | 20 | 87,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa. | instruction | 0 | 43,530 | 20 | 87,060 |
Tags: strings
Correct Solution:
```
n_int, n_dec = input().split('.')
n_int = int(n_int)
print("GOTO Vasilisa." if n_int % 10 == 9 else (n_int if int(n_dec[0]) < 5 else n_int + 1))
``` | output | 1 | 43,530 | 20 | 87,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa. | instruction | 0 | 43,531 | 20 | 87,062 |
Tags: strings
Correct Solution:
```
s = input()
x = s.index('.')
if(s[x - 1] == '9'):
print("GOTO Vasilisa.")
else:
if(int(s[x + 1]) < 5):
print(s[:x])
else:
print(int(s[:x]) + 1)
``` | output | 1 | 43,531 | 20 | 87,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa. | instruction | 0 | 43,532 | 20 | 87,064 |
Tags: strings
Correct Solution:
```
a,b=input().split('.')
if a[len(a)-1]=='9':
print("GOTO Vasilisa.")
else :
c=int(a)
if int(b[0])>=5 :
c+=1
print(c)
``` | output | 1 | 43,532 | 20 | 87,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa. | instruction | 0 | 43,533 | 20 | 87,066 |
Tags: strings
Correct Solution:
```
n=input()
dotindex=n.index(".")
integer_part=n[:dotindex]
decimal_part=n[dotindex+1:]
l=len(str(integer_part))-1
if integer_part[l]!='9':
if decimal_part[0]< '5':
value=integer_part
else:
value=int(integer_part)+1
print(value)
else:
print("GOTO Vasilisa.")
``` | output | 1 | 43,533 | 20 | 87,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa. | instruction | 0 | 43,534 | 20 | 87,068 |
Tags: strings
Correct Solution:
```
n = input()
for i in range(len(n)):
if n[i] == ".":
if n[i - 1] == "9":
print("GOTO Vasilisa.")
elif n[i + 1] == "5" or n[i + 1] == "6" or n[i + 1] == "7" or n[i + 1] == "8" or n[i + 1] == "9":
if n[i - 1] == "0":
print(n[0:i - 1] + str(1))
break
if n[i - 1] == "1":
print(n[0:i - 1] + str(2))
break
if n[i - 1] == "2":
print(n[0:i - 1] + str(3))
break
if n[i - 1] == "3":
print(n[0:i - 1] + str(4))
break
if n[i - 1] == "4":
print(n[0:i - 1] + str(5))
break
if n[i - 1] == "5":
print(n[0:i - 1] + str(6))
break
if n[i - 1] == "6":
print(n[0:i - 1] + str(7))
break
if n[i - 1] == "7":
print(n[0:i - 1] + str(8))
break
if n[i - 1] == "8":
print(n[0:i - 1] + str(9))
break
else:
print(n[0:i])
``` | output | 1 | 43,534 | 20 | 87,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa. | instruction | 0 | 43,535 | 20 | 87,070 |
Tags: strings
Correct Solution:
```
s = input().split('.')
if s[0][-1] == '9':
print("GOTO Vasilisa.")
elif int(s[1][0]) < 5:
print (int(s[0]))
else:
print(int(s[0])+1)
``` | output | 1 | 43,535 | 20 | 87,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa.
Submitted Solution:
```
numero = input()
indice_punto = -1
i = 0
while indice_punto == -1 and i < len(numero):
if numero[i] == '.':
indice_punto = i
i = i+1
unidades = int(numero[indice_punto-1])
decimas = int(numero[indice_punto+1])
if unidades < 9 and decimas < 5:
print(numero[:indice_punto])
elif unidades < 9 and decimas >= 5:
print(numero[:indice_punto-1] + str(int(numero[indice_punto-1])+1))
else:
print('GOTO Vasilisa.')
``` | instruction | 0 | 43,536 | 20 | 87,072 |
Yes | output | 1 | 43,536 | 20 | 87,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa.
Submitted Solution:
```
def main():
parts = input().split('.')
if parts[0][len(parts[0]) - 1] == '9':
print('GOTO Vasilisa.')
else:
if parts[1][0] not in '01234':
add_1 = {'0': '1', '1': '2', '2': '3', '3': '4', '4': '5', '5': '6', '6': '7', '7': '8', '8': '9'}
last_index = len(parts[0]) - 1
parts[0] = parts[0][:last_index] + add_1[parts[0][last_index]]
print(parts[0])
if __name__ == '__main__':
main()
``` | instruction | 0 | 43,537 | 20 | 87,074 |
Yes | output | 1 | 43,537 | 20 | 87,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa.
Submitted Solution:
```
import math
n = input()
dot = n.index(".")
new = n[:dot]
after = n[dot+1]
last = new[-1]
out = ""
def myround(x) :
dot = x.index(".")
new = x[:dot]
after = n[dot+1]
if last == "9" : out = "GOTO Vasilisa."
elif int(after) < 5 : out = new
else : out = str(int(new) + 1)
return out
print(myround(n))
``` | instruction | 0 | 43,538 | 20 | 87,076 |
Yes | output | 1 | 43,538 | 20 | 87,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa.
Submitted Solution:
```
s=input()
li=s.split('.')
if(li[0][-1]=='9'):
print("GOTO Vasilisa.")
else:
if(li[1]<'5'):
print((int)(li[0]))
else:
print((int)(li[0])+1)
``` | instruction | 0 | 43,539 | 20 | 87,078 |
Yes | output | 1 | 43,539 | 20 | 87,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa.
Submitted Solution:
```
a,b = input().split('.')
a = int(a)
b = round(float('1.'+b))-1
if a%10 is 9:
print('GOTO Vasilisa.')
else:
print(a+b)
``` | instruction | 0 | 43,540 | 20 | 87,080 |
No | output | 1 | 43,540 | 20 | 87,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa.
Submitted Solution:
```
s=str(input())
s1=""
s2=""
p=0
flag=0
sum=0
for i in range(0,len(s),1):
if(s[i]!='.'):
s1+=s[i]
if(s[i]=='.'):
p=i
break
for i in range(p+1,len(s),1):
s2+=s[i]
for i in range(0,len(s2),1):
if(s2[i]=='9'):
sum+=1
if(len(s2)==sum):
print("GOTO Vasilisa.")
elif(int(s2[0])>=5):
print(int(s1)+1)
else:
print(int(s1))
``` | instruction | 0 | 43,541 | 20 | 87,082 |
No | output | 1 | 43,541 | 20 | 87,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa.
Submitted Solution:
```
n=input()
ss=n
s=ss.split('.')
x=s[0][-1]
d=(s[0][-1])+'.'+s[1]
d=float(d)
f=round(d)
s[0]=list(s[0])
s[0][-1]=str(f)
s[0]=''.join(s[0])
if(x=='9'):
print("GOTO Vasilisa.")
else:
print(int(s[0]))
``` | instruction | 0 | 43,542 | 20 | 87,084 |
No | output | 1 | 43,542 | 20 | 87,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
* If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part.
* If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.
* If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Examples
Input
0.0
Output
0
Input
1.49
Output
1
Input
1.50
Output
2
Input
2.71828182845904523536
Output
3
Input
3.14159265358979323846
Output
3
Input
12345678901234567890.1
Output
12345678901234567890
Input
123456789123456789.999
Output
GOTO Vasilisa.
Submitted Solution:
```
n = str(input())
f = n.index("."); b = ""
if n[f-1] == 9: print("GOTO Vasilisa")
else:
for i in range(len(n)):
if n[i] != ".": b += n[i]
else: break
if int(n[f+1]) >= 4: print(int(b)+1)
else: print(int(b))
``` | instruction | 0 | 43,543 | 20 | 87,086 |
No | output | 1 | 43,543 | 20 | 87,087 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.