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

Submission status: Accepted

Solution code:
line = input()
nums = line.split(" ")
a = int(nums[0])
b = int(nums[1].replace(".", ""))
print(str(a*b)[:-2] or 0)

Submission status: Accepted

Solution code:
A, B = input().split()
li = []
for i in range(len(B)):
    if B[i] != ".":
        li.append(B[i])
li.reverse()
num = 1
num2 = 0
for i in range(len(li)):
    num2 += num * int(li[i])
    num *= 10
A = int(A)
B = num2
C = A * B
D = C % 100
C = C - D
C = C // 100
print(C)

Submission status: Accepted

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

    ans = str(a * b100)
    if len(ans) > 2:
        ans = ans[:-2]
    else:
        ans = 0

    ans = int(ans)
    print(ans)
resolve()

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

print(int(a*b))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *

tmp = input().split()

A = Decimal(tmp[0]).quantize(Decimal("0"), rounding=ROUND_HALF_UP)
B = Decimal(tmp[1]).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
import math

a,b=[float(x) for x in input().rstrip().split()]
a = Decimal(str(a))
b = Decimal(str(b))
print(math.floor(a*b))

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
a = list(map(str,input().split()))
a[0]=int(a[0])
a[1]=Decimal(a[1])
ans=a[0]*a[1]
print(math.floor(ans))

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

Submission status: Accepted

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

Submission status: Accepted

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

import decimal
A=int(A)
B=decimal.Decimal(B)

print(int(A*B))

Submission status: Accepted

Solution code:
from decimal import Decimal
import math

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

c = a * b
d = math.floor(c)
print(d)

Submission status: Accepted

Solution code:

import numpy as np;
from numba import jit
from decimal import Decimal


if __name__ == '__main__':
  A, B = map(Decimal, input().split())
  ans = A * B
  print("%d" %ans)

Submission status: Accepted

Solution code:
from math import floor
a,b = input().split()
c = ""
for i in b:
    if i!=".":
        c+=i
