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:
import math


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

print(math.floor(a * b))

Submission status: Wrong Answer

Solution code:
A, B = [n for n in input().split()]
A = int(A)
B = float(B)

ans = int(A * B)
print(ans)

Submission status: Wrong Answer

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

print(int(float(A)*float(B)))

Submission status: Wrong Answer

Solution code:
x,y = map(float,input().split())
import math
y_ = y*100
xy = x * y_
print(math.floor(xy/100))

Submission status: Wrong Answer

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

ans = A * B // 100

print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

b *= 100

ans = a * b

print(int(ans/100))

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
a,b = input().split()
a = int(a)
b = float(b)
c = b - math.floor(b)
ans = math.floor(c * a)
c = math.floor(b)
print(ans + c * a)

Submission status: Wrong Answer

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

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

ans = A*B
print(int(ans))

Submission status: Wrong Answer

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

C = A * B

print(math.floor(C))

Submission status: Wrong Answer

Solution code:
import numpy as np
A, B = input().split()
A = np.array(A).astype(np.int64)
B = (np.array(float(B))*100).astype(np.int64)

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

Submission status: Wrong Answer

Solution code:
# C

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

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

Submission status: Wrong Answer

Solution code:
import math

l1 = list(map(float, input().split()))
print(math.floor(l1[0]*l1[1]))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

A = int(A)
ans = math.floor(A*B)
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

