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:
from decimal import *
def main():
    A,B = input().split()
    A = int(A)
    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 sys import stdin
from sys import setrecursionlimit
from collections import Counter, deque, defaultdict
from math import floor, ceil
from bisect import bisect_left
from itertools import combinations
setrecursionlimit(100000)

INF = int(1e10)
MOD = int(1e9 + 7)

def main():
    from builtins import int, map
    A, B = input().split()
    A = int(A)

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

    B = int(B.replace(".", ""))
    if A == 0 or B == 0:
        print(0)
        exit()
    AB = int(A * B) // 100
    print(AB)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
from math import log2,floor,ceil,sqrt
# import bisect
# from collections import deque

# from types import GeneratorType
# def bootstrap(func, stack=[]):
#     def wrapped_function(*args, **kwargs):
#         if stack:
#             return func(*args, **kwargs)
#         else:
#             call = func(*args, **kwargs)
#             while True:
#                 if type(call) is GeneratorType:
#                     stack.append(call)
#                     call = next(call)
#                 else:
#                     stack.pop()
#                     if not stack:
#                         break
#                     call = stack[-1].send(call)
#             return call
#     return wrapped_function

Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
 
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7

a,b = ri().split()
a = int(a)
b = b.split('.')
b[0] = int(b[0])
b[1] = b[1].rstrip('0')
l = len(b[1])



# print(a,b[0],b[1])
if l == 0:
    print(a*b[0])
else:
    b[1] = int(b[1])
    ans = a*b[0] + a*b[1]//10**l
    print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal
num = []
for n in input().split():
    d = Decimal(n)
    num.append(d)

ans = num[0] * num[1]
print(int(ans))

