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

line = input().rstrip()
line = line.split(' ')
A = int(line[0])
B = line[1].split('.')
if len(B) == 1:
    B = int(B[0]) * 100
elif len(B[1]) == 1:
    B = int(B[0]) * 100 + int(B[1]) * 10
else:
    B = int(B[0]) * 100 + int(B[1])

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
a,b = map(str,input().split())
a = Decimal(a)
b =Decimal(b)
# print('{:.020f}'.format(b))
# print(b)
# b *=100
# b = int(b)
# print(math.floor(a*b/100))
# c = a%10000
# e = math.floor(a / 10000)

# print(int(e*b*10000+c*b))

# c = b-int(b)
# for 
# d = int(b)
# s = a*d+c*a
print(int(math.floor(a*b)))

Submission status: Accepted

Solution code:
from decimal import Decimal


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


print(int(x*y))

Submission status: Accepted

Solution code:
from decimal import *

input_line = input()
Line = input_line.split()
print(int(Decimal(Line[0]) * Decimal(Line[1])))

Submission status: Accepted

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

b2=int(b*100)
#print(b2)

ans=a*b2
#print(ans)

ans=int(ans//100)

print(ans)

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
s = input().split()
result = Decimal(s[0])*Decimal(s[1])
print(math.floor(result))

Submission status: Accepted

Solution code:
from decimal import *

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

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

Submission status: Accepted

Solution code:
from decimal import Decimal

a,b = (Decimal(str(x)) for x in input().split())

c = a*b

print(int(c))

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

import math
from decimal import *

A,B=input().split()
print(math.floor(Decimal(A)*Decimal(B)))

Submission status: Accepted

Solution code:
import decimal
s = input().split()
a = int(s[0])
b = round(decimal.Decimal(s[1]), 2)
print(int(a * b))

Submission status: Accepted

Solution code:
import math
import decimal
a, b = input().split()
a = decimal.Decimal(a)
b = decimal.Decimal(b)
print(int(math.floor(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 decimal import *
getcontext().prec = 32

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

Submission status: Accepted

Solution code:
import re
N, M = input().split()

N = int(N)
M = M.replace(".","")
M = M + "00"
M = int(M[:3])

print((N*M)//100)

Submission status: Accepted

Solution code:
import sys
from decimal import *


A, B = sys.stdin.readline().rstrip().split()

root2 = Decimal(A) * Decimal(B)
y = Decimal(str(root2)).quantize(Decimal(str(1)), rounding=ROUND_DOWN)
print(y)

Submission status: Accepted

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

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:
a, b = map(str, input().split())
b = b[:-3] + b[-2:]
a = int(a)
b = int(b)
c = str(a*b)
c = '000' + c
c = c[:-2]
print(int(c))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

print(math.floor(A*B))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b=input().split()
a=int(a)
l=len(b)
B=0
c=1
for i in b:
	if i!='.':
		B+=int(i)*10**(l-c)
		c+=1
print(a*B//10**(l-1))

Submission status: Accepted

Solution code:
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

A,B = input().split()

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def cc():
    a, b = map(str, input().split())
    a2 = int(a)
    b2 = int(b.replace('.', ''))
    c = a2 * b2
    ans = str(c)[0:-2] if len(str(c)) > 2 else 0
    print(ans)
if __name__ == "__main__":
    cc()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import math
a,b=map(lambda x:x,input().split())
a=int(a)
b=round(float(b)*100)
print(a*b//100)

Submission status: Accepted

Solution code:
a,b=map(str,input().split())
a=int(a)
bb=""
for i in b:
  if i!=".":
    bb+=i
bb=int(bb)
print((a*bb)//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
import math
 
A = list(input().split())
 
for i in range(2):
    if i == 0:
        A[i] = int(A[i])
    elif i == 1:
        A[i] = Decimal(A[i])
 
ans = A[0] * A[1]
 
print(math.floor(ans))

Submission status: Accepted

Solution code:
from decimal import Decimal
from math import floor

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

print(floor(a*b))

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

Submission status: Accepted

Solution code:
from decimal import *

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





if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import math
from decimal import Decimal
def f(x):
    return Decimal(x)
def main():
    a, b = map(f, input().split())
    c = a * b
    print(math.floor(c))
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal
import math
A,B = [Decimal("{}".format(i)) for i in input().split()]
print(math.floor(int(A)*B))

Submission status: Accepted

Solution code:
import math
X = input().split()
A = int(X[0])
B_i, B_s = X[1].split(".")
B = int(B_i) * 100 + int(B_s)

print( (A *B) // 100)

Submission status: Accepted

Solution code:
from decimal import Decimal
import math

a,b = map(str,input().split())
c = Decimal(a)
d = Decimal(b)

ans = math.floor(c*d)

print(ans)

Submission status: Accepted

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

n = 1
if '.' in b:
    if b[-2] == '.':
        n = 10
    elif b[-3] == '.':
        n = 100
    b = b.replace('.', '')
b = int(b)
print(math.floor(a*b//n))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

def main():
    a, b = map(str, input().split())
    a = int(a)
    b = list(b)
    del b[1]
    bb = ""
    for i in b:
        bb += i
    b = int(bb)
    ans = str(a * b)
    if len(ans) <= 2:
        print(0)
        exit()
    ans = ans[: -2]
    ans = int(ans)
    print(ans)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from fractions import Fraction

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

from decimal import *

a = Decimal(A)
b = Decimal(B)
getcontext().prec = 28
ans = a * b
print(int(ans))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")

#solve
def solve():
    a, b = LS()
    a = int(a)
    b = float(b)
    b *= 1000
    b = int(b)
    print(a * b // 1000)
    return


#main
if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
from decimal import *
getcontext().prec = 100

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

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import math
from decimal import Decimal

def f(x):
    return Decimal(x)


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from decimal import *

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

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

Submission status: Accepted

Solution code:
import math
a,b=map(lambda x:x,input().split())
a=int(a)
b=round(float(b)*100)
print(int(a*b//100))

Submission status: Accepted

Solution code:
nums = input().split(' ')
a = int(nums[0])
# b = float(nums[1])
b_str = nums[1]
# b100 = int(b*100)
b100sub = int(b_str[-1]) + 10*int(b_str[-2]) + 100*int(b_str[-4])

ans_str = str(a*b100sub)
ans = ans_str[0:-2]
if ans == '':
    ans = '0'

print(int(ans))

Submission status: Accepted

Solution code:
from decimal import Decimal,ROUND_FLOOR
a,b=map(str,input().split())
c=Decimal(a)*Decimal(b)
print(Decimal(str(c)).quantize(Decimal('0'),rounding=ROUND_FLOOR))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B = input().split()
A = int(A)
b,c = map(int, B.split('.'))
ab = A * b
ac = A * c

print(ab + ac // 100)

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
input = input().split()
a = input[0]
b = input[1]
print(str(Decimal(a)*Decimal(b)).split('.')[0])

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *

##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)

##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力

# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと

##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順

# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順

##### 累乗 #####
# pow(x, y, z) -> x**y % z

##### 割り算の切り上げ #####
# tmp = -(-4 // 3)

##### dict の for文 #####
# for k, v in d.items():
#     print(k, v)

##### 進数の変換 #####
# bin_str = bin(i)[2:]
# oct_str = oct(i)[2:]
# hex_str = hex(i)[2:]

def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

def main():
	getcontext().prec = 30
	A,B  = map(Decimal, input().split())

	ans = A * B

	s = str(ans)
	S = s.split(".")
	print(S[0])

def factorize(n):
    fct = []  # prime factor
    b, e = 2, 0  # base, exponent
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct


#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索のリバース
def bisect_left_reverse(a, x):
    if a[0] <= x:
        return 0
    if x < a[-1]:
        return len(a)
    # 二分探索
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] <= x:
            ok = mid
        else:
            ng = mid
    return ok

def bisect_right_reverse(a, x):
    if a[0] < x:
        return 0
    if x <= a[-1]:
        return len(a)
    # 二分探索
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] < x:
            ok = mid
        else:
            ng = mid
    return ok

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索
# 存在しない場合: None 存在する場合: その値
def binary_search(list, item):
    low = 0
    high = len(list) - 1

    while low <= high:
        mid = (low + high) //2
        guess = list[mid]
        if guess == item:
            return mid
        if guess > item:
            high = mid -1
        else:
            low = mid + 1
    return None

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# N 個のボールを K グループに分ける場合のパターン数
def sunuke(N, K, mod=10**9+7):
	if N < K or K-1 < 0:
		return 0
	else:
		return combination(N-1, K-1, mod)

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res

# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
	# comb = Combination(n+r-1, mod)
	# return comb(n+r-1, r)
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# dfs のサンプル
def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:
a,b=input().split()
a=int(a)
seisu=int(b[0])
syosu=int(b[2:4])
#print(b)
print(a*seisu+(a*syosu)//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import decimal

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

A = str(A)
B = str(B)
ans = decimal.Decimal(A) * decimal.Decimal(B)
print(int(ans))

Submission status: Accepted

Solution code:
#C
from decimal import *
import math
a,b = map(Decimal,input().split())

print(math.floor(a*b))

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def main():
    A,B=map(str, input().split(" "))
    A = int(A)
    B = int(B.split(".")[0] + B.split(".")[1])
    mul_AB = A * B
    if mul_AB < 100:
        print(0)
    else:
        print(str(mul_AB)[:-2])

    
if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b=map(str,input().split())
a=int(a)
B=0
if b[0]=='0':
    pass
else:
    B+=int(b[0])*100

if b[2]=='0':
    pass
else:
    B+=int(b[2])*10

if b[3]=='0':
    pass
else:
    B+=int(b[3])

print((a*B)//100)

Submission status: Accepted

Solution code:
from fractions import Fraction
from decimal import Decimal

a, b = map(float, input().split())
# print(b)
# print(format(b, '.15f'))
# b = Fraction(b, 10)
# print(b)

ans = Decimal(str(a)) * Decimal(str(b))
# ans = seki / (10**15)
print(int(ans))

Submission status: Accepted

Solution code:
from math import floor
from decimal import Decimal
a,b = [e for e in input().split(" ")]
a = int(a)
b = Decimal(b)
r = a*b
print(floor(r))

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

input_a = input().split()
a = Decimal(input_a[0])
b = Decimal(input_a[1])
ans = a*b
# print(input_a)
# print(a, b)
# print(type(a), type(b))
print(int(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

def main():
  A, B = input().split()
  # A = int(A)
  # B = float(B)
  res = Decimal(A) * Decimal(B)
  # res = A * int(B * 100) / 100
  print(int(res))

if __name__ == "__main__":
  main()

Submission status: Accepted

Solution code:
import decimal

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

res = a*int(split_b[0])
f = decimal.Decimal(a) * (decimal.Decimal(split_b[1]) * decimal.Decimal('.01'))

print(res + int(f))

Submission status: Accepted

Solution code:
from decimal import *
A,B = map(str,input().split())
num = str(Decimal(A)*Decimal(B))
ans = ''
 
for i in range(len(num)):
  if num[i] == '.':
    break
  ans += num[i]
print(int(ans))

Submission status: Accepted

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

a = Decimal(a)
b = Decimal(b)
ans = a * b
ans = ans.quantize(Decimal(0),rounding=ROUND_FLOOR)
print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal
A, B = map(Decimal, input().split())
# A = 10 ** 15
# B = 9.99

# A = int(A)
X = Decimal(A*B)
# print(X)
X = int(X)

# print(A)
# print(B)
print(X)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *

##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)

##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力

# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと

##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順

# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順

##### 累乗 #####
# pow(x, y, z) -> x**y % z

##### 割り算の切り上げ #####
# tmp = -(-4 // 3)

##### dict の for文 #####
# for k, v in d.items():
#     print(k, v)

##### 進数の変換 #####
# bin_str = bin(i)[2:]
# oct_str = oct(i)[2:]
# hex_str = hex(i)[2:]

def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

def main():
	getcontext().prec = 20
	A,B  = map(Decimal, input().split())

	ans = A * B

	s = str(ans)
	S = s.split(".")
	print(S[0])

def factorize(n):
    fct = []  # prime factor
    b, e = 2, 0  # base, exponent
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct


#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索のリバース
def bisect_left_reverse(a, x):
    if a[0] <= x:
        return 0
    if x < a[-1]:
        return len(a)
    # 二分探索
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] <= x:
            ok = mid
        else:
            ng = mid
    return ok

def bisect_right_reverse(a, x):
    if a[0] < x:
        return 0
    if x <= a[-1]:
        return len(a)
    # 二分探索
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] < x:
            ok = mid
        else:
            ng = mid
    return ok

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索
# 存在しない場合: None 存在する場合: その値
def binary_search(list, item):
    low = 0
    high = len(list) - 1

    while low <= high:
        mid = (low + high) //2
        guess = list[mid]
        if guess == item:
            return mid
        if guess > item:
            high = mid -1
        else:
            low = mid + 1
    return None

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# N 個のボールを K グループに分ける場合のパターン数
def sunuke(N, K, mod=10**9+7):
	if N < K or K-1 < 0:
		return 0
	else:
		return combination(N-1, K-1, mod)

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res

# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
	# comb = Combination(n+r-1, mod)
	# return comb(n+r-1, r)
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# dfs のサンプル
def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:

a, b = input().strip().split()
a = int(a)
# print(b.split("."))
b=b.split(".")
b1=int(b[0])*100 + int(b[1])
print(a*b1//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
a,b = map(str, input().split())
a = int(a)
b = b.replace(".","")
if len(b) == 2:
    b = b + '0'
b = int(b)
ans = a*b
if len(str(ans)) <= 2:
    print(math.floor(ans/100))
else:
    print(int(str(ans)[:-2]))

Submission status: Accepted

Solution code:
import math

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

B = B.replace('.', '').ljust(3, '0')
B = int(B)

AB = A * B
AB = str(AB)
AB = AB[0:-2]
AB = 0 if AB == '' else AB
print(AB)

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

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

print(math.floor(ans))

Submission status: Accepted

Solution code:
import math
Aa,Ba = input().split()
B = 100*int(Ba[0])+10*int(Ba[2])+int(Ba[3])
A = int(Aa)
print((A*B)//100)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

# A *= 100
# B = float(B)
# B = math.floor(B * 100)
B = B.replace('.', '').ljust(3, '0')
B = int(B)

# AB = A * B / 100
# floored = int(math.floor(AB))
# print(floored)

AB = A * B
AB = str(AB)
AB = AB[0:-2]
AB = 0 if AB == '' else AB
print(AB)

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_FLOOR

A, B = input().split()
A = int(A)
B = Decimal(B)
ans = Decimal(str(A*B)).quantize(Decimal('0'), rounding=ROUND_FLOOR)

print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_DOWN
a,b = input().split()
a = int(a)
b = Decimal(b)
x = Decimal(a*b)
d = Decimal(str(x))
y = d.quantize(Decimal(str(0)), rounding=ROUND_DOWN)
print(y)

Submission status: Accepted

Solution code:
import sys
import math

input = sys.stdin.readline
A, B = input().rstrip().split()

def main():
    b = B.replace(".", "")
    result = int(A) * int(b)
    return result // 100

ans = main()
print(int(ans))

Submission status: Accepted

Solution code:
import sys
from decimal import *
import math

sys.setrecursionlimit(10 ** 7)

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

A, B = input().split()

if A == "0":
    print(0)
    exit()

getcontext().prec = 10 ** 10

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

Submission status: Accepted

Solution code:
from decimal import *
import math
A, B = map(Decimal, input().split())
C = A * B
D = C.quantize(Decimal(1), rounding=ROUND_FLOOR)
print(D)

Submission status: Accepted

Solution code:
from decimal import Decimal,ROUND_FLOOR

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

ans = A*B

if ans < 1:
    print(0)
else:
    print(ans.quantize(Decimal("0"), rounding=ROUND_FLOOR))