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 sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(float, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))
import math
A, B = mi()
A = int(A)
print(int(A*B))

Submission status: Wrong Answer

Solution code:
A,B = [float(i) for i in input().split()]
A = int(A)
a = int(B)
b = int(10*B)-10*a
c = int(100*B)-100*a - 10*b
T = (A*b)%10
Y = (A*c)%100
U = (Y*(10*T))//100
print((A*a) + ((A*b)//10) + ((A*c)//100) + U)

Submission status: Wrong Answer

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

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

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

Submission status: Wrong Answer

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

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:
a,b=map(str,input().split())
b=int(float(b)*100)
a=int(a)*b
a//=100
print(int(a))

Submission status: Wrong Answer

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

ans = int(A) * B

print(int(math.floor(ans)))

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:

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

    ans = A*B
    ans = int(ans)

    print(ans)



if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import bisect
import collections
import copy
import functools
import heapq
import math
import sys
from collections import deque
from collections import defaultdict
input = sys.stdin.readline
MOD = 10**9+7

a,b = list(map(float,(input().split())))
a = int(a)
bu = math.floor(b)
bd = int((b - bu)*100)
#print(bu,bd)

ans = a*bu
#print(a,bu,bd)
pro = a*bd
pro //= 100

ans += pro
print(ans)

Submission status: Wrong Answer

Solution code:
import math

a,b = input().split()
a = int(a)
b = b.split(".")
b1 = int(b[0])
b2 = int(b[1])

ans = a*b1 + (b2*a)/100
print(math.floor(ans))

Submission status: Wrong Answer

Solution code:

in_d = input()

a, b = in_d.split()
a = float(a)
b = float(b)

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

answer=(a*b)//1

print(int(answer))

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

print(math.floor(B*A))

Submission status: Wrong Answer

Solution code:
a = [float(i) for i in input().split()]
print(int(a[0]*a[1]))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
b = [x for x in input().split()]
c = int(int(b[0])*float(b[1]))
print(c)

Submission status: Wrong Answer

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

print(floor(ans))

Submission status: Wrong Answer

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

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

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

Submission status: Wrong Answer

Solution code:
from decimal import Decimal, ROUND_DOWN
N, K = map(float, input().split())

print(Decimal(N*K).quantize(Decimal('0'), rounding=ROUND_DOWN))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(10**6)

#a = int(input())
#b = list(map(int, input().split()))
a, b = map(float, input().split())
#s = input()
#s,t = input().split()
#
#readline = sys.stdin.readline
#n,m = [int(i) for i in readline().split()]
#ab = [[int(i) for i in readline().split()] for _ in range(n)]

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

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:
from decimal import Decimal

A, B = input().split()
A = int(A)
B = float(B)
if A == 0 or B == 0.:
    print(0)
else:
    A = Decimal(A)
    B = Decimal(B)
    print(int(A * B))

Submission status: Wrong Answer

Solution code:
import math

A,B = input().split()
a = int(A)
b = int(float(B)*100)
print (math.floor(a * b / 100))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# C
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())
count=0
while A>10:
    A = A/10
    count = count+1

print(int(A*B*10**count))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from sys import stdin

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

print((A*BB)//100)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

from decimal import Decimal
from fractions import Fraction
import math
ans = int(a) * int(b*100)
print(ans,int(a),int(b*100))
#Decimal.from_float(a)*Decimal.from_float(b)
print(int(ans/100))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

ans = a* b

print(int(ans))

Submission status: Wrong Answer

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

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)
    t=a*b
    res=math.trunc(t)
    print(int(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:
# coding: utf-8
ab = input().split()
a = int(ab[0])
b = float(ab[1])
print(a*b//1)

Submission status: Wrong Answer

Solution code:
import math

b=input().split()
b1=int(b[0])
b2=float(b[1])

print(math.floor(b1*b2))

Submission status: Wrong Answer

Solution code:
import numpy as np
import math
import collections


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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

B=int(math.floor(B*10**2))
print(math.floor(A*B/10**2))

Submission status: Wrong Answer

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

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:
import math
l=list(input().split())
a=int(l[0])
b=float(l[1])
print(math.trunc(a*b))

Submission status: Wrong Answer

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
A, B = map(str, input().split())
strC = str(int(A) * float(B))
print(strC[:-2], end = "")

Submission status: Wrong Answer

Solution code:
import math


def main():
    a, b = input().split()
    a = int(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())
A =int(A)

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

Submission status: Wrong Answer

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

B=B*100

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
A, B = map(float, input().split())
f, i = math.modf(B)
print(int( A * i + (A * f) // 1))

Submission status: Wrong Answer

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

c = a*b

import math

print(math.floor(c))

Submission status: Wrong Answer

Solution code:
from sys import stdin
import re
A, B = [float(x) for x in stdin.readline().rstrip().split()]
pattern = "([0-9]*)\."
d = re.search(pattern, str((A * B)))
print(d.group(1))

Submission status: Wrong Answer

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

print(int(sum))

Submission status: Wrong Answer

Solution code:
import math

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


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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

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

print(math.floor(a * b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import numpy as np
a, b = map(float, input().split())
ab = np.array(a * b).astype(np.int64)
print(ab)

Submission status: Wrong Answer

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

ans = a * b / 10000

print(math.floor(ans))

Submission status: Wrong Answer

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

A=int(arr[0])
B=float(arr[1])
C=A * B
D=math.floor(C)
#print(C)
print(D)

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 = int(A)
    B = float(B)
    import math
    print( int(math.trunc(A*B)) )

main()

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:
import math
import sys
input = sys.stdin.readline


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 *
a, b = input().split()

a = Decimal(int(a))
b = Decimal(int(100*float(b)))
print(a*b//Decimal(100))

Submission status: Wrong Answer

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

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:
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)
b,c=int(b),int((b-int(b))*100)
c=(a*c)//100
print(a*b+c)

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split(' '))
# print(a, b)
ans = a * b
# print(ans)
ans = str(ans)
out = ""
for i in ans:
    if i == '.':
        break
    out += i

if (len(out) == 0):
    out = "0"
print(out)

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

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

Submission status: Wrong Answer

Solution code:
input_count = 0

import math

A, B = input().split()

A = int(A)
if '.' in B:
    B_a = int(B.split('.')[0])
    B_b_size = len(B.split('.')[1])
    B_b =  int(B.split('.')[1])
else:
    B_a = int(B)
    B_b_size = 0
    B_b = 0
ans_a = A * B_a
ans_b = A * math.pow(10, -1*B_b_size) * B_b
ans = ans_a + int(ans_b)
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
#include <CodeforcesSolutions.h>
#include <ONLINE_JUDGE <solution.cf(contestID = "1359",problemID = "C",method = "GET")>.h>
"""
    Author : thekushalghosh
    Team   : CodeDiggers
 
    I prefer Python language over the C++ language :p :D
        
    Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time,decimal
start_time = time.time()
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
    
def solve():
    a,b = invr()
    print(math.trunc(a * b))
                
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
 
def main():
    global tt
    if not ONLINE_JUDGE:
        sys.stdin = open("input.txt","r")
        sys.stdout = open("output.txt","w")
    t = 1
    for tt in range(t):
        solve()
    if not ONLINE_JUDGE:
        print("Time Elapsed :",time.time() - start_time,"seconds")
    sys.stdout.close()
    
#---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    return(input().strip())
def invr():
    return(map(float,input().split()))
 
#------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
def counter(a):
    q = [0] * max(a)
    for i in range(len(a)):
        q[a[i] - 1] = q[a[i] - 1] + 1
    return(q)
 
def string_counter(a):
    q = [0] * 26
    for i in range(len(a)):
        q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
    return(q)
 
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
    input = sys.stdin.readline
    
main()

Submission status: Wrong Answer

Solution code:
x = [_ for _ in input().split()]
a = int(x[0])
b = float(x[1])
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:
temp = input()
temp = temp.split(" ")
a = float(temp[0])
b = float(temp[1])
res = a*b
print(int(res))

Submission status: Wrong Answer

Solution code:
"""
N = list(map(int,input().split()))
S = [str(input()) for _ in range(N)]
S = [list(map(int,list(input()))) for _ in range(h)] 
print(*S,sep="")
"""

import sys
sys.setrecursionlimit(10**6)
input = lambda: sys.stdin.readline().rstrip()
inf = float("inf") # 無限


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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

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

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

print(ans)

Submission status: Wrong Answer

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

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 = map(float, input().split())
A = int(A)
a = int(A * B)
print(a)

Submission status: Wrong Answer

Solution code:
N = [float(e) for e in input().split()]
ans = N[0]*N[1]
print(int(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

list1 = input().split()
N = float(list1[0])
M = float(list1[1])

print(int(math.floor(N*M)))

Submission status: Wrong Answer

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

ans = Decimal(f'{a}') * Decimal(f'{int(b * 100)}')
ans /= 100
print(floor(ans))

Submission status: Wrong Answer

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

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 math
A,B = list(map(float, input().split()))
print(math.floor(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().split())
import math
#print(math.floor(a*b))
print(int(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 sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd, floor
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
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
#import numpy as np
from decimal import *

A, B = MAP()
print(floor(Decimal(A)*Decimal(B)))

Submission status: Wrong Answer

Solution code:
import math

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

c = math.floor(a * b)

print(int(c))

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

b, c, d = map(int, b.replace('.', ''))

ans = a * b
ans += int(a // 10 * c)
ans += int(a // 100 * d)

print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
#n = int(input())
#a,b = map(int,input().split())
#a_L = list(map(int,input().split()))

#n = int(input())
a,b = map(float,input().split())
b = int(b*100)
a = int(a)
#a_L = list(map(int,input().split()))

print(a*b//100)

Submission status: Wrong Answer

Solution code:
from sys import stdin
A, B = map(float, stdin.readline().rstrip().split())
A = int(A)
B = B*100
C = A*B
print(int(C/100))

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:
def main():
    A, B = map(float, input().split())
    ans = A * B

    print(int(ans))


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
if __name__=="__main__":
    A, B = input().split(' ')
    A = int(A)
    B = float(B)
    print(int(A*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 = int(a), float(b)
	print(math.trunc(a*b))

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
from sys import stdin
a,b = stdin.readline().rstrip().split() 
a=int(a)
b=float(b)
t = a*b

print(int(t))

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

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

Submission status: Wrong Answer

Solution code:
import sys
#from collections import defaultdict, deque, Counter
#import bisect
#import heapq
#import math
#from itertools import accumulate
#from itertools import permutations as perm
#from itertools import combinations as comb
#from itertools import combinations_with_replacement as combr
#from fractions import gcd
#import numpy as np

stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18

def main():
    A, B = map(float, stdin.readline().rstrip().split())
    ans = int((A*B) // 1)
    ans = str(ans)
    for i in range(len(ans)):
        print(int(ans[i]),end="")


main()

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

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

print(int(a*b))

Submission status: Wrong Answer

Solution code:
import sys

def input():
    return sys.stdin.readline().strip()

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

Submission status: Wrong Answer

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

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(int(a*b))

Submission status: Wrong Answer

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

B = int(B * 1000)
ab = int(int(A*B)/1000)
print(ab)

Submission status: Wrong Answer

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

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

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

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

Submission status: Wrong Answer

Solution code:

def q3():
    import math
    nums = input().split(" ")
    a = int(nums[0])
    b = int(float(nums[1]) * 100)
    print(math.floor((a * b) / 100))


q3()

Submission status: Wrong Answer

Solution code:
import math
A, B = map(str,input().split())
#print(A,B)

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

#print(A,B)
print(math.floor(A*B))

Submission status: Wrong Answer

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

import math
a = int(a)
b = float(b)
print(math.floor(a*b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

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

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:
A,B = [v for v in input().split()]

ans = 0
keta = 1.00

for c in B:
    if c == ".": continue

    ans += (int(c) * float(A)) * keta

    keta /= 10
print(int(ans))

Submission status: Wrong Answer

Solution code:
A,B = map(float, input().split())
count=0
while A<10:
    A = A/10
    count = count+1

print(int(A*B*10**count))

Submission status: Wrong Answer

Solution code:
import numpy as np

def resolve():
  S = input().split(" ")
  A = int(S[0])
  B = float(S[1])
  AB = np.asarray([A, B], dtype = np.float128)
  print(int(AB[0]*AB[1]))

if __name__ == "__main__":
    resolve()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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=input().split()
a=int(a)
b=float(b)
B=int(b*100)
c=a*B
print(c//100)