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:
#!/usr/bin/env python3

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)
import decimal


def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    decimal.getcontext().prec = 128
    a, b = input().split()
    print(int(decimal.Decimal(a) * decimal.Decimal(b)))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from sys import stdin
from decimal import Decimal
def main():
    #入力
    readline=stdin.readline
    li=readline().strip().split()
    a=Decimal(str(li[0]))
    b=Decimal(str(li[1]))
    ans=int(a*b)
    print(ans)

if __name__=="__main__":
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal

a, b = input().split()
A = int(a)
B = int(b.replace('.', ''))
# print(A, B)

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

Submission status: Accepted

Solution code:
from decimal import Decimal
N,K=map(Decimal,input().split())
print(int((N*K)//1))

Submission status: Accepted

Solution code:
import decimal

decimal.getcontext().prec = 100

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

print(int(a * b))

Submission status: Accepted

Solution code:
def main():
    a, b = list(map(float, input().split()))
    round = lambda x: int((x * 2 + 1) // 2)
    a = round(a)
    b = round(100 * b)
    ans = str(a * b)
    if len(ans) >= 3:
        print(ans[:-2])
    else:
        print(0)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a, b = map(str, input().split())
a = int(a)
b1 = int(b[0])
b2 = int(b[2])
b3 = int(b[3])

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import math

a, b = input().split()

from decimal import Decimal

f1 = Decimal(a)
f2 = Decimal(b)

print(math.floor(f1 * f2))

Submission status: Accepted

Solution code:
a,b = input().split()
a = int(a)
s0 = a * int(b[0])
s1 = a * int(b[2])
s2 = a * int(b[3])
s = s0 + (s1 + s2//10)//10
print(s)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10000000)
import numpy as np
from heapq import heapify, heappop, heappush
import copy
from math import gcd, ceil
from collections import deque
# queueとして使う場合 push, popleftを使う
from bisect import bisect_left, bisect_right
from decimal import *
# bisect_left: 配列の順序関係が崩れない条件で挿入することができる一番左の点
# bisect_right: 配列の順序関係が崩れない条件で挿入することができる一番右の点
# A = [1, 1, 1, 2, 2, 2, 4]
# print(bisect_left(A, 2))  # 3
# print(bisect_right(A, 2))  # 6
# print(bisect_left(A, 3))  # 6
# print(bisect_right(A, 3))  # 6


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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
def resolve():
    import math
    from decimal import Decimal

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

resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

n,m=(input().split())
# print(n,m)
print(int(Decimal(str(m))*Decimal(str(n))))

Submission status: Accepted

Solution code:
#!/usr/bin/python3

from decimal import *

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

print(int(a*b))

Submission status: Accepted

Solution code:
from fractions import Fraction

ab=input().split()
a = int(ab[0])
b = Fraction(ab[1])
calc = a*b
print(calc*100//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *

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

ans = Decimal(str(A)) * Decimal(str(B))
ans = str(ans)
i = ans.find('.')
ans = ans[:i]


print(ans)

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
b = b.replace('.', '')
b = int(b)
res = str(a*b)

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

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 = input().split()
a = int(a)
b = int(b[0] + b[2] + b[3])

print(a * b // 100)

Submission status: Accepted

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

print(ab)

Submission status: Accepted

Solution code:
import math

a, b = map(str, input().split())
A = int(a)
bb = b.replace(".","")
B = int(bb)

def Main(A, B):
    return A*B//100
                    
out = Main(A, B)
print(out)

Submission status: Accepted

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

Submission status: Accepted

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

ai = int(a)
#bf = float(b)
#bi = int(bf*100)
bi = int(b.replace('.', ''))

strans = str(ai*bi)
if len(strans) < 3:
    print(0)
else:
    print(strans[:-2])

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

A, B = input().split()
A = int(A)
B = int(B.replace(".", "")) # 100倍

ans = A * B // 100
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:

def s0():return input()
def s1():return input().split()
def s2(n):return [input() for x in range(n)]
def s3(n):return [input().split() for _ in range(n)]
def s4(n):return [[x for x in s] for s in s2(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b,yes="Yes",no="No"): print(yes if b else no)
# from sys import setrecursionlimit
# setrecursionlimit(1000000)
# from collections import Counter,deque,defaultdict
# import itertools
# import math
# import networkx as nx
# from bisect import bisect_left,bisect_right
# from heapq import heapify,heappush,heappop
a,b=s1()

x=int(a)
y=int(b[0]+b[2:])

ans=(x*y)//100
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python
"""AtCoder Beginner Contest 169: C - Multiplication 3
https://atcoder.jp/contests/abc169/tasks/abc169_c
"""

__author__ = 'bugttle <bugttle@gmail.com>'

from decimal import Decimal

def main():
    inputs = input().split()
    A, B = int(inputs[0]), Decimal(inputs[1])

    print(int(A * B))

if __name__ == '__main__':
    main()

Submission status: Accepted

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


def solve(*args: str) -> str:
    a, b = args[0].split()
    a = int(a)
    b = Decimal(b)

    return str(int(a*b))


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Submission status: Accepted

Solution code:
from decimal import Decimal

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

print(main())

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

Submission status: Accepted

Solution code:
s = input().split()
a = int(s[0])
b = int(s[1][0]) * 100
if s[1][1] == '.':
    b += int(s[1][2]) * 10
    if len(s[1]) == 4:
        b += int(s[1][3])
c = str(a*b)
if len(c) < 3:
    print(0)
else:
    print(c[:-2])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal


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




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

Submission status: Accepted

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

a,b = int(a),str(b)
b = int(b[0] + b[2:])

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

Submission status: Accepted

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

a = int(split_str[0])
b_lis = split_str[1].split('.')

b1 = int(b_lis[0])
b2 = int(b_lis[1])

print(a * (b1 * 100 + b2) // 100)

Submission status: Accepted

Solution code:
import math
A, B = input().split()
Afrac = A[-2:].zfill(2)
Aint = A[:-2].zfill(1)
Bfrac = B[-2:].zfill(2)
Bint = B[:-3].zfill(1)

ans = int(A) * int(Bint) + int(Aint) * int(Bfrac) + math.floor(int(Afrac) * int(Bfrac) / 100)
print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal


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

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

a = Decimal(str(a))
b = Decimal(str(b))

print(int(a*b))

Submission status: Accepted

Solution code:
a,b=map(str,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[0]+b[2:])
print(a*b//100)

Submission status: Accepted

Solution code:
from decimal import Decimal, getcontext

getcontext().prec = 1000
A, B = input().split()
A = Decimal(A)
B = Decimal(B)

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, cos, radians, pi, sin
from operator import mul
from functools import reduce
from operator import mul
from decimal import Decimal

mod = 10 ** 9 + 7
INF = 10 ** 13
sys.setrecursionlimit(2147483647)
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]



a, b = LS()
a = Decimal(a)
b = Decimal(b)
print(int(a * b))

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

import math

a,b = nn()
c,d = b.split('.')
a,b = int(a),int(c)*100+int(d)

print(a*b//100)

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

result = math.floor(A * B)

print(result)

Submission status: Accepted

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

Submission status: Accepted

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

print(math.floor(a * b))

Submission status: Accepted

Solution code:
import sys
import math
from collections import deque
import heapq
import itertools
from decimal import Decimal
MAX_INT = int(10e25)
MIN_INT = -MAX_INT
mod = 1000000000+7
sys.setrecursionlimit(1000000)
def IL(): return list(map(float,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

a,b = SL()

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

print(ans)

Submission status: Accepted

Solution code:
str_A,str_B = input().split()

A = int(str_A)
B = int(str_B[0])*100+int(str_B[2:])

# print(A)
# print(B)

print((A*B)//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from math import floor
from decimal import *

A, B = input().split()
A = int(A)
B = Decimal(B)
print(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:
def solve():
    A,B = input().split()
    A = int(A)

    decimal_digit = len(B) - 2
    B_int = int("".join(B.split('.')))

    tmp = A * B_int
    tmp = str(tmp)
    
    if int(tmp) <= decimal_digit:
        print("0")
    else:
        print(tmp[:len(tmp)-decimal_digit])

if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_FLOOR

a, b = map(Decimal, input().split())
print((a*b).quantize(Decimal('1'), rounding=ROUND_FLOOR))

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    import decimal
    a, b = map(float, input().split())

    i = decimal.Decimal(str(a))
    j = decimal.Decimal(str(b))
    k = i * j
    x = int(k)
    print(x)

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

Submission status: Accepted

Solution code:
import math
a,b=input().split()
a=int(a)
b=int(b.replace(".",""))
if len(str(a*b))>2:
    print(str(a*b)[:-2])
else:
    print(0)

Submission status: Accepted

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

if "." in B:
    keta = (len(B) - B.index(".") - 1)
    B_fix = int(B.replace(".",""))
    print(A * B_fix // (10**keta))
else:
    print(A * B)

Submission status: Accepted

Solution code:
from decimal import Decimal

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

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

Submission status: Accepted

Solution code:
import math
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:
import math
     
s = input().split()

s[1] = s[1].replace(".", "")
     
num = int(s[0]) * int(s[1])
     
print(num // 100)

Submission status: Accepted

Solution code:


def main():
    A, B = input().split()
    A = int(A)
    B = float(B)
    B = int(B*100 + 0.5)
    result = str(A*B)[:-2] or '0'
    print(result)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
b = b.replace('.','')
b100 = int(b)
ans = a * b100 // 100
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) // 1)
print(ans)

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:
import sys
import numpy as np
import math
import random
from decimal import Decimal
import itertools
import re
from collections import deque, Counter
from functools import lru_cache

sys.setrecursionlimit(2147483647)
INF = 10**13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007

def main():
	a, b = LS()
	ad = Decimal(a)
	bd = Decimal(b)
	product = ad * bd
	print(int(product))




if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import itertools
from functools import cmp_to_key
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

string = readline().decode().replace(".", "")
A, B = [int(i) for i in string.split()]

ret = A*B
ret = ret//100

print(ret)

Submission status: Accepted

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


#自作関数群
def readInt():
	return int(input())
def readInts():
	return list(map(int, input().split()))


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

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

ans = (a*c)//1000
#print(type(ans))
print(ans)

Submission status: Accepted

Solution code:
def mapint_inp():
    return map(int, input().split())

def intinp():
    return int(input())

import decimal

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

print((A*B).quantize(decimal.Decimal('1'), rounding=decimal.ROUND_FLOOR))

Submission status: Accepted

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

Submission status: Accepted

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


a, b = input().split()

a = int(a)
b = Decimal(b)

print(int(a*b))

Submission status: Accepted

Solution code:
import math
from decimal import *

def main():
    a, b = input_list()
    print(int(a*b))

def yogen(a, b, angle):
    coss = math.cos((angle/180)*math.pi)
    return math.sqrt(a**2 + b**2 - 2*a*b*coss)


def get_angle(hour, minute):
    h = (hour * 360) / 12 + (minute * 360) / (12 * 60)
    m = (minute * 360) / 60
    angle = abs(h-m)
    return min(angle, 360-angle)

def has(v, l):
    for vl in l:
        if v == vl:
            return True
    return False

def input_list():
    return list(map(Decimal, input().split()))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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 Decimal as d,ROUND_FLOOR as r

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

print((a*b).quantize(d('0'),rounding=r))

Submission status: Accepted

Solution code:
import math


def main():
    s, t = input().split()
    A = int(s)
    b, c = map(int,t.split("."))
    ans = A*b + A*c//100
    print(ans)
 
 
if __name__ == '__main__':
    import sys
    sys.setrecursionlimit(10000)
    main()

Submission status: Accepted

Solution code:
SA, SB = input().split()
A = int(SA)
sb1, sb2 = SB.split('.')
if len(sb2) == 1: sb2+="0"
B100 = int(sb1)*100 + int(sb2)
ans = A * B100 // 100
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

def resolve():
    from decimal import Decimal
    import math
    a,b=map(float, input().split())
    a=str(a)
    b=str(b)
    a=Decimal(a)
    b=Decimal(b)
    print(math.floor(a*b))
resolve()

Submission status: Accepted

Solution code:
import math
import decimal

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

A, B = input().split()

A = np.int64(A)

B1 = np.int64(B[0])

B2 = np.int64(B[2:4])

res = (A * B1) + (A * B2) // 100

# print(A)
# print(B)

# print(B1)
# print(B2)

print(res)

Submission status: Accepted

Solution code:
#import sys
MOD = 10 ** 9 + 7
INFI = 10**10
#input = sys.stdin.readline
import math
from collections import deque
import itertools
import heapq
#import bisect
from fractions import Fraction
import copy
from functools import lru_cache



def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

#    h,w,a,b = map(int, input().split())
#    c = [[0 for j in range(n)] for i in range(n)]

def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)



def main():
    n=list(input().split())
    a=int(n[0])
    b=int((str(n[1][0])+str(n[1][2:4])))
#    print(a,b)
    ans=a*b//100
    temp=float(n[1])
 #   print(a*temp)
    print(ans)










if __name__ == "__main__":

    main()

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

b1,b2 = map(int,B.split("."))
B = 100*b1 + b2
print((A*B)//100)

Submission status: Accepted

Solution code:
from decimal import Decimal

s = input().split()

a = int(s[0])
b = Decimal(s[1])

print(int(a * b))

Submission status: Accepted

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

print(m.quantize(0, rounding=ROUND_FLOOR))

Submission status: Accepted

Solution code:
A, B = map(str, input().split())
A = int(A)
ans = A * int(B[0])
ans2 = A * int(B[2]) // 10
ans3 = (A * int(B[2]) - ans2 * 10) / 10
ans4 = A * int(B[3]) // 100
ans5 = (A * int(B[3]) - ans4 * 100) / 100
#print(ans, ans2, ans3, ans4, ans5)
print(int(ans + ans2 + ans4) + int(ans3 + ans5))

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_DOWN

A, B = input().split()
X = Decimal('0')

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

X = (A*B).quantize(Decimal('0'), rounding=ROUND_DOWN)

print(X)

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

# A = 10**15
# B = 9.99
# for i in range(0, 10):
#     # _B = i / 100
#     _B = Decimal(i) / Decimal(100)
#     print('_B', _B)
#     print(A * _B, int(A * _B))

#     print('Decimal', Decimal(10**15) * _B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

a, b = input().split()
a = int(a)
b1, b2 = b.split(".")
b1 = int(b1)
b2 = int(b2)
ans = a * b1 + a * b2 // 100
print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal
import math
AB = input().split()

a = int(AB[0])
b = Decimal(AB[1])

print(math.floor(a * b))

Submission status: Accepted

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

def solve(A: int, B: float):
    A = Decimal(str(A))
    
    B = Decimal(str(B))
    
    print(int(A*B))
    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 = float(next(tokens))  # type: float
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import random
A,B = input().split()
A = int(A)
B = list(B)
B.remove(".")
B = int("".join(B))
ans = A*B//100
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import decimal

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

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

print(decimal.Decimal(A*B).quantize(decimal.Decimal('1.'), rounding=decimal.ROUND_DOWN))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys


def main():
    A,B=input().split()
    A=int(A)
    B=int(B.replace(".",""))
    m=str(A*B)

    if len(m)<=2:
        print("0")
    else:
        res=int(m[:len(m)-2])
        print(res)

if __name__ == "__main__":
    main()