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

Solution code:
import math
from decimal import *

ab = input().split()
a = int(ab[0])
b = Decimal(ab[1])

print(math.floor(a * b))

Submission status: Accepted

Solution code:
from decimal import *

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

print(int(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
from io import StringIO
import unittest
import math
from decimal import Decimal, ROUND_FLOOR

def resolve():
    # s = input()
    # n = int(input())
    a, b = map(float, input().split())
    # l = [list(map(int, input().split())) for _ in range(n)]

    ans = Decimal(str(a)) * Decimal(str(b))

    print(ans.quantize(Decimal('0'), rounding=ROUND_FLOOR))

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)


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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal


A, B = input().split()

A = Decimal(A)
B = Decimal(B)

result = Decimal(A * B)

print(math.floor(result))

Submission status: Accepted

Solution code:
import math
import decimal
a, b = input().split()
x = decimal.Decimal(a)
y = decimal.Decimal(b)
c = x*y
print(math.floor(c))

Submission status: Accepted

Solution code:
def main():
    from builtins import int, map, list, print
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = (lambda: (sys.stdin.readline()).rstrip())
    input_list = (lambda: input().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

    A, B = input_list()
    a = int(A)
    B = str(B)
    B = B.replace(".", "")
    b = int(B)
    ans = a * b
    ans = str(ans)
    ans = ans[:-2]
    if ans == "":
        print(0)
    else:
        print(ans)



if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
A,B=input().split()
A=Decimal(A)
B=Decimal(B)
print(math.floor(A*B))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math
from decimal import *

def main():
    a, b = input().split()

    a, b = Decimal(a), Decimal(b)

    print((a * b).quantize(Decimal('0'), rounding=ROUND_DOWN))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal
a,b=input().split()
a=int(a)
b=Decimal(b).quantize(Decimal('0.01'))
ans=int(a*b)
print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal

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

ans = int(A*B)

print(ans)

Submission status: Accepted

Solution code:
s,ss=input().split()
ss=ss.replace(".","")
i=int(s)
ii=int(ss)
print(i*ii//100)

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

A = input().split()
result = Decimal(A[0]) * Decimal(A[1]) 
print(math.floor(result))

Submission status: Accepted

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

print(a*b//100)

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_DOWN

N, K = map(Decimal, input().split())

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

Submission status: Accepted

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

from decimal import Decimal

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

Submission status: Accepted

Solution code:
from decimal import *
a,b=input().split()
a=Decimal(a)
b=Decimal(b)
print(str(a*b)[:-3])

Submission status: Accepted

Solution code:
A,B = map(str,input().split())
A = int(A)
if B[-2] == ".":
    B = B[:-2] + B[-1] + "0"
elif B[-3] == ".":
    B = B[:-3] + B[-2:]
else:
    B = B + "00"

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

if len(ans) <= 2:
    print("0")
else:
    print(ans[:-2])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
a, b = input().split()
a = int(a)
for i in range(1000):
    s = '{:4.2f}'.format(i / 100)
    # print(s)
    if s == b:
        x = i
        break
print(a * x // 100)

Submission status: Accepted

Solution code:
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()

A,B=input().split()
A=int(A)
if not "." in B:
    print(A*int(B))
else:

    if B[-2]==".":
        Z=""
        for b in B:
            if not b==".":
                Z+=b
        B=int(Z)
        C=A*int(B)
        C//=10
        print(C)
    elif B[-3]==".":
        Z=""
        for b in B:
            if not b==".":
                Z+=b
        B=int(Z)
        C=A*int(B)
        C//=100
        print(C)

Submission status: Accepted

Solution code:
from decimal import Decimal
A, B = input().split()

A = int(A)
B = Decimal('{}'.format(B))

print(int(A * B))

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_DOWN

A,B=input().split()
A=Decimal(A).quantize(Decimal('0'), rounding=ROUND_DOWN)
B=Decimal(B).quantize(Decimal('0.01'), rounding=ROUND_DOWN)
C=A*B
C=Decimal(str(C)).quantize(Decimal('0'), rounding=ROUND_DOWN)
print(C)

Submission status: Accepted

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

a_ = Decimal(a)
b_ = Decimal(b)
c = a_ * b_
print(c.quantize(Decimal('0'), rounding=ROUND_DOWN))

Submission status: Accepted

Solution code:
import numpy as np
a,b =list(input().split(" "))
a = np.int(a)
b = np.float128(b)
ret = int(np.floor(a * b))

print(ret)

Submission status: Accepted

Solution code:
import math
import decimal

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

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

Submission status: Accepted

Solution code:
a_s, b_s = input().split()

b_s = b_s.replace(".", "")

s = str(int(a_s) * int(b_s))
if len(s) > 2:
    print(str(int(a_s) * int(b_s))[:-2])
else:
    print(0)

Submission status: Accepted

Solution code:
import sys
import math
import collections
import decimal
from collections import deque
from functools import reduce
import heapq
#n = int(input())
a, b = map(str, sys.stdin.readline().split())
#n = input()
#a = list(map(int, sys.stdin.readline().split()))

x = int(a)
y = decimal.Decimal(b)
        
print(math.floor(x*y))

Submission status: Accepted

Solution code:
from decimal import Decimal
a, b = map(str, input().split())
num = list(str(Decimal(a) * Decimal(b)))
ans = ''
for i in num:
    if i == '.':
        break
    ans += i
print(ans)

Submission status: Accepted

Solution code:
from decimal import *
import math
A, B = input().split()
print(math.floor(Decimal(A) * Decimal(B)))

Submission status: Accepted

Solution code:
from decimal import Decimal
ab = input().split()
a,b = int(ab[0]),Decimal(ab[1])
answer = int(a*b)
print(answer)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from fractions import Fraction
import math 
N, M = input().split()
N = Fraction(N)
M = Fraction(M)
ans = N * M

print(int(ans))

Submission status: Accepted

Solution code:
from decimal import Decimal

a,b = map(str,input().split())
print(int(Decimal(a)*Decimal(b)))

Submission status: Accepted

Solution code:
from decimal import *
from math import floor
A, B = map(float, input().split())
temp = Decimal(str(A)) * Decimal(str(B))
print(floor(temp))

Submission status: Accepted

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

print(a * b100 // 100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
A, B = input().split()
B = Decimal(B) 
print(int(int(A)*int(B*100)/Decimal('100')))

Submission status: Accepted

Solution code:
X,Y=input().split() 
Y=Y.replace(".","")
print(int(X)*int(Y)//100)

Submission status: Accepted

Solution code:

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
if B_b_size == 0:
    ans = A * B_a
elif B_b_size == 1:
    ans_a = A * B_a
    ans_b = A * B_b 
    ans_b = ans_b // 10
    ans = ans_a + ans_b
else:
    ans_a = A * B_a
    ans_b = A * B_b 
    ans_b = ans_b // 100
    ans = ans_a + ans_b
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *
A, B = map(str, input().split())
print(Decimal(A)*Decimal(B)//1)

Submission status: Accepted

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

Submission status: Accepted

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

from decimal import Decimal

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

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
b = int(b[0]+b[2:])

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import decimal
A,B=input().split()
A=int(A)
B=decimal.Decimal(B)
c=A*B
c=c.quantize(decimal.Decimal('1'), rounding=decimal.ROUND_FLOOR)
print(c)

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
A, B = input().split()
A = int(A)
B = Decimal(B)
ans = math.floor(A * B)
print(ans)

Submission status: Accepted

Solution code:
import sys                                                            
import decimal                                                        
a,b = [decimal.Decimal(x) for x in sys.stdin.readline().split(" ")]   
c = a * b                                                             
print(c.quantize(decimal.Decimal('1.'), rounding=decimal.ROUND_DOWN))

Submission status: Accepted

Solution code:
def main():
    import decimal
    A , B = map(decimal.Decimal, input().split())
    C = decimal.Decimal(A) * decimal.Decimal(B)
    #print(C)
    D = str(C)
    D = D.split(".")[0]
    #print(D)
    E = int(D)
    print(E)



if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a,b = map(float,input().split())
b = round(b,2)
c = b - b // 1
c = round(c,2)
b = int(b)
#print(b,c)
c *= 100
#print(format(c, '.20f'))
a = round(a,0)
a =int(a)
#print(a,b)
ans = a * b
p = 0
c = int(c)
for i in range(c):
    p += a
#print(p)
ans += round(a * c // 100 ,3)
#print(format(c*a, '.20f'))
ans = int(ans)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
s = input()
a, b = s.split()
a = int(a)
b = Decimal(b)

print(int(a * b))

Submission status: Accepted

Solution code:
from decimal import Decimal
ls = list(input().split())
a = int(ls[0])
b = ls[1]
b = Decimal(b)
ans = (a * b)
ans = int(ans)

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
from copy import deepcopy
from functools import reduce
from fractions import gcd
import math
import itertools
from collections import Counter
from itertools import chain  ##list(chain.from_iterable(l)) ##flatten
from heapq import heappush, heappop
import bisect
from decimal import Decimal

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

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

print(ans)

Submission status: Accepted

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

if A == 0 or B == '0.00':
    ans = 0
else:
    ans = A*int(B[0])*100 + A*int(B[2])*10 + A*int(B[3])
    ans = str(ans)
    if len(ans)-2 <= 0:
        ans = 0
    else:
        ans = ans[0:len(ans)-2]
print(ans)

Submission status: Accepted

Solution code:
from math import floor as f
a,b=input().split()
b=int(str(b).replace(".",""))
print(int(a)*b//100)

Submission status: Accepted

Solution code:
import sys
import decimal

a,b = input().split()
Da = decimal.Decimal(a)
Db = decimal.Decimal(b)
res = Da*Db

print(int(res))

Submission status: Accepted

Solution code:

def main():
    a,b = input().split()
    a = int(a)
    answer = 0
    b_big,b_small = map(int,b.split("."))

    answer += b_big * a
    answer += b_small * a // 100
    print(answer)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from decimal import *
A, B = input().split()
A = Decimal(A)
B = Decimal(B)
import math
ans = A*B
print(int(math.floor(ans)))

Submission status: Accepted

Solution code:
A, B = input().split()
B = B.split('.')
if B[0]=='0':
    B = int(B[1])
else:
    B = int(B[0]+B[1])
A = int(A)
ans = A*B//100
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
b = b.replace('.', '')
c = 0
for i, n in enumerate(map(int, reversed(b))):
    c += n * 10 ** i

ans = a * c
print(ans // 100)

Submission status: Accepted

Solution code:
def mp(): return map(int, input().split())
def lmp(): return list(map(int, input().split()))

import math
a,b = map(str,input().split())
a = int(a)
b = b[0]+b[2]+b[3]
b = int(b)
print(a*b//100)

Submission status: Accepted

Solution code:
from fractions import Fraction
a,b=input().split()
a=Fraction(int(a),1)
b=Fraction(int(b[0]+b[2:]),100)
print(int(a*b))

Submission status: Accepted

Solution code:
a,b = input().split()
a = int(a)
b2 = 0
for i in b:
	if i == '.': continue
	else:
		b2 = 10*b2+int(i)
print((a*b2)//100)

Submission status: Accepted

Solution code:
A,B=map(str,input().split())
a=int(A)
b=int(B[0]+B[2]+B[3])
print(a*b//100)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

class UnionFindEx:
    def __init__(self, size):
        #正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   #負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    #サイズ更新
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    A,B=map(int, input().replace('.', '').split())
    print(A*B//100)






main()

Submission status: Accepted

Solution code:
from decimal import Decimal
import math

A,B = map(float,input().split())
tmp_A = str(A)
tmp_B = str(B)
f1 = Decimal(tmp_A)
f2 = Decimal(tmp_B)
print(math.floor(f1*f2))

Submission status: Accepted

Solution code:
A, B = input().split()
A = int(A)
B_1, B_2 = B.split(".")
B_10 = int(B_1)*100 + int(B_2)

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

Submission status: Accepted

Solution code:
from math import floor
import decimal

a, b = input().split()
a = decimal.Decimal(a)
b = decimal.Decimal(b)
ans = floor(a*b)
print(ans)

Submission status: Accepted

Solution code:
# created by dipta10

a, b = map(str, input().split(' '))
a = int(a)
x = ""
for i in b:
    if i == '.':
        continue
    x += i
b = int(x)

# print(a, b)
ans = a * b
ans = str(ans)
# print(ans)
if (len(ans) <= 2):
    print ('0')
else:
    print(ans[:-2])

Submission status: Accepted

Solution code:
import math
import decimal

list1 = input().split()
N = decimal.Decimal(list1[0])
M = decimal.Decimal(list1[1])
a = N*M

val_pi_d = decimal.Decimal(a)
val_floor_d = val_pi_d.quantize(decimal.Decimal('0'), rounding=decimal.ROUND_FLOOR)
print(int(val_floor_d))

Submission status: Accepted

Solution code:
import decimal

A,B = input().split()

a = decimal.Decimal(A)
b = decimal.Decimal(B)

ans = decimal.Decimal(a*b)

print(int(ans))

Submission status: Accepted

Solution code:
from decimal import *

A,B = input().split()
fA = Decimal(A)
fB = Decimal(B)
ans = int(fA*fB)
print(ans)

Submission status: Accepted

Solution code:
A,B  = input().split()
A = int(A)
C,D=B.split('.')
B=C+D
B=int(B)
print(A*B//100)

Submission status: Accepted

Solution code:
from decimal import Decimal,getcontext
import math
getcontext().prec = 100

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

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

Submission status: Accepted

Solution code:
from decimal import *
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b=STRM()
    a=Decimal(int(a))
    b=b[0]+b[2:4]
    b=Decimal(int(b))
    print(a*b//Decimal(100))
    
if __name__ == '__main__':
    do()

Submission status: Accepted

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

a2 = round(int(a),len(a))
b2 = b.replace('.','')
b3 = round(int(b2),len(b2))
#print(a2)
#print(b2)
c = a2 * b3
c2 = str(c)
#print(c2)
if len(c2)<3:
    print(0)
else:
    print(c2[0:-2])

Submission status: Accepted

Solution code:
from decimal import Decimal
a,b = map(float, input().split())
ans = Decimal(str(a)) * Decimal(str(b))

  
print(int(ans))

Submission status: Accepted

Solution code:
import math

a, b = map(float, input().split())
b = (b+10**(-6))*100
ab = str(int(a)*int(b))
if len(ab) <= 2:
    print(0)
else:
    ans = int(ab[:-2])
    print(ans)

Submission status: Accepted

Solution code:
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))

i=input()

a,b=i.split(' ')
from decimal import Decimal
print(int(Decimal(a) * Decimal(b)))

Submission status: Accepted

Solution code:
a, b = map(str, input().split(' '))
a = int(a)
x = ""
for i in b:
    if i == '.':
        continue
    x += i
b = int(x)

# print(a, b)
ans = a * b
ans = str(ans)
# print(ans)
if (len(ans) <= 2):
    print ('0')
else:
    print(ans[:-2])

# ans = str(ans)
# out = ""
# for i in ans:
#     if i == '.':
#         break
#     out += i

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *
d1 = Decimal("0.01")
A, B = input().split()
a = Decimal(A)
b = Decimal(B)

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

Submission status: Accepted

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

print(A*B//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#n, m, q = map(int, input().split())
#List = list(map(int, input().split()))
#req = [list(map(int, input().split())) for _ in range(q)]
#t = t[:-1]
#print(ans[j], end = "") 改行無しで出力
#[0]*n
import math
from decimal import *
a, b = input().split()
ans = Decimal(a)*Decimal(b)


print(Decimal(ans).quantize(Decimal("0"), rounding=ROUND_DOWN))

Submission status: Accepted

Solution code:
from decimal import Decimal
l = list(input().split())
a = int(l[0])
b = Decimal(l[1])
print(int(a*b))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

A, B = map(Decimal, input().split())
 
A = int(A)
B *= 100
B = int(B)

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

Submission status: Accepted

Solution code:

import sys
input = sys.stdin.readline


class Solution:
    def main(self):
        a, b = input().split()
        a = int(a)
        b1,b2 = b.split(".")

        ans = a * int(b1)
        c = ((a * int(b2[0]) * 10) + (a * int(b2[1])) )// 100

        print(ans + c)

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

Submission status: Accepted

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

from decimal import Decimal
a = Decimal(a)
b = Decimal(b)
ans = a*b

import math
print(math.floor(ans))

Submission status: Accepted

Solution code:
a,b = input().split()
na = int(a)
nb100 = (int(b[0])*100+int(b[2:]))
ans = na*nb100
print(ans//100)

Submission status: Accepted

Solution code:
from decimal import Decimal

A,B = input().split()
a = Decimal(A)
b = Decimal(B)
print(int(a*b))

Submission status: Accepted

Solution code:
import math
import string
import collections
from collections import Counter
from collections import deque
from decimal import Decimal


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
ab = list(input().split())
# print(ab)
#a = int(ab[0])
ans = Decimal(ab[0]) * Decimal(ab[1])
print(math.floor(ans))

Submission status: Accepted

Solution code:
temp = input().split(" ")
A = int(temp[0])

i = int(temp[1].split(".")[0])
j = int(temp[1].split(".")[1])

x = A * i
y = A * j // 100

print(x+y)

Submission status: Accepted

Solution code:
A, B = input().split()
A = int(A)
if B[0] == "0":
    B = int(B[2:])
else:
    B = int(B.replace(".", ""))

print(A*B//100)

Submission status: Accepted

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

Submission status: Accepted

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


def solve(A: int, B: str):
    b=int(B[0])*100+int(B[2:])
    print(b*A//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 = str(next(tokens))  # type: str
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A, B = input().split()
A = int(A)
if B == '0':
    print(0)
    exit()
B = int(B[0]+B[2:])

print((A * B) // 100)

Submission status: Accepted

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

a = int(a)
nb = int(b[0])

sb = int(b[2:4])

p = a * sb
p = p//100

print(p + a * nb)

Submission status: Accepted

Solution code:
from decimal import Decimal
A,B=input().split()
a=Decimal(A)
b=Decimal(B)
print(int(a*b))

Submission status: Accepted

Solution code:

import math
from decimal import Decimal
ab = list(map(str,input().split()))
a=Decimal(ab[0])
b=Decimal(ab[1])

print(math.floor(a*b))

Submission status: Accepted

Solution code:
from decimal import Decimal
import math
A, B = input().split()
A = Decimal(A)
B = Decimal(B)
ans = A*B
print(math.floor(ans))

Submission status: Accepted

Solution code:

def parse():
  splited = input().split(" ")
  A = int(splited[0])
  B_n = splited[1].split(".")[0]
  B_d = splited[1].split(".")[1]
  B = int(B_n) * 100 + int(B_d)
  return A, B

def main():
  A, B = parse()
  print(int(A * B // 100))

if __name__ == "__main__":
  main()

Submission status: Accepted

Solution code:
from decimal import Decimal
from math import floor
def main():
    a, b = input().split()
    a = Decimal(a)
    b = Decimal(b)
    r = floor((a * b))
    print(int(r))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
import decimal

A, B = input().split(" ")
A = decimal.Decimal(A)
B = decimal.Decimal(B)

print(math.floor(A * B))

Submission status: Accepted

Solution code:
a,b = input().split()
a = int(a)
b0 = int(b[0])
b1 = int(b[2])
b2 = int(b[3])
r = str(a*100*b0 + a*10*b1 + a*b2)
if len(r) < 3:
    print(0)
else:
    print(r[:-2])

Submission status: Accepted

Solution code:
from decimal import Decimal
A,B=input().split()
a=Decimal(A)
b=Decimal(B)
print(int(a*b))

Submission status: Accepted

Solution code:
from decimal import Decimal
a, b = input().split()
a=int(a)
b=Decimal(b)
print(int((a*b)//1))

Submission status: Accepted

Solution code:
A,B = map(float,input().split())
A = int(A)
import math
import decimal
B = decimal.Decimal(str(round(B,2)))
print(math.floor(A*B))

Submission status: Accepted

Solution code:
EPS=10**-8
A,B=input().split()
A=int(A)
B=int(float(B)*100+EPS)
print(A*B//100)

Submission status: Accepted

Solution code:
import decimal

A_B = input().split(" ")

a = decimal.Decimal(str(A_B[0]))
b = decimal.Decimal(str(A_B[1]))

print(int(a*b))

Submission status: Accepted

Solution code:
# coding: utf-8
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

A, B = sr().split()
A = int(A)
B = int(float(B) * 1000)
answer = int(A*B)//1000
print(answer)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
from decimal import Decimal

info = input().split()
A = int(info[0])
B = Decimal(info[1])

print(int(A*B))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_DOWN
import heapq
from fractions import gcd
from functools import reduce
from collections import deque
# from math import factorial
import itertools
import collections
import math
import sys
sys.setrecursionlimit(2000000)
# import statistics
# import numpy as np
# n = int(input())
# a, b, c, k = list(map(int, input().split()))
# a = list(map(int, input().split()))
# abc = [int(input()) for i in range(5)]
# n = int(input())
# h1, m1, h2, m2, k = list(map(int, input().split()))
a, b = list(map(float, input().split()))
# a = list(map(int, input().split()))
# data = [list(map(int, input().split())) for i in range(n)]
# k = int(input())
# p = list(map(int, input().split()))
# ab_sorted = sorted(ab, key=lambda x: x[0])
# py = [list(map(int, input().split())) for i in range(m)]
ans = (Decimal(str(a)) * Decimal(str(b))
       ).quantize(Decimal('0'),  rounding=ROUND_DOWN)
print(ans)

Submission status: Accepted

Solution code:
a,b=input().split()
a=int(a)
b=float(b)
b,c=int(b),int((1000*b-1000*int(b)))
c=(a*c)//1000
print(a*b+c)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import decimal
import sys
from decimal import Decimal

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    A, B = rl().split()
    ans = Decimal(A) * Decimal(B)
    ans = ans.quantize(Decimal('0'), rounding=decimal.ROUND_FLOOR)
    print(ans)


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
import math
import decimal

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

c = decimal.Decimal(a)
d = decimal.Decimal(b)

e = c * d

print(math.floor(e))

Submission status: Accepted

Solution code:

from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict, Counter
from itertools import combinations, permutations, combinations_with_replacement
from itertools import accumulate
from math import ceil, sqrt, pi, radians, sin, cos
import decimal

MOD = 10 ** 9 + 7
INF = 10 ** 18

A, B = input().split()

A, B = decimal.Decimal(A), decimal.Decimal(B)

print(int(A * B))

Submission status: Accepted

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