TnT/CodeNet4Repair huggingface dataset:
Problem:
We have a tree with N vertices numbered 1 to N. The i-th edge in the tree connects Vertex u_i and Vertex v_i, and its length is w_i. Your objective is to paint each vertex in the tree white or black (it is fine to paint all vertices the same color) so that the following condition is satisfied:    * For any two vertices painted in the same color, the distance between them is an even number.  Find a coloring of the vertices that satisfies the condition and print it. It can be proved that at least one such coloring exists under the constraints of this problem.

Incorrect submission (verdict: Wrong Answer):
from collections import deque

def bfs(colors, links):
    q = deque([(0, 0)])
    
    while q:
        v, current = q.popleft()

        if current % 2 == 0:
            colors[v] = 0
        else:
            colors[v] = 1

        for next_v, distance in links[v]:
            if colors[next_v] != -1: continue

            q.append((next_v, current + distance))
        
def solve():
    N = int(input())
    A = [list(map(int, input().split())) for _ in range(N-1)]
    cs = [-1] * N
    cs[0] = 0

    links = [[] for _ in range(N)]
    for u, v, w in A:
        v -= 1
        u -= 1
        links[v].append((u, w))
        links[u].append((v, w))

    bfs(cs, links)

    print('\n'.join(map(str, cs)))

print(solve())

Fixed, accepted submission:
from collections import deque

def bfs(colors, links):
    q = deque([(0, 0)])
    
    while q:
        v, current = q.popleft()

        for next_v, distance in links[v]:
            if colors[next_v] != -1: continue
        
            if (current+distance) % 2 == 0:
                colors[next_v] = 0
            else:
                colors[next_v] = 1

            q.append((next_v, current + distance))
        
def solve():
    N = int(input())
    A = [list(map(int, input().split())) for _ in range(N-1)]
    cs = [-1] * N
    cs[0] = 0

    links = [[] for _ in range(N)]
    for u, v, w in A:
        v -= 1
        u -= 1
        links[v].append((u, w))
        links[u].append((v, w))

    bfs(cs, links)

    print('\n'.join(map(str, cs)))

solve()
Problem:
We will say that two integer sequences of length N, x_1, x_2, ..., x_N and y_1, y_2, ..., y_N, are _similar_ when |x_i - y_i| \leq 1 holds for all i (1 \leq i \leq N).  In particular, any integer sequence is similar to itself.  You are given an integer N and an integer sequence of length N, A_1, A_2, ..., A_N.  How many integer sequences b_1, b_2, ..., b_N are there such that b_1, b_2, ..., b_N is similar to A and the product of all elements, b_1 b_2 ... b_N, is even?

Incorrect submission (verdict: Wrong Answer):
import sys
from io import StringIO
import unittest
import logging
logging.basicConfig(level=logging.DEBUG)

def resolve():
    n = int(input())
    dat = list(map(int, input().split()))
    total = 3 ** n
    countzero = 0
    countodd = []

    for i in range(n):
        if dat[i] % 2 == 0:
            countodd.append(2)
        else:
            countodd.append(1)
    xxx = 1
    for i in range(n):
        xxx *= countodd[i]

    total -= xxx
    print(total)

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_input_1(self):
        print("test_input_1")
        input = """2
2 3"""
        output = """7"""
        self.assertIO(input, output)
    def test_input_2(self):
        print("test_input_2")
        input = """3
3 3 3"""
        output = """26"""
        self.assertIO(input, output)
    def test_input_3(self):
        print("test_input_3")
        input = """1
100"""
        output = """1"""
        self.assertIO(input, output)
    def test_input_4(self):
        print("test_input_4")
        input = """10
90 52 56 71 44 8 13 30 57 84"""
        output = """58921"""
        self.assertIO(input, output)

if __name__ == "__main__":
    unittest.main()

Fixed, accepted submission:
n = int(input())
dat = list(map(int, input().split()))
total = 3 ** n
countzero = 0
countodd = []

for i in range(n):
    if dat[i] % 2 == 0:
        countodd.append(2)
    else:
        countodd.append(1)
xxx = 1
for i in range(n):
    xxx *= countodd[i]

total -= xxx
print(total)
Problem:
We have a 3 \times 3 grid. A number c_{i, j} is written in the square (i, j), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.   According to Takahashi, there are six integers a_1, a_2, a_3, b_1, b_2, b_3 whose values are fixed, and the number written in the square (i, j) is equal to a_i + b_j.   Determine if he is correct.

Incorrect submission (verdict: Wrong Answer):
grid = [list(map(int, input().split())) for _ in range(3)]