print((a*b)//100)

Submission status: Wrong Answer

Solution code:
import sys

A, B = sys.stdin.readline().rstrip().split()
A = int(A)
b_1, b_2 = map(int, B.split('.'))

x = A * b_1 + A * b_2 / 100
print(int(x))

Submission status: Wrong Answer

Solution code:
#from fractions import Fraction
from decimal import Decimal

import math
A,B = input().split()

b = Decimal(float(B))
#b = Fraction(float(B))

tmp = Decimal(int(A))*b
print(int(math.floor(tmp)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
def multi(a, b):
    """
    """
    a = str(a)
    b = str(b)
    num = 0
    tmp = a.find('.')
    if tmp != -1:
        num = num + len(a) - tmp - 1
    tmp = b.find('.')
    if tmp != -1:
        num = num  + len(b) - tmp -1
    a1 = a.replace(".", "")
    b1 = b.replace(".", "")
    a1 = int(a1)
    b1 = int(b1)
    c = a1 * b1
    ans = [c, num]
    c = str(c)
    res = c[:len(c)-num]
    tmp = c[len(c)-num:]
    res = res + '.' + tmp
    return res, ans
a, b = input().split()
c= multi(a, b)
ans=str(c[1][0])[:-2]
print(ans)

Submission status: Wrong Answer

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

print(int(float(a)*float(b)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
import math
from collections import deque
from collections import defaultdict

def main():
    a,b = list(map(float,sys.stdin.readline().split()))
    print(int(a*b//1))
    return 0

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

A = int(A)
B = float(B)*100
B = int(B)

ans = A*B/100
print(int(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub, or_

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

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

def read_int_n():
    return list(map(int, input().split()))

def read_float():
    return float(input())

def read_float_n():
    return list(map(float, input().split()))

def read_str():
    return input().strip()

def read_str_n():
    return list(map(str, input().split()))

def error_print(*args):
    print(*args, file=sys.stderr)


def main():
    a, b = read_float_n()
    print(math.floor(a * math.floor(b) + (b - math.floor(b)) * a))

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-

import sys
import math


debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        # for line in sys.stdin:
        #     lines.append(line)
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    tokens = lines[0].split(' ')
    a = int(tokens[0])
    b = float(tokens[1])

    return (a, b)


def solve(a, b):
    
    return int(math.floor(a * round(b, 2)))
    


def main():
    # 出力
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys

a, b = [float(num) for num in input().split()]

print(str(a*b).split(".")[0])

Submission status: Wrong Answer

Solution code:
import math 
a, b = map(float, input().split())
if a*b>10**6:
    a =int(100*a)
    b = int(100*b)
    c = a*b
    d = str(c)[:-4]
    print(int(d))
else:
    print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

N = list(map(str, input().split()))

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

print (math.floor(a*b))

Submission status: Wrong Answer

Solution code:
# coding: utf-8
import math
a, b = input().split()
print(math.floor(int(a) * float(b)))

Submission status: Wrong Answer

Solution code:
# coding: utf-8
#C
a, b = map(float,input().split())

ans = round(a,2)*round(b,2)
print(int(ans))

Submission status: Wrong Answer

Solution code:
'''
    handle - pruvi007
    questionName - 
    Contest - 
    Topic - 
    Platform - 
'''
from sys import stdin, stdout
from collections import defaultdict

def main():
    a = stdin.readline().split('\n')[0]
    A,B = a.split()
    A = float(A)
    B = float(B)
    import math
    print( math.trunc(A*B) )

main()

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 = input().split()
A=int(A)
B=float(B)

print(int(A*B))

Submission status: Wrong Answer

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

def fl(x):
    digits = 5
    form = '%.'+str(digits-1)+'e'
    return float((form % x))

print(math.floor(A * fl(B)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
n = input()
lst = n.split()
ans = int(lst[0])*float(lst[1])

print(int(ans))

Submission status: Wrong Answer

Solution code:
import sys
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:
A, B = input().split(' ')

A = A.replace('.', '')
B = B.replace('.', '')

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

result = int(A * B / 100)

print(result)

Submission status: Wrong Answer

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

A = int(A)
B = int(math.floor(float(B) * 100))
print((A * B) // 100)

Submission status: Wrong Answer

Solution code:
import math
n,k = map(float,input().split())
if n == 0.0:
    print(0)
    exit()
    
if k == 0.0:
    print(0)
    exit()

a = math.floor(n*k)
print(a)

Submission status: Wrong Answer

Solution code:
import sys
import math

a,b = (i for i in input().split())

a = int(a)
b = float(b)
#b2 = b1 - int(b1)

c = a*b

#print(c)
#print(type(c))
ans = math.floor(c)

print(ans)

Submission status: Wrong Answer

Solution code:
import math

A, B = map(str, input().split())
A = int(A)
B = float(B)
ans = A * B

print(int(ans))

Submission status: Wrong Answer

Solution code:
# 2106~
# 10^2 より大きい部分と，10^2より小さい部分に分ける
A,B=input().split()
A = int(A)
B = float(B)
if A < 10**2:
    print((A*B))
    exit()
Ag = int(A/(10**2))
Bg = int(B*(10**2))
ABg = Ag*Bg
Al = A - Ag*(10**2)
Abl = int(Al*B)
print(ABg+Abl)

Submission status: Wrong Answer

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

bs = str(b)
bs1, bs2 = map(str, bs.split("."))
digi = len(bs2)

ans = a * (b * 10**digi) // 10**digi
print(int(ans))

Submission status: Wrong Answer

Solution code:
import sys
import math
def II(): return int(input())
def MI(): return input().split()
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
def RN(N): return [input().strip() for i in range(N)]


def main():
    A, B = MI()
    A = float(A)
    B = float(B)
    print(math.floor(A*B))
    


if __name__ == "__main__":
	main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

a, b = [float(i) for i in input().split()]
a = int(a)
ans = a*b
#print(type(ans))
ans = math.floor(ans)
#print(type(ans))
ans = int(ans)
#print(type(ans))
print(ans)

Submission status: Wrong Answer

Solution code:
import math

a, b = input().split()
res = int(a) * round(float(b) * 100) / 100
print(int(res))

Submission status: Wrong Answer

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

print(int(A * B))

Submission status: Wrong Answer

Solution code:
A,B=input().split()
A=int(A)
B=float(B)
print('{:.0f}'.format(A*B))

Submission status: Wrong Answer

Solution code:
import math

a, b = map(float, input().split())
if a == 0 or b == 0:
    print(0)
else:
    print(int(a*b))

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys  # {{{
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools
# }}}

# pre-defined{{{
sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  # can also use string module
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe
# }}}

def solve():
    a, b = map(float, input().split())
    print(int((a*b) // 1))
    return 0

if __name__ == "__main__":# {{{
    solve()

# vim: set foldmethod=marker: }}}

Submission status: Wrong Answer

Solution code:
import os
import heapq
import sys
import math
import operator
from collections import defaultdict
from io import BytesIO, IOBase
# def gcd(a,b):
#     if b==0:

#         return a
#     else:
#         return gcd(b,a%b)
def main():
    # mod=10**9+7
    #for _ in range(int(input())):
    a,b=list(input().split())
    a=int(a)
    b=float(b)
    res=math.trunc(a*b)
    print(res)








BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
from sys import stdin

A, B = [float(x) for x in stdin.readline().rstrip().split()]

print(int(A*B))

Submission status: Wrong Answer

Solution code:
s_in=input().split()
A=int(s_in[0])
B=float(s_in[1])

c=int(A*B)
print(c)

Submission status: Wrong Answer

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

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:

if __name__ == '__main__':
    a = [float(i) for i in input().split()]
    b= int(a[0])
    c = int(a[1]*100)
    d = b*c
    e = d //100
    print(e)

Submission status: Wrong Answer

Solution code:
li = input().split()
x = int(li[0])
y = float(li[1])
x *= y  
print(int(x))

Submission status: Wrong Answer

Solution code:
a,b=map(float,input().split())
print(str(a*b)[:-2])

Submission status: Wrong Answer

Solution code:
import sys

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

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

print(int(ans))

Submission status: Wrong Answer

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

l = readline().split()

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

ans = A*B
if ans < 1:
  ans = 0
else:
  ans = str(int(ans * 100))
  ans = ans[:-2]
print(ans)

Submission status: Wrong Answer

Solution code:
AB = list(map(float, input().split()))

result = AB[0] * AB[1]
print(int(result))

Submission status: Wrong Answer

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

# print(a, b)
ab = a * b // 100

print(ab)

Submission status: Wrong Answer

Solution code:
# coding: utf-8
import math

a = list(map(float, input().split()))
print(math.floor(a[0] * a[1]))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

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 = input().split()
a = int(a)
b = float(b)
ans = int(a*b)
print(ans,end = "")

Submission status: Wrong Answer

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

C=A*B
print(int(C//100))

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

from decimal import *

root2 = Decimal(a) * Decimal(b)
n = 0 
y = Decimal(str(root2)).quantize(Decimal(str(10**(n*-1))), rounding=ROUND_DOWN)
print(y)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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 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

temp = input().split(" ")
A = int(temp[0])
B = int(float(temp[1])*100)
print(int(A*B/100))

Submission status: Wrong Answer

Solution code:
a,b = [float(e) for e in input().split(" ")]
r = a*b
print(int(r))

Submission status: Wrong Answer

Solution code:
import math

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

ret = (int)(a) * b
ret = math.floor(ret)

print("{}".format(ret))

Submission status: Wrong Answer

Solution code:
import math

A, B = [float(i) for i in input().split(' ')]
print(int(math.floor(A * B)))

Submission status: Wrong Answer

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

print(int(A*B))

Submission status: Wrong Answer

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

print(int(A*B))

Submission status: Wrong Answer

Solution code:
import math
li = list(map(str,input().split()))
a = int(li[0])
b = int(float(li[1])*100)
ans = (a*b) // 100
print(int(ans))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:

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


A = int(A)
B = int(B*100)
print(int(A*B/100))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

A,B=map(float,input().split())
print(int(A*B-((A*B)%1)))

Submission status: Wrong Answer

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


def main():
    a, b = map(float, input().split())
    a = int(a)
    print(int(a * b))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
data = input().rstrip().split(" ")
A = int(data[0])
B = float(data[1])*100
calc = A*B
print(math.floor(calc/100))

Submission status: Wrong Answer

Solution code:
import math

A, B = map(float, input().split())
B *= 100
ans = A*B
ans = int(ans // 100)
#ans = math.floor(ans)
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

a = int(a)
print(int(a*b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

import math

B = int(B*100)

#print(B)
#print(int(A))

print(math.floor(A*B))

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())
A = int(A)
B = int(B*100)
ans = A*B
ans = ans//100
print(ans)

Submission status: Wrong Answer

Solution code:
sAB = input().split()
sAB[0] = int(sAB[0])
sAB[1] = float(sAB[1])

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

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 sys

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

sys.setrecursionlimit(10**7)

ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

import math

a, b = nfa()

print(int(a * b))

Submission status: Wrong Answer

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

print(res)

Submission status: Wrong Answer

Solution code:
A,B=map(str,input().split())
A=int(A)
B_1=int(B.split(".")[0])
B_2=int(B.split(".")[1][0])
B_3=int(B.split(".")[1][1])

sum1=0
sum2=0
sum3=0

sum1=A*B_1
sum2=int((A/10)*B_2)
sum3=int((A/100)*B_3)

sum=sum1+sum2+sum3

print(sum)

Submission status: Wrong Answer

Solution code:
A, B = [float(x) for x in input().split()]

res = A * B

print(str(int(A*B)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import sys
# from random import choice,randint
# from bisect import bisect_left as bl             
# from bisect import bisect_right as br  
# from collections import deque,defaultdict,Counter
from math import sqrt,floor,ceil
# from itertools import combinations,permutations
# from heapq import heapify,heappop,heappush,heappushpop
# inp=sys.stdin.readline
# out=sys.stdout.write
# flsh=sys.stdout.flush
# ranomd string generator --> a = ''.join(random.choices(string.ascii_lowercase, k = 1000))
 
sys.setrecursionlimit(10**9)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod1=998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

#fact=[1]
#for i in range(1,100001):
#    fact.append((fact[-1]*i)%mod)
#ifact=[0]*100001
#ifact[100000]=pow(fact[100000],mod-2,mod)
#for i in range(100000,0,-1):
#    ifact[i-1]=(i*ifact[i])%mod
 
def MI(): return map(int, inp().strip().split())
def LI(): return list(map(int, inp().strip().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]
def LI_(): return [int(x)-1 for x in inp().strip().split()] #use list comprehension for loops
def LF(): return [float(x) for x in inp().strip().split()] #use try and except for dictionaries
def LS(): return inp().strip().split() #declare local variables ... for functions assing them to variables
def I(): return int(inp().strip()) # before using example ... func = len for using len() funtcion
def F(): return float(inp().strip()) #sort dictionary after zipping
def S(): return inp().strip() #use map function for mapping list to a fuction
def pf(s): return out(s+'\n')
def JA(a, sep): return sep.join(map(str, a)) #use this for string concatenation
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def modinv(n,p):return pow(n,p-2,p)
def ncr(n,r,p):                      
    t=((fact[n])*((ifact[r]*ifact[n-r])%p))%p
    return t

####################Actualcode################################
def solve():
    a,b=LF()
    ans = a*b
    # print(ans)
    print(round(floor(ans)))

def main():
    solve()


######## Python 2 and 3 footer by Pajenegod and c1729
py2 = round(0.5)
if py2:
    from future_builtins import ascii, filter, hex, map, oct, zip
    range = xrange

import os, sys
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)

inp = lambda: sys.stdin.readline().rstrip('\r\n')
out = lambda x: sys.stdout.write(x)
flsh= lambda: sys.stdout.flush()

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
a = int(a)
b1 = int(b)
b2 = int(b*10 % 10)
b3 = int(b*100 % 10)

print(int(a*b1*100+a*b2*10+a*b3)//100)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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


class Solution:
    def main(self):
        a, b = input().split()
        print(math.floor(float(b) * int(a)))

# Run main
if __name__ == '__main__':
    Solution().main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
import math

def f(x):
    if type(x) is float:
        return x
    else:
        return x


def main():
    a, b = map(f, input().split())
    
    c = int(a) * float(b)
    
    print(math.floor(c))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math

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

s=math.floor(A*B)

print(s)

Submission status: Wrong Answer

Solution code:
import math

n, m = map(float, input().split())
n = int(n)
print(int(math.floor(n*m)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys

sys.setrecursionlimit(10000000)
import os
import math
import bisect
import collections
import itertools
import heapq
import re
import queue

# import fractions

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, B = fl()
    print(int(math.floor((int(A*100) * int(B*100))//10000)))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
def main():
    a, b = input().split(' ')
    a = int(a)
    lst_b = [int(b[int(i)]) for i in [0, 2, 3]]

    ans = 0
    ans += a * lst_b[0]
    ans += a * lst_b[1] // 10
    ans += a * lst_b[2] // 100
    print(ans)


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
str = input()

str2 = str.split(" ")

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


res = round((float(A)*float(B)))
if res != 0:
    res = round(res - 0.5)


print(res)

Submission status: Wrong Answer

Solution code:
import math
A,B = list(input().split())
A = A + '.00000000000000001'
B = B + '00000000000000001'
print(math.floor(float(A)*float(B)))

Submission status: Wrong Answer

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

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

print(int(A*B))