Problem:


Score : 300 points

Problem Statement

Compute A \times B, truncate its fractional part, and print the result as an integer.

Constraints

0 \leq A \leq 10^{15}

0 \leq B < 10

A is an integer.

B is a number with two digits after the decimal point.

Input

Input is given from Standard Input in the following format:

A B

Output

Print the answer as an integer.

Sample Input 1

198 1.10

Sample Output 1

217

We have 198 \times 1.10 = 217.8. After truncating the fractional part, we have the answer: 217.

Sample Input 2

1 0.01

Sample Output 2

0

Sample Input 3

1000000000000000 9.99

Sample Output 3

9990000000000000



Sample input:
198 1.10


Sample output:
217

Submission status: Wrong Answer

Solution code:
A, B = list(map(str, input().split()))

a = int(A)
b = int(B[0])
c = int(B[2:])
c_ = c / 100
d = int(a * c_)



ans = a * b + d


print(ans)

Submission status: Wrong Answer

Solution code:
a, b = input().split()
a = int(a)
b1 = int(b[0])
b2 = int(b[2])
b3 = int(b[3])
ans = a * b1 + a * b2 / 10 + a * b3 / 100
print(int(ans))

Submission status: Wrong Answer

Solution code:
import math
A, B = input().split()
A = int(A)
B = int(float(B)*100)
print(A*B//100)

Submission status: Wrong Answer

Solution code:
from math import floor

a, b = input().split()
a = int(a)

if '.' in b:
    b = float(b)
else:
    b = int(b)
    
ans = a*b
print(floor(ans))

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().split())
c = a*b
c = int(c)
print(c)

Submission status: Wrong Answer

Solution code:
import sys
# from functools import lru_cache, cmp_to_key
# from heapq import merge, heapify, heappop, heappush
# from math import ceil, floor, gcd
from collections import defaultdict as dd, deque, Counter as C
# from itertools import combinations as comb, permutations as perm
# from bisect import bisect_left as bl, bisect_right as br, bisect
# from time import perf_counter
# from fractions import Fraction
# sys.setrecursionlimit(pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]

from math import trunc
a, b = map(float, input().split())
print(trunc(a * b))

Submission status: Wrong Answer

Solution code:
[a,b]=list(map(float,input().split()))
ans=int(a*b)
print(ans)

Submission status: Wrong Answer

Solution code:
import math

# for _ in range(int(input())):

a = list(input().split())
a[0] = float(a[0])
a[1] = float(a[1])

print(int(a[0] * a[1]))

Submission status: Wrong Answer

Solution code:
from sys import stdin