Submission status: Accepted

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


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

    a, b = input().split()
    a = int(a)
    b = 100 * int(b[:-3]) + int(b[-2:])
    print(a * b // 100)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
ab = list(input().split())
a = int(ab[0])
b = ab[1]
ans = 0
# ans += a*int(b[0])
# ans += a*int(b[2])*0.1
# ans += a*int(b[3])*0.01


# import math
# anss = math.floor(ans)
# print(anss)

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

Submission status: Accepted

Solution code:
# 2020/05/31
# AtCoder Beginner Contest 169 - C

# Input
a, b = input().split()

# Calc
bint = int(b[0:len(b)-3])
bfloat = int(b[len(b)-2:len(b)])
ans = int(a) * (bint * 100 + bfloat) // 100

# Output
print(ans)

Submission status: Accepted

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

A = int(A)

B = int(B[0])*100 + int(B[2])*10 + int(B[3])

print(A*B//100)

Submission status: Accepted

Solution code:
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    A, B = input().split()

    A = int(A)
    B = int(B.replace('.', ''))
    print((A * B) // 100)


main()

Submission status: Accepted

Solution code:
from decimal import *

# print('input >>')
A, B = input().split()

ans = Decimal(A) * Decimal(B)
# ans = A * 100 * B * 100 / 10000

# print('-----output-----')
print(int(ans))

Submission status: Accepted

Solution code:
import sys
import heapq

def main():
    a, b = sys.stdin.readline().split()
    a = int(a)
    b = int(b[:-3] + b[-2:])
    ans = a * b // 100
    print(ans)
    return

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import math
import decimal

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


print(math.floor(decimal.Decimal(a*b)))

Submission status: Accepted

Solution code:
s=input().split()
A=int(s[0])
B=int(s[1][0])*100+int(s[1][2])*10+int(s[1][3])
print(A*B//100)

Submission status: Accepted

Solution code:
from decimal import Decimal
s_list = input().split()
c = str(int(s_list[0])*Decimal(s_list[1]))
print(c.split(".")[0])

Submission status: Accepted

Solution code:
# coding: utf-8
import sys

# from operator import itemgetter
sysread = sys.stdin.readline
read = sys.stdin.read
#from heapq import heappop, heappush
#from collections import defaultdict

sys.setrecursionlimit(10 ** 7)
# import math
# from itertools import product, accumulate, combinations, product
# import bisect# lower_bound etc
#import numpy as np
# from copy import deepcopy
#from collections import deque
#import numba
import math

def run():
    A, b = input().split()
    A = int(A)
    B = 0
    B += int(b[0]) * 100
    B += int(b[-2:])
    ret = 0
    for _ in range(B):
        ret += A
    print(ret//100)


if __name__ == "__main__":
    run()

Submission status: Accepted

Solution code:
import decimal

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

print(int(a*b))

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_FLOOR
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():
    
    A,B=map(str,input().split())

    val=Decimal(B)*Decimal(A)
    print(int(val))
    
resolve()

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:
A, B = input().split()
B = int(B[0]) * 100 + int(B[2:])
print((int(A) * B) // 100)

Submission status: Accepted

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

Submission status: Accepted

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

print(int(a * b))

Submission status: Accepted

Solution code:
from decimal import *
a,b=open(0).read().split()
print(int(Decimal(a)*Decimal(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:
# coding: utf-8

import sys
import math
import collections
import itertools
import bisect
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return x if y == 0 else gcd(y, x%y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")

A, B = LS()
A = int(A)

B = B.split('.')
Ba = int(B[0])
Bb = int(B[1])

c = 0
Bb *= A
Bb = str(Bb)
if len(Bb) >= 3:
    c = int(Bb[0:len(Bb)-2])

print(A*Ba + c)

Submission status: Accepted

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

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

import decimal

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

Submission status: Accepted

Solution code:
import sys
a, b = sys.stdin.readline().split()
b = b.replace('.', '')
print(int(a) * int(b) // 100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(300000)
from decimal import Decimal, getcontext
getcontext().prec = 32

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')
from math import floor

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

Submission status: Accepted

Solution code:
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]

a,b = input().split()
a = int(a)
b = list(b.split("."))
b = ''.join(b)
b = int(b)
print(a*b//100)

Submission status: Accepted

Solution code:
def C():
    A, B = input().split()
    A = int(A)
    B_int = int(B[:B.index('.')])
    B_decimal = int(B[B.index('.')+1:])
    ans_int = A*B_int
    ans_int += B_decimal*A//100
    print(ans_int)
    
C()

Submission status: Accepted

Solution code:
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
from decimal import Decimal
#======================================================#
def main():
    a, b = IS().split()
    a = Decimal(a)
    b = Decimal(b)
    print(int(Decimal(a*b)))

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b=map(str,input().split())
a=int(a)
b=b.split(".")
b=int(b[0]+b[1])
print((a*b)//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:
A,B=input().split()

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

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

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

Submission status: Accepted

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

a = int(a)
bb = int(b.replace('.',''))
ans = a * bb

print(int(ans//100))

Submission status: Accepted

Solution code:
from decimal import *
s,t=input().split()
k=(Decimal(s)*Decimal(t))//Decimal(1)
print(k)

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
from decimal import *
getcontext().prec = 20 #小数点何桁か
a,b = readline().rstrip().decode('utf-8').split()
a = Decimal(a)
b = Decimal(b)
c = Decimal(a*b)
print(int(c))

Submission status: Accepted

Solution code:
#!/usr/bin/env python

def main():
    a, b = map(str, input().split(' '))
    a = int(a)
    b = b[:-3] + b[-2:]
    b = int(b)
    c = a * b // 100
    print(c)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal,ROUND_DOWN
a,b=input().split()
ad = Decimal(a)
bd = Decimal(b)
print((ad * bd).quantize(Decimal('0'), rounding=ROUND_DOWN))

Submission status: Accepted

Solution code:
A, B = [i for i in input().split()]
A = int(A)
B1, B2 = B.split('.')
B = 100 * int(B1) + int(B2)
print(A*B//100)

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_FLOOR

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

# print(A, B)
print((A * B).quantize(Decimal("1"), rounding=ROUND_FLOOR))

Submission status: Accepted

Solution code:
A,B=input().split()
A=int(A)
B=int(B[0]+B[2]+B[3])
X=str(A*B)
if len(X)>2:
  print(X[:-2])
else:
  print(0)

Submission status: Accepted

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

a=int(a)
b=round(float(b)*100)

print(a*b//100)

Submission status: Accepted

Solution code:
A, B = input().split()
print(int(A + '00')*int(''.join(B.split('.')))//10000)

Submission status: Accepted

Solution code:
# import sys
#
#
# RS = lambda: sys.stdin.readline()[:-1]
# RI = lambda x=int: x(RS())
# RA = lambda x=int: map(x, RS().split())
# RSS = lambda: RS().split()

# import decimal
# decimal.getcontext().prec = 50


def solve(a , b):
    b = b.replace(".", "")
    b = int(b)
    ans = a*b // 100
    print(ans)
    return


inp = input().split()
a = int(inp[0])
b = inp[1]
solve(a, b)

Submission status: Accepted

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

Submission status: Accepted

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

import sys
sys.setrecursionlimit(300000)


def solve(A: int, B: float):
    s = int(B[0]) * 100
    x = int(B[2:])
    #ret = (B * 100 * A) // 100
    ret = ((s + x) * A) // 100
    print(int(ret))
    return

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: float
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

print(A* B // 100)

Submission status: Accepted

Solution code:
from math import floor
a, b = input().split()
a = int(a)
b = int(b[0])*100 + int(b[2])*10 + int(b[3])
ans = (a*b) // 100
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def solve(a, b):
    a_int = int(a)
    b_int = 0
    c = 0
    for i in range(len(b)):
        if b[- i - 1] == ".":
            continue
        b_int += int(b[- i - 1]) * (10 ** c)
        c += 1
    # print(a_int, b_int, a_int * b_int // 100)
    return a_int * b_int // 100


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


def test():
    assert solve("198", "1.10") == 217
    assert solve("1", "0.01") == 0
    assert solve("1000000000000000", "09.99") == 9990000000000000


if __name__ == "__main__":
    test()
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal, getcontext

getcontext().prec = 99


def resolve():
    A, B = input().split()

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



resolve()

Submission status: Accepted

Solution code:
import sys
# from collections import defaultdict
# from collections import Counter
# from queue import Queue

def main():
    # N = int(input())

    A_, B_ = [ch for ch in input().split()]
    A = int(A_)
    Bint = int(float(B_[0]))
    Bfloat = int(B_[2:])

    # print(A)
    # print(Bint)
    # print(Bfloat)

    ans = A * Bint + (A * Bfloat // 100)

    # ans = A + int(A * (B - 1.0))
    print(ans)

    # As = []
    # for i in range(N):
    #     tmp = int(input())
    #     As.append(tmp)

    return 0

if __name__ == '__main__':
    sys.exit(main())

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 math
from decimal import Decimal
a, b = map(str, input().split())
ans = math.floor(Decimal(a)*Decimal(b))
print(ans)

Submission status: Accepted

Solution code:
a,b=input().split()
c=[]
for i in range(len(b)):
  if b[i]=='.':
    x=i
  else:
    c.append(b[i])
if len(c)<3:
  c.append('0')
d=''.join(c)
if x==2:
  print(int(a)*10)
  exit()
else:
  e=int(a)*int(d)
  e=list(str(e))
  if len(e)<=2:
    print(0)
    exit()
  else:
    e.pop(-1)
    e.pop(-1)
  print(''.join(e))

Submission status: Accepted

Solution code:
### ----------------
### ここから
### ----------------

import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

    a,b=map(str, readline().rstrip().split())
    a=int(a)
    b1,b2=b.split(".")
    b=int(b1)*100+int(b2)
    print((a*b)//100)
    #arr=list(map(int, readline().rstrip().split()))
    #n=int(readline())
    #ss=readline().rstrip()
    #yn(1)

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

### ----------------
### ここまで 
### ----------------

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

num = math.floor(Decimal(a) * Decimal(b))
print(num)

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
bl, br = b.split('.')
b = int(bl) * 100 + int(br)

print((a * b) // 100)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys

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

A, B = read().split()

A = int(A)
B = int(float(B) * 100 + .5)

A *= B
print(A // 100)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと


def read_a_int(): return int(read())


def read_ints(): return list(map(int, read().split()))


def read_col(H):
    '''H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) #一列の場合'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_tuple(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_matrix(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    # return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため


MOD = 10**9 + 7
INF = 2**31  # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  # , insort_left, insort_right
from decimal import Decimal
A, B = input().split()
A = Decimal(int(A))
B = Decimal(B)
print(int(A * B))

Submission status: Accepted

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

b = b[0] + b[2] + b[3]
ans = int(a) * int(b) // 100

print(int(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
import math
'''
a=10**15
b=9.99
'''
a,b=map(Decimal,input().split())

num=a*b
#print(num)

num=math.floor(num)
print(num)

Submission status: Accepted

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

a = int(a)
b = int(b.replace('.', ''))

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

Submission status: Accepted

Solution code:
# coding: utf-8

import sys
import math
from collections import Counter
import itertools
import fractions
from decimal import *
#import numpy as np
#from functools import reduce

# 入力を整数に変換して受け取る
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
# 入力全てを整数に変換したものの配列を受け取る
def LI(): return list(map(int, sys.stdin.readline().split()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'

# リストを改行区切りで出力する
p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")

# ###########################################
a,b = input().split()
da = Decimal(a)
db = Decimal(b)

print(math.floor(da*db))

Submission status: Accepted

Solution code:
import sys, random, math
from bisect import bisect_left, bisect_right
input = sys.stdin.readline

def main():
    inf = 10 ** 20

#    t = int(input())
#    t, a, b = map(int, input().split())
    t = 1
    
    for _ in range(1, t+1):
    #    print("Case #{}: ".format(_), end = '')
        
        aa, bb = input().split()
        a, b = -1, -1
        for i in range(len(aa)):
            if(aa[i] == '.'):
                a = int(aa[:i]) * 100
                if(i == len(aa)-2):
                    a += int(aa[-1]) * 10
                else:
                    a += int(aa[-2:])
        if(a == -1):
            a = int(aa) * 100
        for i in range(len(bb)):
            if(bb[i] == '.'):
                b = int(bb[:i]) * 100
                if(i == len(bb)-2):
                    b += int(bb[-1]) * 10
                else:
                    b += int(bb[-2:])
        if(b == -1):
            b = int(bb) * 100
    
            
    #    print(a, b)
        
        print((a*b//10000))
        
main()

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

from collections import defaultdict, deque
from sys import exit
import math
import copy
from bisect import bisect_left, bisect_right
from heapq import *
import sys
# sys.setrecursionlimit(1000000)
INF = 10 ** 17
MOD = 1000000007

from fractions import *
def inverse(f):
    # return Fraction(f.denominator,f.numerator)
    return 1/f


def combmod(n, k, mod=MOD):
    ret = 1
    for i in range(n - k + 1, n + 1):
        ret *= i
        ret %= mod

    for i in range(1, k + 1):
        ret *= pow(i, mod - 2, mod)
        ret %= mod

    return ret
def bunsu(n):
    ret = []
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            tmp = 0
            while(True):
                if n % i == 0:
                    tmp += 1
                    n //= i
                else:
                    break
            ret.append((i, tmp))

    ret.append((n, 1))
    return ret

def solve():
    a, b = input().split()
    a = int(a)
    b = int(b[:-3]) * 100 + int(b[-2:])
    ans = (a * b) // 100
    print(ans)
    # print(str(ans)[:-2])
def main():
    # n = getN()
    # for _ in range(n):
    solve()
if __name__ == "__main__":
    solve()

Submission status: Accepted

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

print(int(A*B))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
arr = input().split()
a = int(arr[0])
b = int(arr[1][0]) * 100 + int(arr[1][2]) * 10 + int(arr[1][3])
res = a * b
print(res // 100)

Submission status: Accepted

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

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

print(A*B//100)

Submission status: Accepted

Solution code:
a,b=input().split()
a=int(a)
b=int(float(b)*pow(10,len(str(a))))
print(a*b//pow(10,len(str(a))))

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:
A, B = input().split()
A = int(A)
B = int(B[0]+B[2:])
C = A*B
D = str(C)[:-2]
if D == "":
    D = 0
else:
    D = int(D)
print(D)

Submission status: Accepted

Solution code:
import sys
def input():
    return sys.stdin.readline()[:-1]

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

Submission status: Accepted

Solution code:
# abc169_c.py
import decimal

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

print(int(ans))

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:
a,b=input().split()
a=int(a)
b=int(b[:-3]+b[-2:])
#b=int(float(b)*100)
print(int(a*b//100))

Submission status: Accepted

Solution code:
import math

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

b = b.replace('.', '')
b = int(b)

print((a*b)//100)

Submission status: Accepted

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

Submission status: Accepted

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

A = int(A)

if '.' in B:
    idx_dot = B.index('.')
    level = len(B) - 1 - idx_dot
    B_int = ''
    for Bi in list(B):
        if Bi != '.': B_int += Bi
    B_int = int(B_int)
    #
    ans = (A * B_int) // (10 ** level)
else:
    B = int(B)
    ans = A * B

print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal

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

p = a * b

print(int(p))

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
b = b.split('.')
b = int(b[0])*100 + int(b[1])

print(a*b//100)

Submission status: Accepted

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

Submission status: Accepted

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

from decimal import *
getcontext().prec = 100
a=Decimal(a)
b=Decimal(b)
print(int(a*b))

Submission status: Accepted

Solution code:
import decimal

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

Submission status: Accepted

Solution code:
from fractions import Fraction
a, b = map(Fraction, input().split())

print(int(a*b))

Submission status: Accepted

Solution code:
A, B = [s for s in input().split()]
A = int(A)
intB, decimalB = B.split(".")
result = A * int(intB) +  A * int(decimalB) // 100
print(result)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
# coding: utf-8

import math
import re
import numpy as np

S = input().split(" ")
A = int(S[0])
B = int(S[1][0]) * 100 + int(S[1][2]) * 10 + int(S[1][3])

ans = (A * B) // 100

print(ans)

Submission status: Accepted

Solution code:
#!python3

iim = lambda: map(int, input().rstrip().split())
from decimal import Decimal

def resolve():
    a, b = input().split()
    a = int(a); b = Decimal(b)

    print(int(a*b))

if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
import math
from decimal import *

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
from decimal import *
import math
inputs = input().strip().split()
A = Decimal(inputs[0])
B = Decimal(inputs[1])

ans = A * B

print(math.floor(ans))

Submission status: Accepted

Solution code:
import bisect
import copy
import heapq
import math
import sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
sys.setrecursionlimit(500000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

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

# b*=100
# print(a,b)
# b=math.floor(b)
print(a*b//100)

Submission status: Accepted

Solution code:
from sys import stdin, stdout

int_in = lambda: int(stdin.readline())
arr_in = lambda: [int(x) for x in stdin.readline().split()]
mat_in = lambda rows: [arr_in() for y in range(rows)]
str_in = lambda: stdin.readline().strip()
out = lambda o: stdout.write("{}\n".format(o))
arr_out = lambda o: out(" ".join(map(str, o)))
bool_out = lambda o: out("YES" if o else "NO")
tests = lambda: range(1, int_in() + 1)
case_out = lambda i, o: out("Case #{}: {}".format(i, o))


if __name__ == "__main__":
    parts = str_in().split()
    a = int(parts[0])
    b = int(parts[1].replace(".", ""))
    out((a*b)//100)

Submission status: Accepted

Solution code:
from decimal import *

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

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