Problem:


Score : 300 points

Problem Statement

Compute A \times B, truncate its fractional part, and print the result as an integer.

Constraints

0 \leq A \leq 10^{15}

0 \leq B < 10

A is an integer.

B is a number with two digits after the decimal point.

Input

Input is given from Standard Input in the following format:

A B

Output

Print the answer as an integer.

Sample Input 1

198 1.10

Sample Output 1

217

We have 198 \times 1.10 = 217.8. After truncating the fractional part, we have the answer: 217.

Sample Input 2

1 0.01

Sample Output 2

0

Sample Input 3

1000000000000000 9.99

Sample Output 3

9990000000000000



Sample input:
198 1.10


Sample output:
217

Submission status: Accepted

Solution code:
import math

A, B = input().split()
A = int(A)
Bc, Bp = map(int, B.split("."))
print(A*Bc + A*Bp//100)

Submission status: Accepted

Solution code:
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
from decimal import Decimal
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
#import numpy as np
INF = float("inf")
#d = defaultdict(int)
#d = defaultdict(list)
#N = int(input())
#A = list(map(int,input().split()))
#S = list(input())[:-1]
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = [int(input()) for _ in range(N)]
#S = [list(input())[:-1] for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
A,B = map(Decimal,input().split())
if round(A) == 0 or B <= 0.005:
    print(0)
else:
    print(math.floor(A*B))

Submission status: Accepted

Solution code:
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
#import numpy as np
INF = float("inf")
#d = defaultdict(int)
#d = defaultdict(list)
#N = int(input())
#A = list(map(int,input().split()))
#S = list(input())[:-1]
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = [int(input()) for _ in range(N)]
#S = [list(input())[:-1] for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
A,B = map(float,input().split())
if math.floor(A) == 0 or B <= 0.005:
    print(0)
else:
    A = int(A)
    B *= 100.0
    B = round(B)
    c = A*B
    c = round(c)
    print(c // 100)

Submission status: Accepted

Solution code:
from decimal import *
input = input()
A = Decimal(input.split()[0])
B = Decimal(input.split()[1])
#result = int(Decimal(str(A*int(B*100))).quantize(Decimal('1E2'), rounding=ROUND_DOWN) * Decimal(0.01))
print (int(A*B))

Submission status: Accepted

Solution code:
# w/o decimal module

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
#文字列を一文字ずつ数字に変換、'5678'を[5,6,7,8]とできる
def LSI(): return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N): return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
#文字列として取得
def ST(): return sys.stdin.readline().rstrip()
def LST(): return sys.stdin.readline().rstrip().split()
def LST2(N): return [sys.stdin.readline().rstrip().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)

A,B = list(map(float,input().split()))
B = int(B*100+0.1)
A = int(A)
ans = A*B//100
print(ans)

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
bint, bdec = map(int, b.split('.'))

b = 100*bint + bdec
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:
A, B = input().split()

B = B.split(".")

print(int(A) * int(B[0]) + int(A) * int(B[1]) // 100)

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:
a, b = input().split()
a, b = int(a), b.replace('.','')
b = int(b[0])*100 + int(b[1])*10 + int(b[2])*1
print(a*b//100)

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
import math
import sys
def input():
    return sys.stdin.readline().rstrip('\n')


def calc(A, B):
    V = A % 100
    U = A // 100
    return U * B + V * B // 100
    

S = input().split()
A = int(S[0])
B = int(S[1].replace('.', ''))
print(calc(A, B))

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])
ans = A*B // 100
print(ans)

Submission status: Accepted

Solution code:
a,b=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 sys import setrecursionlimit, exit
setrecursionlimit(1000000000)

from fractions import Fraction

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

main()

Submission status: Accepted

Solution code:
from math import floor
from fractions import Fraction

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

main()

Submission status: Accepted

Solution code:
from sys import setrecursionlimit, exit
setrecursionlimit(1000000000)

import re

def main():
    ipt = re.split('[ .]', input())
    a = int(ipt[0])
    b = int(ipt[1]) * 100 + int(ipt[2])
    print(a * b // 100)

main()

Submission status: Accepted

Solution code:
from decimal import *
input = input()
A = Decimal(input.split()[0])
B = Decimal(input.split()[1])
result = int(Decimal(str(A*int(B*100))).quantize(Decimal('1E2'), rounding=ROUND_DOWN) * Decimal(0.01))
print (result)

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:
A, B = map(str, input().split())
A = int(A)
B = B.replace('.','')
while len(B) < 3:
  B = B + '0'

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

Submission status: Accepted

Solution code:
from decimal import *

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

print(int(x*y))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
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, B = int(A), int(B.replace('.', ''))
print(A * B // 100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal,  getcontext

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

Submission status: Accepted

Solution code:
import math

a,b = input().split()

a = int(a)

n1 = int(b[0])
n2 = int(b[2])
n3 = int(b[3])

resposta = ((a * n1 * 100) + (a * n2 * 10) + (a *n3))//100

print(resposta)

Submission status: Accepted

Solution code:
i = list(input().split())
a = int(i[0]);
b = int(i[1][:1] + i[1][2:])
print(a*b // 100)

Submission status: Accepted

Solution code:
s = list(input().split())
a = int(s[0]);
b = int(s[1][:1]+s[1][2:])
print(a*b//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

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

Submission status: Accepted

Solution code:
A, B = input().split()
A = int(A)
# B = int(B.replace('.', ''))
B = float(B)
B = int(B * 100 + 2 ** (-6))
ans = A * B // 100
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.readline

from fractions import Fraction
A,B = readline().split()
A = int(A)
B = Fraction(B)

print(int(A * B))

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.readline

A,B = readline().split()
A = int(A)
B = round(float(B) * 100)

print(A * B // 100)

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.readline

A,B = readline().split()
A = int(A)
B = int(float(B) * 100 + 0.5)

print(A * B // 100)

Submission status: Accepted

Solution code:
li = input().split()
x = li[0]
x = int(x)
y = li[1]
y = y.replace('.','')
y = int(y)
print(x*y//100)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(int(A * B))

Submission status: Accepted

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

A = int(A)

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

print(int(A * B // 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:
from decimal import Decimal

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

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

Submission status: Accepted

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


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
from decimal import Decimal


AB = list(map(Decimal, input().split()))

result = int((AB[0] * AB[1]))
print(result)

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

B *= 100

print(math.floor(A * B / 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:
def main():
    a,b = input().split()
    a = int(a)
    b = round(float(b)*100)
    print(a*b//100)
if __name__ == "__main__":
    main()

Submission status: Accepted

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

a = int(line[0])
b = line[1]

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

print((a*b)//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *
ii = lambda:int(input())
mi = lambda:list(map(int,input().split()))
ix = lambda x:list(input() for _ in range(x))
mix = lambda x:list(mi() for _ in range(x))
iix = lambda x:list(int(input()) for _ in range(x))
##########
def main(a,b):
    a = int(a)
    b = Decimal(b)
    print(int(a*b))

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

if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:

a,b=map(float,input().split())
B=round(100*b)
print(int(a)*B//100)

Submission status: Accepted

Solution code:
# import math
from decimal import Decimal
A, B = [x for x in input().split(" ")]
A = int(A)
B = int(Decimal(B) * 100)

# if A > 10**15 or A < 0:
#   exit(1)
# if B < 0 or B > 10:
#   exit(1)

print(A * B // 100)

Submission status: Accepted

Solution code:
from fractions import Fraction

A, B = input().split()
A = int(A)
B = Fraction(B)
print(int(A * 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 = map(float, input().split())
B = round(B * 100)
print(int(A) * B // 100)

Submission status: Accepted

Solution code:
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[0] + b[2] + b[3])

print(a*b // 100)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

a,b = LS()
b = b.replace(".","")
x = int(a)
y = int(b)

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

Submission status: Accepted

Solution code:
from decimal import *

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

Submission status: Accepted

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

main()

Submission status: Accepted

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

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

print(int(A*B))

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
from decimal import Decimal 
def main():
    A, B = map(Decimal, input().split())
    ans = int(A*B)
    # A = round(A)
    # B = round(B*100)
    # ans = round(A*B) 
    # ans = ans//100
    print(ans)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal

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

A_int=int(A)
B_100int=int(B*int(100))

C=int(A_int*B_100int//int(100))

print(C)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *

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

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

Submission status: Accepted

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

seki = aa * b_100
ans = seki // 100

# ans=math.floor(aa*b_100/100)

# ab = Decimal(A) * Decimal(B)
# ans = math.floor(ab)

print(ans)

Submission status: Accepted

Solution code:
from decimal import *

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

Submission status: Accepted

Solution code:
NUM=list(input().split())
A=int(NUM[0])
B=float(NUM[1])
BB=int(round(B*100))
ABB=A*BB
ANS=ABB//100
print(int(ANS))

Submission status: Accepted

Solution code:
A,B = map(str, input().split())
A = int(A)
period_index = B.index(".")
B_after_the_decimal = int(B[period_index+1:])
B_before_the_decimal = int(B[0:period_index])

include_decimal = str(int(A*B_after_the_decimal))
include_decimal = include_decimal[:len(include_decimal)-(len(B) - period_index -1)]

if include_decimal != "":
    include_decimal = int(include_decimal)
    ans = include_decimal + A*B_before_the_decimal
else:
    ans = A*B_before_the_decimal
    
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B = map(str, input().split())
ans = 0
index = 0
B = B[::-1]
for b in B:
  if b == ".":
    continue
  ans += int(A) * int(b) * 10**index
  index += 1
print(ans//100)

Submission status: Accepted

Solution code:
#from collections import deque,defaultdict
from sys import stdin
input = stdin.readline
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

from decimal import Decimal
a,b = input().split()
a = int(a)
b = float(b)
b = round(100*b)
print(a*b//100)

Submission status: Accepted

Solution code:
from fractions import Fraction
from decimal import Decimal
from math import floor

A, B = input().split()

ans = Decimal(A) * Decimal(B)
print(floor(ans))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

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


def solve():
    A, B = rl().split()
    A = int(A)
    B = B.split('.')
    B = int(B[0] + B[1])
    ans = A * B // 100
    print(ans)


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
#! /usr/bin/env python3
a, b = input().split()
c = d = 0
if float(a) > 0 and '.' in a : c = a[::-1].find('.')
if float(b) > 0 and '.' in b : d = b[::-1].find('.')
t = int(a.replace('.', '')) * int(b.replace('.', ''))
if t == 0 or len(str(t)) < c+d:
    print(0)
elif c+d < 1:
    print(t)
else:
    print(str(t)[:-(c+d)])

Submission status: Accepted

Solution code:
def main():
    A, B = input().split()
    a = int(A)
    b = round(1000 * float(B))
    print((a * b) // 1000)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:

def two_sum(a, b):
    s = a + b
    v = s - a
    e = (a - (s - v)) + (b - v)
    return s, e

def split(a):
    t = ((2. ** 27) + 1.) * a
    high = t - (t - a)
    low = a - high
    return high, low

def two_prod(a, b):
    p = a * b
    ah, al = split(a)
    bh, bl = split(b)
    e = ((ah * bh - p) + ah * bl + al * bh) + al * bl
    return p, e

def mul(a, ae, b, be):
    c, ce = two_prod(a, b)
    ce += ae * b + a * be + ae * be
    return two_sum(c, ce)

def div(a, ae, b, be):
    c = a / b
    t, te = two_prod(-c, b) # ~ -a
    ce = (((a + t) + te + ae) - be * c) / b
    return two_sum(c, ce)

def solve(a, b, debug=False):
    from math import floor
    c, ce = div(round(b * 100.), 0., 100., 0.) # c = round(b * 100) / 100
    if debug:
        print(f'... {round(b * 100)} / 100 = {c} + {ce}')
    p, pe = mul(a, 0., c, ce) # p = a * c
    if p < 1.0: return 0
    ph, pl = split(p) # ph + pl = p
    pl, pe = two_sum(pl, pe)
    if debug:
        print(f'... {a} * {b} = {ph} + {pl} + {pe}')
    return int(ph) + int(floor(pl))

def main():
    a, b = input().split(' ')
    print(solve(int(a), float(b)))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# ABC 169
import math

a, b = input().split()
a = int(a)
b = int(round(float(b)*100))
print(a*b//100)

Submission status: Accepted

Solution code:
import math
A,B = input().split()
A = int(A)
B = B.replace(".","")
 
B = int(B)
print(math.floor(A*B//100))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

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

import math

bint = round(b*100)
aint = round(a)
print(aint*bint//100)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if B[0] == 0:
    BH =      B[2]+B[3]
else:
    BH = B[0]+B[2]+B[3]

ABH = str(int(A)*int(BH))
if len(ABH) <= 2:
    print('0')
else:
    print(ABH[:-2])

Submission status: Accepted

Solution code:
def solve(string):
    a, b = string.split()
    b = "".join(b.split("."))
    return str(int(a) * int(b) // 100)


if __name__ == '__main__':
    import sys
    print(solve(sys.stdin.read().strip()))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from math import floor
from fractions import Fraction

A, B = input().split()

print(floor(int(A) * Fraction(B)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

a += 0.001
b += 0.001

a = int(a)
b = int(b*100)
mul = a*b
mod = mul%100
ans = (mul - mod)//100
print(ans)

Submission status: Accepted

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

from decimal import *

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

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

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

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

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

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

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

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

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

##### とても大きな数 と 小数の計算誤差 #####
# 「Decimal」は計算誤差を 0にできる。必要に応じて粒度を設定せよ。
# getcontext().prec = 100
#
# tmp = Decimal(i)
# A,B = map(Decimal, input().split())
# ans = A * B

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

inf = float('inf')
mod = 1000000007

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

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

	ans = A * B

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

Submission status: Accepted

Solution code:
str_a, str_b = input().split()
a = int(str_a)
b_100 = int(str_b.replace('.', ''))
print(a * b_100 // 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:
import math
from decimal import *
A,B=input().strip().split()
result=math.floor(Decimal(A)*Decimal(B))
print(result)

Submission status: Accepted

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


def main():
    A, B = map(Decimal, input().split())
    print(int(A * B))


if __name__ == "__main__":
    main()

Submission status: Accepted

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