def main():
    _in = [_.rstrip() for _ in stdin.readlines()]
    A,B = list(map(float,_in[0].split(' ')))  # type:list(int)
    # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
    A = int(A)
    A_1 = A//100
    A_2 = A-A_1*100

    cnt = int(A_1*(B*100)+(A_2*B)//1)
    # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    print(cnt)


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import math
a,b = input().split()

b = int(float(b)*100)


print(int(a)*b//100)

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
b *= 100
res = a*b
print(int(res//100))

Submission status: Wrong Answer

Solution code:
A, B = input().split()
A = int(A)
B = float(B)

A0 = A//100
A1 = A%100
B0 = int(B*100)


ans = A0 * B0 + int(A1 * B)
print(ans)

Submission status: Wrong Answer

Solution code:
import math

a, b = map(float, input().split(" "))
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
import math

numbers = input().split()
a = int(numbers[0])
b = float(numbers[1])

c = math.floor(a * b)

print(c)

Submission status: Wrong Answer

Solution code:
from math import floor

a, b = input().split()
a = int(a)
b = float(b)

print(floor(a*b+0.001))

Submission status: Wrong Answer

Solution code:
import math
ab = input().split()
a = int(ab[0])
b = float(ab[1])

ans = math.floor(a*b)

print(ans)

Submission status: Wrong Answer

Solution code:
n,m=map(str,input().split())
n=int(n)
m=int(float(m)*100)
hoge=n*m
print(hoge//100)

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(4100000)

import math

import logging

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)


def resolve():
    # S = [x for x in sys.stdin.readline().split()][0]  # 文字列 一つ
    # N = [int(x) for x in sys.stdin.readline().split()][0]  # int 一つ
    A, B = [float(x) for x in sys.stdin.readline().split()]  # 複数int
    # h_list = [int(x) for x in sys.stdin.readline().split()]  # 複数int

    # grid = [list(sys.stdin.readline().split()[0]) for _ in range(N)]  # 文字列grid
    # v_list = [int(sys.stdin.readline().split()[0]) for _ in range(N)]
    # grid = [[int(x) for x in sys.stdin.readline().split()]
    #         for _ in range(N)]  # int grid

    logger.debug('{}'.format([]))

    print(int(A * B))


if __name__ == "__main__":
    resolve()

# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py で実行できる
# pypy3 -m unittest template/template.py で実行できる

import sys
from io import StringIO
import unittest


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_入力例_1(self):
        input = """198 1.10"""
        output = """217"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """1 0.01"""
        output = """0"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """1000000000000000 9.99"""
        output = """9990000000000000"""
        self.assertIO(input, output)

Submission status: Wrong Answer

Solution code:

a,b = map(float, input().split())
ans = int(a*b//1)
print(ans)

Submission status: Wrong Answer

Solution code:
import math

a,b=input().split()
a=int(a)
b=float(b)
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
import sys, math

a, b = sys.stdin.readline().split()
print(math.floor(int(a) * float(b)))

Submission status: Wrong Answer

Solution code:
from decimal import *
A,B = list(map(float,input().split()))
print(int(Decimal(A)*Decimal(B)))

Submission status: Wrong Answer

Solution code:
import sys

a,b = list(map(float, input().split()))

ans = a * b

ans = ans // 1

print(int(ans))

Submission status: Wrong Answer

Solution code:
import math

A,B=map(float,input().split(' '))

print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
A, B = map(float, input().split())
int(A)
B = int(B * 100)
print(int(A * B // 100))

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
a*=b
print(int(a))

Submission status: Wrong Answer

Solution code:
import math
# N = int(input())
A, B = [i for i in input().split()]
A = int(A)
B = float(B)
print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
import math
A,B = input().split()
A=int(A)
B=float(B)
print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
from math import floor

a, b = map(float, input().split())
print(floor(a * b))

Submission status: Wrong Answer

Solution code:
import math

if __name__ == "__main__":
    a, b = input().split()
    a = int(a)
    b = float(b)

    ans = a * b
    ans = math.floor(ans)

    print(ans)

Submission status: Wrong Answer

Solution code:
a, b = list(map(float,input().split()))
print(int(a*b))

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().split())
bb = int(b * 100)
ans = a * bb

print(int(ans//100))

Submission status: Wrong Answer

Solution code:
import math
A,B=map(float,input().split())
print(int((A*B)))

Submission status: Wrong Answer

Solution code:
inputlist = input().strip().split(" ")
a = int(inputlist[0])
b = float(inputlist[1])

print(int(a*b))

Submission status: Wrong Answer

Solution code:
a, b = input().split()
a = int(a)
b = float(b)
sum = str(a * b)
if '.' in sum:
    print(sum.split('.')[0])
else:
    print(sum)

Submission status: Wrong Answer

Solution code:
from pprint import pprint
import sys

A, B = sys.stdin.readline().strip().split()
print(int(A) * int(float(B) * 100) // 100)

Submission status: Wrong Answer

Solution code:
import math
A, B = input().split()
A = int(A)
B, C = B.split('.')

ans = A*int(B) + A*int(C[0])/10 + A*int(C[1])/100
print(math.floor(ans))

Submission status: Wrong Answer

Solution code:
import math
a,b = map(float,input().split())

ans = a*b

print(math.floor(ans))

Submission status: Wrong Answer

Solution code:
from math import floor
a, b = input().split()
a = int(a)
b = float(b)
ans = floor(a * b)
print(ans)

Submission status: Wrong Answer

Solution code:
import math
A, B = map(float, input().split())
print(int(A*B))

Submission status: Wrong Answer

Solution code:
A, B = input().split()
A = int(A)
B = int(float(B)*100)

print(A*B//100)

Submission status: Wrong Answer

Solution code:
from math import floor
a,b = map(float, input().split())
ans = b*a
print(floor(ans))

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline

AB = input().split()
A = int(AB[0])
B100 = int(float(AB[1])*100)

print( A*B100//100 )

Submission status: Wrong Answer

Solution code:
s = input().split()
A = int(s[0])
B = float(s[1])
B100 = int(B * 100)
print(int(A * B100) // 100)

Submission status: Wrong Answer

Solution code:
a,b = map(str, input().split())
print(int(int(a)*float(b)))

Submission status: Wrong Answer

Solution code:
###############################################################################
#Imports
import collections
import itertools
from functools import lru_cache
import sys
import math
###############################################################################
#Constants
MOD = int(1e9)+7
###############################################################################
#Helper
def helper():
	pass
###############################################################################
#Solver
def solve():
	a, b = input().split(' ')
	a, b = float(a), float(b)
	print(int(a*b))

###############################################################################
#Driver
t = 1
for _ in range(t):
	solve()
###############################################################################

Submission status: Wrong Answer

Solution code:
a, b = input().split()
import math

a = int(a)
ans = 0
ans += a * int(b[0])
ans += a * int(b[2]) / 10
ans += a * int(b[3]) / 100
ans = math.floor(ans)
print(ans)

Submission status: Wrong Answer

Solution code:
A,B=map(float,input().split())
print(int((A*B)//1))

Submission status: Wrong Answer

Solution code:
from decimal import *
a,b=map(float, input().split(" "))
print((int)(Decimal(a)*Decimal(b)))

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
b = round(b,2)
#a = int(a)
print (int(a*b))

Submission status: Wrong Answer

Solution code:
ab = input().split()
 
a = int(ab[0])
b = float(ab[1])
x = a * b
print(int(x))

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().split())
print(int(a*b //1))

Submission status: Wrong Answer

Solution code:
A,B=input().split()
A=int(A)
B=int(float(B)*100)
ans=0
for i in range(B):
    ans+=A
print(ans//100)

Submission status: Wrong Answer

Solution code:
import math 
a,b = map(float,(input().split()))
ans = a * b

print(math.floor(ans))

Submission status: Wrong Answer

Solution code:
a,b = input().split()
b = int(float(b)*100)
a = int(a)
print((a*b)//100)

Submission status: Wrong Answer

Solution code:
A,B = map(float,input().split())
A = int(A)
B = int(B*100)
print(A*B//100)

Submission status: Wrong Answer

Solution code:
import math

A, B = map(float, input().split())

print(A * math.floor(B))

Submission status: Wrong Answer

Solution code:
import math
l = list(input().split())

a = int(l[0])
b = float(l[1])

print(int(math.floor(a*b)))

Submission status: Wrong Answer

Solution code:
import sys

input = sys.stdin.readline


def S():
    return input().rstrip()


def I():
    return int(input())


def MI():
    return map(float, input().split())


a, b = MI()

print(int(a * b))

Submission status: Wrong Answer

Solution code:
#JMD
#Nagendra Jha-4096

 
import sys
import math

#import fractions
#import numpy
 
###File Operations###
fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile

###Defines...###
mod=1000000007
 
###FUF's...###
def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 
##### Main ####
t=1
for tt in range(t):
    #n=int(input())
    a,b= map(float, sys.stdin.readline().split(' '))
    b*=100
    a*=b
    print(int(a//float(100)))
    #a=list(map(int,sys.stdin.readline().split(' ')))
    
    
#####File Operations#####
if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

Submission status: Wrong Answer

Solution code:
A,B = map(float,input().split(" "))
ans = str(A * B).split(".")[0]
print(ans)

Submission status: Wrong Answer

Solution code:
import math

a = list(map(float,input().split()))


print(math.floor(a[0]*a[1]))

Submission status: Wrong Answer

Solution code:
a, b = input().split()
c = int(a) * float(b)
print(c)
cl = list(str(c))
s = ""
for i in range(len(cl)):
    if cl[i] == '.':
        break
    else:
        s += cl[i]
print(s)

Submission status: Wrong Answer

Solution code:
# coding: utf-8
nums = input().split()
a = int(nums[0])
b = float(nums[1])
print(int(a*b))

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
# n,m = map(int,sys.stdin.readline().split())
# a = tuple(map(int,sys.stdin.readline().split())) # single line with multi param
# a = tuple(sys.stdin.readline() for _ in range(n)) # multi line with single param
# a = tuple(tuple(map(int,sys.stdin.readline().rstrip().split())) for _ in range(N)) # multi line with multi param
# s = sys.stdin.readline().rstrip()
# n = int(sys.stdin.readline())
# INF = float("inf")
# sys.setrecursionlimit(10000)
import sys,collections,math
sys.setrecursionlimit(100000)
a,b = sys.stdin.readline().split()
a = int(a)
b = float(b)

print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
import math
a,b = map(float,input().split())
c = math.floor(a*b)
print(c)

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().split())

s = a * b
t = int(s)

print(t)

Submission status: Wrong Answer

Solution code:
a,b=map(float, input().split())
a=int(a*100)
b=int(b*100)
print(int(a*b)//100)

Submission status: Wrong Answer

Solution code:


def read_int():
    return int(input().strip())


def read_ints():
    return list(map(int, input().strip().split(' ')))


def read_floats():
    return list(map(float, input().strip().split(' ')))


def solve():
    A, B = input().strip().split(' ')
    A = int(A)
    B = int(float(B)*100)
    return A*B//100


if __name__ == '__main__':
    print(solve())

Submission status: Wrong Answer

Solution code:
s = input().split()
a = int(s[0])
b = float(s[1])

print(int(a*b))

Submission status: Wrong Answer

Solution code:
A,B=input().split(' ')
A=int(A)
B=float(B)
print(int(A*B))

Submission status: Wrong Answer

Solution code:
x = input().split()
a = int(x[0])
b = float(x[1])
r = (a * b * 100) //100
print(int(r))

Submission status: Wrong Answer

Solution code:
import math
a, b = list(map(float, input().split()))
print(int(math.floor(a*b)))

Submission status: Wrong Answer

Solution code:
A, B = input().split()
A = int(A)
B = float(B)
B = int(B * 100)
import math
print(math.floor(A*B/100))

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
import math
import sys


def solve(A: int, B: float):
    bint = int(B*100)
    print(A*bint//100)
    return


# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = float(next(tokens))  # type: float
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
a,b = input().split()
a=int(a)
b=int(float(b)*100)

ans=a*b
print(int(ans/100))

Submission status: Wrong Answer

Solution code:
import math
li = input().split()
a=int(li[0])
b=float(li[1])
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
import math

i = list(map(float, input().split()))
ans = 1
for num in range(len(i)):
    ans = ans * i[num]
print(math.floor(ans))

Submission status: Wrong Answer

Solution code:
def readInt():
    return list(map(float, input().split()))

a,b = readInt()
a = int(a)
# print(a,b)
ans = int(a*b)
print(ans)

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().split())
b = round(b,2)
a = round(a,0)
a =int(a)
#print(a,b)
ans = a * b 
ans = int(ans)
print(ans)

Submission status: Wrong Answer

Solution code:
import math
import sys
import collections
from collections import defaultdict
from sys import stdin, stdout

sys.setrecursionlimit(10**9)
a,b=map(float,input().split())
print(int(a*b))

Submission status: Wrong Answer

Solution code:
A, B = map(float, input().split())
A = int(A)
B *= 100
B = int(B)
ans = A * B
print(ans//100)

Submission status: Wrong Answer

Solution code:
s = list(map(float, input().split()))
a = s[0]*s[1]
print(int(a))

Submission status: Wrong Answer

Solution code:
A,B = list(input().split())

A = int(A)
B = float(B)

print(int(A*B))

Submission status: Wrong Answer

Solution code:
a,b = map(float, input().split())
ab = a*b
ans = int(ab)
print(ans)

Submission status: Wrong Answer

Solution code:
import math
N, M = input().strip().split()
N, M = [int(N), float(M)]
print( math.trunc(N*M))

Submission status: Wrong Answer

Solution code:
A, B = list(map(float, input().split()))
A = int(A)

print(int(A*B))

Submission status: Wrong Answer

Solution code:
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations, combinations_with_replacement
from heapq import heappop, heappush
from fractions import gcd
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    s = list(input().split())
    a = int(s[0])
    b = float(s[1])
    b *= 100
    b = int(b)
    print(a*b//100)
    
if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd
from itertools import permutations, combinations, product, accumulate, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from decimal import *
#from fractions import gcd
def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True

t = input().split()
a, b = int(t[0]), Decimal(t[1])
bb = int(b)
bbb = int(b * 100 - bb * 100)
ans = a * bb + int(a * bbb / 100)
print(ans)

Submission status: Wrong Answer

Solution code:
# 0や1のケースに注意
# index out of range
# 貪欲

def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    import math
    #from math import gcd

    #inf = 10**17
    #mod = 10**9 + 7

    c = input().rstrip().split()
    a = int(c[0])
    b = float(c[1])
    res = a*b
    d = int(res)
    for i in range(d-100000, d+100000):
        if i <= res < i+1:
            print(i)
            break


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
A,B = map(float,input().split())

print(int(A*B//1))

Submission status: Wrong Answer

Solution code:
A, B = map(float,input().split())
print(int((A * int(B * 100)) // 100))

Submission status: Wrong Answer

Solution code:
import math
a,b=map(float,input().split())
b*=100
c=a*b

print(math.floor(c/100))

Submission status: Wrong Answer

Solution code:
#c
a,b=map(float, input().split())
import math
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
A,B=map(float,input().split())
print(A,B,int(A*B))

Submission status: Wrong Answer

Solution code:
ab = input()
a = int(ab.split()[0]) 
b = float(ab.split()[1])
print(int(a * b))

Submission status: Wrong Answer

Solution code:
def main():
    A,B = map(float,input().split())
    C = int(A*B)
    print(C)
    
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())

ans = int(a) * int(b // 1)
diff = a * (b - b//1)
ans += int(diff)
print(ans)

Submission status: Wrong Answer

Solution code:
import sys
#import time
import copy
#from collections import deque, Counter, defaultdict
#from fractions import gcd
#import bisect
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**20
ri = lambda : int(input())
rs = lambda : input().strip()
rl = lambda : list(map(float, input().split()))
a,b = rl()
print(int(a*b))

Submission status: Wrong Answer

Solution code:
import math
A, B = list(map(float, input().split()))
answer = A*B
print(math.floor(answer))

Submission status: Wrong Answer

Solution code:
A,B=input().split()
a=int(A)
b=float(B)
x=a*b
import math
print(math.floor(x))

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)


A, B = input().split()
A = int(A)
B = float(B)

print(int(A*B))

Submission status: Wrong Answer

Solution code:
a,b = input().split()

a,b = int(a),float(b)

b = int(100*b)

print((a*b)//100)

Submission status: Wrong Answer

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, floor
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(float, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

A, B = MAP()

c = B * 100
c = floor(c)
A = floor(A)
# print(c)
# print(A * c // 100)
# A = A
# c = int(c)
print(A * c // 100)

Submission status: Wrong Answer

Solution code:
import math
x,y = map(float,input().split())
ans=math.floor(x*y)
print(ans)

Submission status: Wrong Answer

Solution code:
import math
a,b = map(float,input().split())
c = a*b%1
print(c)
s = a*b-c
print(math.ceil(a*b))

Submission status: Wrong Answer

Solution code:
def resolve():
    a, b = map(float, input().split())
    a = int(a)
    b = b*100
    b = int(b)
    print(int(a*b/100))
resolve()

Submission status: Wrong Answer

Solution code:
import math
a,b = [i for i in input().split()]
a = int(a)
b = float(b)
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
A,B=input().split()
C=int(int(A)*float(B))
print(C)

Submission status: Wrong Answer

Solution code:
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

import math

c = input().split()
a = int(c[0])
b = float(c[1])

print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
def abc169_c():
    sin = input().split()
    A = int(sin[0])
    B = float(sin[1])
    ans = A * int(B*100) // 100
    print(ans)

abc169_c()

Submission status: Wrong Answer

Solution code:
a,b=input().split()
ans=int(a)*float(b)
print(int(ans))

Submission status: Wrong Answer

Solution code:
import math
a, b = map(float, input().split())
ans = a*b
if ans < 0:
    print(math.floor(ans)+1)
else:
    print(math.floor(ans))

Submission status: Wrong Answer

Solution code:
#import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')

A, B = input().split()
A = int(A)
B = float(B)

print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
import sys
import math

def solve(A: int, B: float):
    a = (A*B)//1
    print(math.ceil(a))

    return


# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = float(next(tokens))  # type: float
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
from collections import defaultdict
from math import gcd
import time
import sys
from collections import Counter
import itertools
import math
# read = sys.stdin.buffer.read
# readline = sys.stdin.buffer.readline
# readlines = sys.stdin.buffer.readlines
input = sys.stdin.readline

A, B = map(float, input().split(" "))

print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
S = input().split()

A = int(S[0])
B = float(S[1])

print(int(A*B))

Submission status: Wrong Answer

Solution code:
import sys
import heapq

def main():
    a, b = map(str, sys.stdin.readline().split())
    a = int(a)
    b = float(b)
    b *= 100
    b = int(b)
    ans = a * b // 100
    print(ans)
    return

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().split())
q = int(a)
p = int(b*100)
print(int(q*p//100))

Submission status: Wrong Answer

Solution code:
import itertools

import math


def main():
    A, B = map(float, input().split())

    print(math.floor(A*B))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
from decimal import Decimal
# ----------

# ----------

A, B = map(float, input().split())
A = Decimal(A)
B = Decimal(B)

print(int(A * B))

Submission status: Wrong Answer

Solution code:
import math

p = 1.0
flag = False
n = input().split()
for i in n:
    x = float(i)
    p = p * x

print(math.trunc(p))

Submission status: Wrong Answer

Solution code:
A, B = map(str, input().split())
A = int(A)
B1, B2, B3 = int(B[0]), int(B[2]), int(B[3])
ans = A*B1 + A*B2/10 + A*B3/100
print(int(ans))

Submission status: Wrong Answer

Solution code:
from math import *
a, b = input().split(' ')
ans = int(a) * float(b)
print(trunc(ans))

Submission status: Wrong Answer

Solution code:
mod = 1000000007
eps = 10**-9


def main():
    import sys
    from math import floor
    input = sys.stdin.readline

    a, b = map(float, input().split())
    print(floor(a * b))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
from math import *
a,b = map(float,input().split())
print(floor(a*b))

Submission status: Wrong Answer

Solution code:
# coding:utf-8

A, B = map(float, input().split(' '))

print(str(A*B).split('.')[0])

Submission status: Wrong Answer

Solution code:
import math
a,b = map(float,input().strip().split())
print(math.trunc(a*b))

Submission status: Wrong Answer

Solution code:
a,b=map(float,input().split())
print((a*(b*100))//100)

Submission status: Wrong Answer

Solution code:
import math
a = list(input().split())
print(math.floor(int(a[0])*float(a[1])))

Submission status: Wrong Answer

Solution code:
alist = input().split()
a=int(alist[0])
b=float(alist[1])

bb=int(b*100)
mae=a*bb
mae2=mae//100
print(mae2)

Submission status: Wrong Answer

Solution code:
import sys
import math

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
   
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a,b=map(str,input().split())

a=int(a)
b=float(b)

print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
# coding: utf-8
from math import floor


def solve(*args: str) -> str:
    a, b = map(float, args[0].split())

    return '{:.0f}'.format(floor(a*b))


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Submission status: Wrong Answer

Solution code:
A, B = map(float, input().split())
int(A*B)

Submission status: Wrong Answer

Solution code:
s = str(input())
d = s.split()
a = float(d[1])
b = int(d[0])
c = int(a * b)
print(c)

Submission status: Wrong Answer

Solution code:
import math
a,b=input().split()
a,b=float(a),float(b)
ans=math.floor(a*b)
print(ans)

Submission status: Wrong Answer

Solution code:
a, b = input().split()
ans = int(a)*int(float(b)*100)
ans = ans//100
print(ans)

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
import math

def main():
    A, B = map(float, input().split())
    print(int(A*B))

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
def main():
    a, b = [float(v) for v in input().split(' ')]
    ans = a * b
    print(int(ans))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
A,B = input().split()
A = int(A)
B = int(float(B) * 100)
o = A * B // 100
print(o)

Submission status: Wrong Answer

Solution code:
import math
A, B = map(float, input().split())
ans = math.floor(A * B)
print(ans)