# Row's check
diff1 = grid[1][0] - grid[0][0]
diff2 = grid[2][0] - grid[0][0]

flag = False

row1 = grid[0]
row2 = grid[1]
row3 = grid[2]

row1_  = [c + diff1 for c in row1]
row1__ = [c + diff2 for c in row2]

if row1_ == row2 and row1__ == row3:
    flag = True

if flag:
    print("Yes")

else:
    print("No")


Fixed, accepted submission:
c = []

for i in range(3):
    A = list(map(int, input().split()))
    c.append(A)
if c[0][0] + c[1][1]+ c[2][2] == c[1][0] + c[2][1] + c[0][2] == c[2][0] + c[0][1] + c[1][2]:
    print('Yes')
else:
    print('No')
Problem:
Evi has N integers a_1,a_2,..,a_N. His objective is to have N equal **integers** by transforming some of them.  He may transform each integer at most once. Transforming an integer x into another integer y costs him (x-y)^2 dollars. Even if a_i=a_j (i≠j), he has to pay the cost separately for transforming each of them (See Sample 2).  Find the minimum total cost to achieve his objective.

Incorrect submission (verdict: Wrong Answer):
a = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq

n = ni()
A = lma()
ans = 10**9
for a in A:
    tmp=0
    for a1 in A:
        tmp+=(a-a1)**2
    ans = min(tmp,ans)
print(ans)


Fixed, accepted submission:
a = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq

n = ni()
A = lma()
ans = 10**9
for i in range(-100,101):
    tmp=0
    for a1 in A:
        tmp+=(i-a1)**2
    ans = min(tmp,ans)
print(ans)
Problem:
You are given an H × W grid.   The squares in the grid are described by H strings, S_1,...,S_H.   The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W).   `.` stands for an empty square, and `#` stands for a square containing a bomb.  Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square.   (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.)   He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square.  Print the strings after the process.

Incorrect submission (verdict: Wrong Answer):


import sys
import itertools

# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

H, W = map(int, readline().split())
S = [readline().decode('utf8').rstrip() for _ in range(H)]

ans = [[0 if cell == '.' else '#' for cell in row] for row in S]
print(ans)

for i in range(H):
    for j in range(W):
        if S[i][j] != '#':
            continue
        for dx, dy in itertools.product([-1, 0, 1], repeat=2):
            x = i + dx
            y = j + dy
            if x < 0 or x >= H:
                continue
            if y < 0 or y >= W:
                continue
            if S[x][y] == '#':
                continue

            ans[x][y] += 1

for row in ans:
    print(*row, sep=' ')


Fixed, accepted submission:


import sys
import itertools

# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

H, W = map(int, readline().split())
S = [readline().decode('utf8').rstrip() for _ in range(H)]

ans = [[0 if cell == '.' else '#' for cell in row] for row in S]
# print(ans)

for i in range(H):
    for j in range(W):
        if S[i][j] != '#':
            continue
        for dx, dy in itertools.product([-1, 0, 1], repeat=2):
            x = i + dx
            y = j + dy
            if x < 0 or x >= H:
                continue
            if y < 0 or y >= W:
                continue
            if S[x][y] == '#':
                continue

            ans[x][y] += 1

for row in ans:
    print(*row,sep='')
Problem:
There are N children in AtCoder Kindergarten. Mr. Evi will arrange the children in a line, then give 1 candy to the first child in the line, 2 candies to the second child, ..., N candies to the N-th child. How many candies will be necessary in total?

Incorrect submission (verdict: Wrong Answer):
n = input()
s=""
for i in range(len(n)):
    if(n[i]=="B" and s != ""):
        s=s[:-1]
    else:
        s+=n[i]
print(s)
        


Fixed, accepted submission:
n = int(input())
ans = 0
for i in range(n):
    ans += i+1
print(ans)
Problem:
An _X -layered kagami mochi_ (X ≥ 1) is a pile of X round mochi (rice cake) stacked vertically where each mochi (except the bottom one) has a smaller diameter than that of the mochi directly below it. For example, if you stack three mochi with diameters of 10, 8 and 6 centimeters from bottom to top in this order, you have a 3-layered kagami mochi; if you put just one mochi, you have a 1-layered kagami mochi.  Lunlun the dachshund has N round mochi, and the diameter of the i-th mochi is d_i centimeters. When we make a kagami mochi using some or all of them, at most how many layers can our kagami mochi have?

Incorrect submission (verdict: Wrong Answer):
N = int( input())
D = []
for i in range(N):
    D.append(int(input()))