# print(c)
c = int(c)
# b = int(float(b)*100)
a = int(a)
print((a*c)//100)

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:
import math
from decimal import Decimal
a,b = [Decimal(i) for i in input().split()]
print(Decimal(math.floor(a*b)))

Submission status: Accepted

Solution code:
from collections import defaultdict
from math import gcd
import time
import sys
from collections import Counter
import itertools
import math
from decimal import *
# read = sys.stdin.buffer.read
# readline = sys.stdin.buffer.readline
# readlines = sys.stdin.buffer.readlines
input = sys.stdin.readline

temp = input().split(" ")
a = Decimal(temp[0])
b = Decimal(temp[1])
ans = a*b
print(math.floor(ans))

Submission status: Accepted

Solution code:
import math
A,B=input().split()
A=int(A)
x=int(B[-2:])
y=int(B[:-3])

print(A*y + A*x//100)

Submission status: Accepted

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

for i, c in enumerate(b):
    if c == ".":
        break
u = 10**(len(b)-i-1)
b_n = "".join(b.split("."))

print(int(a)*int(b_n)//u)

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:
S = input()
A, B = S.split(" ")
A = int(A)
b1, b2, b3 = int(B[0]), int(B[2]), int(B[3])

ans = A*b1 + (A*10*b2 + A*b3)//100

print(ans)

Submission status: Accepted

Solution code:
from decimal import *
N, M = input().strip().split()
N=int(N)
x = Decimal(str(M))
x = x * 100

print(x*N//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math

sys.setrecursionlimit(10**7)

a, b = input().split()
a = int(a)
b = "".join(b.split("."))
if b == "000":
    b = 0
else:
    i=0
    while b[i] == "0":
        i += 1
    b = int(b[i:])
ans = str(a*b//100)
i=0
while i < len(ans) and ans[i] != ".":
    i += 1
print(ans[:i])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# from math import factorial,sqrt,ceil #,gcd
# from itertools import permutations,combinations,combinations_with_replacement
# from collections import deque,Counter
# from bisect import bisect_left
# from heapq import heappush,heappop
# from numba import njit
# from functools import lru_cache # 簡単メモ化 @lru_cache(maxsize=1000)
# from fractions import gcd

from decimal import Decimal, getcontext
getcontext().prec = 1000
# # eps = Decimal(10) ** (-100)

# import numpy as np    # numpy.lcm()
# from scipy.sparse.csgraph import shortest_path, dijkstra, floyd_warshall, bellman_ford, johnson
# from scipy.sparse import csr_matrix
# from scipy.special import comb,perm #permはnPk
# import networkx as nx
# G = Graph()
import math
# slist = "abcdefghijklmnopqrstuvwxyz"
A,B = input().split()
# A = int(A)
# B = float(B)*10000

# B = round(B,-2)
# ans = A*B//10000

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

ans = A*B

# print(A,B,ans)
print(int(ans))
# for row in board:
#     print(*row,sep="")    #unpackして間にスペース入れずに出力する
# print("{:.10f}".format(ans))
# print("{:0=10d}".format(ans))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7


def inp():
    '''
    一つの整数
    '''
    return int(input())


def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))


def str_inp():
    '''
    文字列をリストとして読み込む
    '''
    return list(input()[:-1])


a, b = input().split()
a = int(a)
b = list(b)
dot = 0
for i in range(len(b)):
    if b[-i - 1] == ".":
        dot = i
        del b[-1 - i]
        b = int("".join(b))
        break
ans = str(a * b)
if len(ans) <= dot:
    ans = 0
else:
    ans = ans[:-dot]
print(ans)

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
from decimal import Decimal
import math


a, b = input().split()

ax = Decimal(a)
bx = Decimal(b)

ans = ax*bx

print(math.floor(ans))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
data = input().rstrip().split(" ")
if float(data[1]) == 0.0:
    print(0)
else:
    A = int(data[0])
    B = round(float(data[1])*100)
    calc = A*B
    if calc <100:
        print(0)
    else:
        ans = str(calc)
        k = len(ans)-2
        print(ans[0:k])

Submission status: Accepted

Solution code:
import itertools
import decimal
import math

A,B=input().split()

An=decimal.Decimal(A)
Bn=decimal.Decimal(B)
ans=decimal.Decimal(An*Bn).quantize(decimal.Decimal('0'), rounding=decimal.ROUND_DOWN)
print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
from decimal import *
import math

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

print(c.quantize(0, ROUND_FLOOR))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
from decimal import Decimal
a, b = input().split()

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

L, R = map(Decimal, input().split())
ans = math.floor(L * R)
print(ans)

Submission status: Accepted

Solution code:
import sys

A, B = sys.stdin.readline().strip().split()
A = int(A)
for i in range(1000):
    if i < 10:
        s = "0.0" + str(i)
    elif i < 100:
        s = "0." + str(i)
    else:
        i = str(i)
        s = i[0] + "." + i[1:]
    if B == s:
        B = int(i)
print(A*B // 100)

Submission status: Accepted

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

b= decimal.Decimal(b)

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

from decimal import Decimal

a,b=input().rstrip().split(" ")
u=Decimal(a)*Decimal(b)
#print(u)
print(int(u))
'''a=int(a)
b=float(b)
#print(b)
u=int(100*b)
#print(u)
print(int(a*b))
#print((a*u)//100)'''

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

x= Decimal(a)*Decimal(b)
x= Decimal(x)-Decimal(x)%1
print(int(x))

Submission status: Accepted

Solution code:
import numpy as np
A, B = input().split()
A = np.array(A).astype(np.int64)

n = len(B)
Bs = []
for i in range(n):
  if i !=  1:
    Bs.append(np.array(B[i]).astype(np.int64))
Bs

if n == 4:
  sums = A*Bs[0]*100 + A*Bs[1]*10 + A*Bs[2]
elif n ==3:
  sums = A*Bs[0]*100 + A*Bs[1]*10
else:
  sums = A*Bs[0]*100

print(sums//100)

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_DOWN
import math

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

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

print(math.floor(A*B))

Submission status: Accepted

Solution code:
from decimal import *
a,b = input().split()
ans = Decimal(a) * Decimal(b)
print(ans.quantize(Decimal("1"),rounding=ROUND_DOWN))

Submission status: Accepted

Solution code:
a,s=[x for x in input().split()]
for i in range(len(s)):
    if s[i]=='.':
        ans=s[0:i]+s[i+1:]
        break
p=str(int(a)*int(ans))
if len(p)<3:
    print(0)
else:
    print(p[0:len(p)-2])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

A, B = input().split()

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

C = A*B
C = int(C)

print(C)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
A, B = map(str, input().split())

A_num = int(A)
if B == "10.00":
    print(A_num * 10)
else:
    B_num = int(B[0]) * 100 + int(B[2]) * 10 + int(B[3])
    print(int((A_num * B_num) // 100))

Submission status: Accepted

Solution code:
a = input().split(" ")

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

Submission status: Accepted

Solution code:
from decimal import *

A, B = input().split()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import *

if __name__ == "__main__":
    A, B = [Decimal(a) for a in input().split()]
    ans = A*B
    ans = math.floor(ans)
    print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal

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

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

Submission status: Accepted

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

result = str(A * B)[:-2]

print(result if result != "" else 0)

Submission status: Accepted

Solution code:
import math

a, b = map(str, input().split())
a = int(a)
b = int(b.replace('.', ''))
ans = str(a * b)

if len(ans) > 2:
    print(int(ans[:-2]))
else:
    print(0)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b = input().split()
A = int(a)
Bn,Bs = map(int, b.split('.'))

C1 = A * Bn

abs = str(A * Bs)
if A * Bs > 99:
    C2 = int(abs[:-2])
else:
    C2 = 0
print(C1+C2)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import re
A, B, C = map(int, re.split(r'[ \.]', input()))
print(A * (100 * B + C) // 100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
a, b = input().split()
c = int(a) * Decimal(b)
cl = list(str(c))
s = ""
for i in range(len(cl)):
    if cl[i] == '.':
        break
    else:
        s += cl[i]
print(s)

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()

def main():
    a, b = input().split()
    A = int(a)
    B = int(b[0] + b[2:])
    x = A * B
    print(x // 100)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import math
S=list(map(str, input().split()))
a=S[0]
b=S[1]
c=b[0]+b[2]+b[3]
print(math.floor(int(a)*(int(c))//100))

Submission status: Accepted

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

Submission status: Accepted

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

B_i = int(B[:-3])
B_f = int(B[-2:])


f = str(A*B_f)
if (len(f) >= 3):
    f_i = int(f[:-2])
else:
    f_i = 0

print(A*B_i + f_i)

Submission status: Accepted

Solution code:
from decimal import Decimal

if __name__ == "__main__":
    a, b = list(input().split())
    a = Decimal(a)
    b = Decimal(b)

    print(int(a*b))

Submission status: Accepted

Solution code:
from decimal import Decimal

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
import numpy as np

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

c = b * 100 
 
if (c % 1) >= 0.5:
    c = int(c) + 1

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

print(int(ans))

Submission status: Accepted

Solution code:
from decimal import Decimal

inlist = input().split()
num1 = int(inlist[0])
num2 = Decimal(inlist[1])

print(int(num1*num2))

Submission status: Accepted

Solution code:
from decimal import *


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

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
tmp = [i for i in input().split()]

a = int(tmp[0])
b = int(float(tmp[1]) * 1000)

result = a*b//1000
print(result)

Submission status: Accepted

Solution code:
import decimal

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

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

res = A * B
res = int(res)

print(res)

Submission status: Accepted

Solution code:
import sys
import math

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60


def main():
    A, B = readline().split()
    A = int(A)
    B1, B2 = B.split('.')
    B1 = int(B1)
    B2 = int(B2)

    ans = A * B1 + int(A * B2 // 100)
    print(ans)

    return


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

a = int(a)
c = b[0] + b[2] + b[3]
c = int(c)

ans = a*c //100

print(ans)

Submission status: Accepted

Solution code:
from decimal import *
li = list(map(str,input().split()))
print(int(Decimal(li[0]) * Decimal(li[1])))

Submission status: Accepted

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

Submission status: Accepted

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

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

ans = int(a*b)

print(ans)

Submission status: Accepted

Solution code:
import math
a,b=map(lambda x:x,input().split())
a=int(a)
for i in range(len(b)):
    if b[i]==".": b=int(b[:i]+b[i+1:]);break

print(a*b//100)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

# a = int(a)
# b = float(b)

ab = Decimal(a) * Decimal(b)


print(math.floor(ab))

Submission status: Accepted

Solution code:
s = list(input().split())
a = int(s[0])
b = int(s[1].replace('.',''))*100
ans = str(a*b//100)
n = len(ans)
if n <= 3:
    print(0)
else:
    print(ans[:n-2])

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math

MOD = 10 ** 9 + 7
# MOD = 998244353

a, b = input().split()
a = int(a)
b = "".join(b.split("."))
b = b + "0"*(3 - len(b))
b = int(b)
ans = a*b
print(ans//100)

Submission status: Accepted

Solution code:
from decimal import Decimal

A, B = [n for n in input().split()]
print(int(Decimal(A) * Decimal(B)))

Submission status: Accepted

Solution code:
import numpy as np
import sys
sys.setrecursionlimit(10 ** 9)
from decimal import Decimal
def main():
    a, b = map(Decimal, input().split())
    a = int(a)
    ans = a * b
    print(int(ans))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
inpl = lambda: list(map(int,input().split()))
A, B = input().split()
A = int(A)
B1, B2 = list(map(int,B.split('.')))
C = int(100*B1+B2)
print(A*C//100)

Submission status: Accepted

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

b = int(b*100+0.1)
c = a*b
c = c//100

print(c)

Submission status: Accepted

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

C = ""

for i in range(len(B)):
    if B[i]!=".":
        C+=B[i]
if C[0]=="0" and len(C)>1:
    C = int(C[1:])
else:
    C = int(C)

print((A*C)//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_FLOOR

A, B = map(Decimal, input().split())
print(Decimal(A*B).quantize(Decimal('0'), rounding=ROUND_FLOOR))

Submission status: Accepted

Solution code:
import math
import decimal

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

print(math.floor(a*b))

Submission status: Accepted

Solution code:
# A, B = [i for i in input().split()]
#
# A = int(A)
# B = float(B)
# B100 = int(B*100)
#
# print((B100*A)//100)

import decimal
A, B = [decimal.Decimal(i) for i in input().split()]

C =A*B

ans = int(C)
print(ans)

Submission status: Accepted

Solution code:
import sys
import math
from functools import reduce
from operator import mul
sys.setrecursionlimit(10**6)

def InMap(): return list(map(int, sys.stdin.readline().split(' ')))
def In(): return int(sys.stdin.readline())
def InS(): return sys.stdin.readline()

S = InS()
A = int(S.split(' ')[0])
B = S.split(' ')[1]
B = B[0] + B[2] + B[3]
# A *= B
print(A * int(B) // 100)

Submission status: Accepted

Solution code:
from decimal import *
import math

a, b = input().split()

ans = Decimal(a) * Decimal(b)

print(math.floor(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
from decimal import *

a, b = input().split()

result = Decimal(a) * Decimal(b)

result = result.quantize(Decimal('0'), rounding=ROUND_DOWN)
print(result)

Submission status: Accepted

Solution code:
# C

A, B = list(input().split())
A = int(A)
B = int(B.replace('.', ''))
res = A * B
res = res // 100
print(res)

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:
sr=input().split( )
a=int(sr[0])
ans=0
ans+=int(sr[1][0])*100
ans+=int(sr[1][2])*10
ans+=int(sr[1][3])
t=a*ans//100
print(t)

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

sys.setrecursionlimit(10**7)

ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

from decimal import Decimal

a, b = nas()

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

print(int(a * b))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
#from math import gcd
import bisect
from collections import defaultdict
from collections import deque
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]

######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()

#####Shorten#####
def DD(arg): return defaultdict(arg)


#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
  arr = []
  temp = n
  for i in range(2, int(-(-n**0.5//1))+1):
    if temp%i==0:
      cnt=0
      while temp%i==0: 
        cnt+=1 
        temp //= i
      arr.append([i, cnt])
  if temp!=1:
    arr.append([temp, 1])
  if arr==[]:
    arr.append([n, 1])
  return arr

#####MakeDivisors######
def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors

#####MakePrimes######
def make_primes(N):
  max = int(math.sqrt(N))
  seachList = [i for i in range(2,N+1)]
  primeNum = []
  while seachList[0] <= max:
    primeNum.append(seachList[0])
    tmp = seachList[0]
    seachList = [i for i in seachList if i % tmp != 0]
  primeNum.extend(seachList)
  return primeNum

#####GCD#####
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#####BitCount#####
def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count

#####ChangeBase#####
def base_10_to_n(X, n):
  if X//n:
    return base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def base_n_to_10(X, n):
  return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))

#####IntLog#####
def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count

#############
# Main Code #
#############
A,B = SL()
A = int(A)
B = int(B[0]+B[2]+B[3])

print((A*B)//100)

Submission status: Accepted

Solution code:
from sys import stdin
import sys
import math
import random
from decimal import Decimal


s = input().split()
A = Decimal(s[0])
B = Decimal(s[1])
print(int(A*B))

Submission status: Accepted

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

Submission status: Accepted

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

ad = decimal.Decimal(a)
ab = decimal.Decimal(b)

#print(ad, ab)

result = (ab * ad).quantize(decimal.Decimal('0'), rounding=decimal.ROUND_FLOOR)

print(result)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import decimal
A=[decimal.Decimal(x) for x in input().split()]
print(int(A[0]*A[1]))

Submission status: Accepted

Solution code:
# ABC169 C Multiplication 3

a, b = map(lambda x: int(x.replace(".","")), input().split())

print(a*b//100)

Submission status: Accepted

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

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