sorted(D)
print(D)
ans = 1
d_now = D[0]
for i in range(1,N):
    if d_now > D[i]:
        ans += 1
        d_now = D[i]
print(ans)

Fixed, accepted submission:
N = int( input())
D = []
for i in range(N):
    D.append(int(input()))
D = sorted(D)
ans = 1
d_now = D[0]
for i in range(1,N):
    if d_now < D[i]:
        ans += 1
        d_now = D[i]
print(ans)
Problem:
There are N stones arranged in a row. Every stone is painted white or black. A string S represents the color of the stones. The i-th stone from the left is white if the i-th character of S is `.`, and the stone is black if the character is `#`.  Takahashi wants to change the colors of some stones to black or white so that there will be no white stone immediately to the right of a black stone. Find the minimum number of stones that needs to be recolored.

Incorrect submission (verdict: Wrong Answer):
n = int(input())
s = str(input())
a = s.find('
b = s.rfind('.') 

ans = min([s[a:n].count('.'),s[0:b].count('#')])
print(ans)

Fixed, accepted submission:
n = int(input())
s = str(input())
k = [s.count('.')]

for i in range(n):
  if s[i] == "#":
    k.append(k[i]+1)
  else:
    k.append(k[i]-1)
    
print(min(k))
Problem:
Snuke has a grid consisting of three squares numbered 1, 2 and 3. In each square, either `0` or `1` is written. The number written in Square i is s_i.  Snuke will place a marble on each square that says `1`. Find the number of squares on which Snuke will place a marble.

Incorrect submission (verdict: Wrong Answer):
s = input()
ans = 0
for i in range(3):
  if s[i] == 1:
    ans += 1
print(ans)

Fixed, accepted submission:
s = list(input())
ans = 0
for i in range(3):
  if s[i] == '1':
    ans += 1
print(ans)
Problem:
You are given three integers A, B and C. Determine whether C is not less than A and not greater than B.

Incorrect submission (verdict: Wrong Answer):
a,b,c = map(int,input().split())
if c >= a and b <= b:
  print('YES')
else:
  print('NO')

Fixed, accepted submission:
a,b,c = map(int,input().split())
if c >= a and c <= b:
  print('Yes')
else:
  print('No')
Problem:
In programming, hexadecimal notation is often used.  In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters `A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12, 13, 14 and 15, respectively.  In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`, `C`, `D`, `E` or `F`.  When X and Y are seen as hexadecimal numbers, which is larger?

Incorrect submission (verdict: Wrong Answer):
a,b=input().split()
print(type(a))
print(type(b))
if a<b:
	print("<")
elif b<a:
	print(">")
else :
	print("=")

Fixed, accepted submission:
a,b=input().split()
if a<b:
	print("<")
elif b<a:
	print(">")
else :
	print("=")
Problem:
We will buy a product for N yen (the currency of Japan) at a shop.  If we use only 1000-yen bills to pay the price, how much change will we receive?  Assume we use the minimum number of bills required.

Incorrect submission (verdict: Wrong Answer):
n = int(input())
k=n%1000+1
print(k*1000-n)

Fixed, accepted submission:
n = int(input())
k = (n//1000) + 1
if n%1000 == 0:
  print(0)
else :
  print(1000*k-n)
Problem:
The commonly used bills in Japan are 10000-yen, 5000-yen and 1000-yen bills. Below, the word "bill" refers to only these.  According to Aohashi, he received an otoshidama (New Year money gift) envelope from his grandfather that contained N bills for a total of Y yen, but he may be lying. Determine whether such a situation is possible, and if it is, find a possible set of bills contained in the envelope. Assume that his grandfather is rich enough, and the envelope was large enough.

Incorrect submission (verdict: Wrong Answer):
N, Y = map(int, input().split())
res = -1, -1, -1

for x in range(N + 1):
    for y in range(N - x + 1):
        z = N - x - y
        if 10000 * x + y * 5000 + z * 1000 == Y:
            res = x, y, z

print(res)



Fixed, accepted submission:
N, Y = map(int, input().split())
res = -1, -1, -1

for x in range(N + 1):
    for y in range(N - x + 1):
        z = N - x - y
        if 10000 * x + y * 5000 + z * 1000 == Y:
            res = x, y, z
            break

print(*res)
Problem:
There are N empty boxes arranged in a row from left to right. The integer i is written on the i-th box from the left (1 \leq i \leq N).  For each of these boxes, Snuke can choose either to put a ball in it or to put nothing in it.  We say a set of choices to put a ball or not in the boxes is good when the following condition is satisfied:    * For every integer i between 1 and N (inclusive), the total number of balls contained in the boxes with multiples of i written on them is congruent to a_i modulo 2.  Does there exist a good set of choices? If the answer is yes, find one good set of choices.

Incorrect submission (verdict: Wrong Answer):
#######################################
import numpy as np
import math
import copy
import re
import sys
#sys.exit(0)

inf = float("inf")
prime = 1

def check_print(check_flag, text, end="\n"):
  if check_flag:
    print(text, end=end)

def c2i(x):
    if str.isdecimal(x):
        return int(x)
    else:
        return x

def cout(*args):
  arglist = []
  for arg in args:
    if hasattr(arg, "__iter__"):
      arglist.extend(arg)
    else:
      arglist.append(arg)
      
  arglist = list(map(str, arglist))
  print(" ".join(arglist))
  
def count2(num):
  count=0
  while num%2==0:
    num/=2
    count+=1
  return count

def ketasum(num):
  nums = [int(s) for s in str(num)]
  return sum(nums)

#math
def gcd(a, b): 
  while b:
    a, b = b, a % b
  return a

def lcm(a, b): 
  return a * b // gcd (a, b)

def gcd3(lis): (3over)
  ans = lis[0]
  for li in lis:
    ans = gcd(ans,li)

def lcm3(lis): (3over)
  ans = lis[0]
  for li in lis:
    ans = lcm(ans,li)

def divisor(n): 
  i = 1
  table = []
  while i * i <= n:
    if n%i == 0:
      table.append(i)
      table.append(n//i)
    i += 1
  table = list(set(table))
  return table

def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(i)
    i += 1
  if n > 1:
    table.append(n)
  return table

def is_prime(n):
  for i in range(2, n + 1):
    if i * i > n:
      break
    if n % i == 0:
      return False
  return n != 1

#input stock


#processing stock






#math


#######################################
n = int(input())
a = np.array(list(map(int, input().split())))
ret = np.array([-1]*n)

mid = int(n/2)

for i in range(n):
  i_idx, i_val = n-i-1, n-i
  idx = [j for j in range(n) if (j+1)%i_val==0]
  idx2 = [j for j in range(n) if (j+1)%i_val==0 and ret[j]==-1]
  idx3 = [j for j in range(n) if (j+1)%i_val==0 and ret[j]!=-1]
  idx = np.array(idx)
  idx2 = np.array(idx2)
  idx3 = np.array(idx3)

  if len(idx)==1:
    ret[i_idx] = a[i_idx]
  elif len(idx2)==1:
    ret[i_idx] = (sum(a[idx]) - sum(a[idx3]))%2
  
cout(ret)

  
  

Fixed, accepted submission:
#######################################
import numpy as np
#######################################
n = int(input())
a = list(map(int, input().split()))
ret = np.zeros(n+1, dtype="int")
ret2 = []

for i in reversed(list(range(n))): 
  if sum(ret[::i+1][1:])%2 != a[i]:
    ret[i+1] = 1
    ret2.append(i+1)

print(sum(ret[1:]))
print(" ".join(list(map(str, ret2[::-1]))))
Problem:
A Hitachi string is a concatenation of one or more copies of the string `hi`.  For example, `hi` and `hihi` are Hitachi strings, while `ha` and `hii` are not.  Given a string S, determine whether S is a Hitachi string.

Incorrect submission (verdict: Wrong Answer):
def solve(s):
    for i in range(len(s)):
        if s[i] == 'h' and s[i+1] == 'i':
            print("YES")
            return

    print("NO")
    return 
    
if __name__ == "__main__":
    s = input()
    solve(s)


Fixed, accepted submission:
z = input()

if z=='hi' or z=='hihi' or z=='hihihi' or z=='hihihihi' or z=='hihihihihi':
    print("Yes")
else:
    print("No")
Problem:
It is September 9 in Japan now.  You are given a two-digit integer N. Answer the question: Is 9 contained in the decimal notation of N?

Incorrect submission (verdict: Wrong Answer):
s = input()
a = [int(c) for c in s]

print(9 in a)


Fixed, accepted submission:
s = input()
a = [int(c) for c in s]
if 9 in a:
    print('Yes')
else:
    print('No')
Problem:
You are given a string s. Among the **different** substrings of s, print the K-th lexicographically smallest one.  A substring of s is a string obtained by taking out a non-empty contiguous part in s. For example, if s = `ababc`, `a`, `bab` and `ababc` are substrings of s, while `ac`, `z` and an empty string are not. Also, we say that substrings are different when they are different as strings.  Let X = x_{1}x_{2}...x_{n} and Y = y_{1}y_{2}...y_{m} be two distinct strings. X is lexicographically larger than Y if and only if Y is a prefix of X or x_{j} > y_{j} where j is the smallest integer such that x_{j} \neq y_{j}.

Incorrect submission (verdict: Wrong Answer):
s = input()
k = int(input())

smin = list(set(list(s)))
print(smin)
smin = sorted(smin)[0:5]
print(smin)

def search(st):
    ans = []
    cnt = 0
    for a in st:
        if len(set(ans)) >= 5:
            return ans
        for i in range(len(s)):
            if s[i] is a:
                for j in range(6):
                    ans.append(s[i:min(i+j,len(s))])

    
    return ans
    
b = list(set(search(smin)))

if b[0] == '':
    del b[0]

print(b[k-1])

Fixed, accepted submission:
s = input()
k = int(input())

smin = list(set(list(s)))
smin = sorted(smin)[0:5]


def search(st):
    ans = []
    cnt = 0
    for a in st:
        if len(set(ans)) >= 5:
            return ans
        for i in range(len(s)):
            if s[i] is a:
                for j in range(1,6):
                    ans.append(s[i:min(i+j,len(s))])

    
    return ans
    
b = list(set(search(smin)))
b = sorted(b)
if b[0] == '':
    del b[0]

print(b[k-1])
Problem:
Our world is one-dimensional, and ruled by two empires called Empire A and Empire B.  The capital of Empire A is located at coordinate X, and that of Empire B is located at coordinate Y.  One day, Empire A becomes inclined to put the cities at coordinates x_1, x_2, ..., x_N under its control, and Empire B becomes inclined to put the cities at coordinates y_1, y_2, ..., y_M under its control.  If there exists an integer Z that satisfies all of the following three conditions, they will come to an agreement, but otherwise war will break out.    * X < Z \leq Y   * x_1, x_2, ..., x_N < Z   * y_1, y_2, ..., y_M \geq Z  Determine if war will break out.

Incorrect submission (verdict: Wrong Answer):
NMXY = list(map(int,input().split()))
N=NMXY[0]
M=NMXY[1]
X=NMXY[2]
Y=NMXY[3]
x=list(map(int,input().split()))
y=list(map(int,input().split()))
flag1=[]
flag2=[]

Z=list(range(X+1,Y+1))
print(Z)
Z2=[]
Z3=[]
for k in Z:
    if all([i<k for i in x]):
        Z2.append(k)


print(Z2)
for l in Z2:
    if all([j>=k for j in y]):
        Z3.append(k)

print(Z3)
if len(Z3)>0:
    print('No War')
else:
    print('War')


Fixed, accepted submission:
N,M,X,Y=map(int,input().split())
x=list(map(int,input().split()))
y=list(map(int,input().split()))
A=max(x)
B=min(y)
if A>=B:
    print("War")
else:
    if X<=A and B<=Y:
        print("No War")
    else:
        print("War")
Problem:
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two _gestures_ , _Rock_ and _Paper_ , as in Rock-paper-scissors, under the following condition:  (※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).  Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.  _(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)_  With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.  The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.

Incorrect submission (verdict: Wrong Answer):
s=input()
g=p=a=0
for t in s:
  if t=='g':
    g+=1
  else:
    if p<g:
      p+=1
      a+=1
    else:
      g+=1
      a-=1
print(a+(g-p)//2)

Fixed, accepted submission:
s=input()
g=p=a=0
for t in s:
  if t=='g':
    g+=1
  else:
    if p<g:
      p+=1
    else:
      g+=1
      a-=1
print(a+(g-p)//2)
Problem:
Write a program which reads a rectangle and a circle, and determines whether the circle is arranged inside the rectangle. As shown in the following figures, the upper right coordinate $(W, H)$ of the rectangle and the central coordinate $(x, y)$ and radius $r$ of the circle are given.     

Incorrect submission (verdict: Wrong Answer):
W,H,x,y,r = map(int,input().split())
if 0 <= x-r and x + r <= W and 0 <= y-r and y + r >= H:
   print("Yes")
else:
   print("No")

Fixed, accepted submission:
W,H,x,y,r = map(int,input().split())
if 0 <= x-r and x + r <= W and 0 <= y-r and y + r <= H:
   print("Yes")
else:
   print("No")
Problem:
Compute A \times B, truncate its fractional part, and print the result as an integer.

Incorrect submission (verdict: Wrong Answer):
import math
A, B = list(map(float, input().split()))
print(math.floor((B*100)*A))

Fixed, accepted submission:
sp = input().split()
A = int(sp[0])
B = int(sp[1].replace(".",""))
print(A*B//100)