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:
a, b = map(float, input().split())


b = round(b*100)

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

print(int(ans))

Submission status: Accepted

Solution code:
from decimal import Decimal
import decimal

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

sum=a*b
val_pi_d = decimal.Decimal(sum)

# decimal型による切り捨て
val_floor_d = val_pi_d.quantize(decimal.Decimal('0.001'), rounding=decimal.ROUND_FLOOR)
print(int(val_floor_d))

Submission status: Accepted

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


def solve(A: int, B: float):
    B *= 1000
    C = int(B)
    print(A * C // 1000)

    # Bbig = int(B)
    # # print(Bbig)
    # Bsmall = int((B - Bbig) * 10)
    # # print(Bsmall)
    # Bsmall2 = int((B - Bbig) * 100) - Bsmall * 10
    # # print(Bsmall2)
    # Abig = A * Bbig * 100
    # # print(Abig)
    # Asmall = (A * Bsmall) * 10
    # # print(Asmall)
    # Asmall2 = (A * Bsmall2)
    # # print(Asmall2)
    # print((Abig + Asmall + Asmall2) // 100)
    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 decimal
import math
A,B=list(map(decimal.Decimal,input().split()))
C=decimal.Decimal(A*B)
print(math.floor(C))

Submission status: Accepted

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

def main():
    a,b = list(map(float,sys.stdin.readline().split()))
    a = int(a)
    b100 = round(b * 100)
    
    ans = (a * b100) // 100
    print(str(ans))

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#import math
from decimal import *
# 小数を制御

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal


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:
from decimal import Decimal
ab = input().split()
a = Decimal(ab[0])
b = Decimal(ab[1])
print(int((a*b)))

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

import sys
import math
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

A, B = readline().decode().rstrip().split()
A = int(A)
B = 100 * int(B[0]) + 10 * int(B[2]) + int(B[3])

ans = A * B // 100

print(ans)

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
A,B=list(input().split())
A = Decimal(A)
B = Decimal(B)
# print(A* B)
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//100)

Submission status: Accepted

Solution code:
#import math
#N=int(input())
A,B = map(float,input().split())
#N=int(input())
#A = list(map(int,input().split()))
#S=str(input())
A=int(A)
B=round(B*100)
c=A*B
c=str(c//100)
print(c)

Submission status: Accepted

Solution code:
import math

def main():
    A,B = [x for x in input().split()]
    print(int(A)*round(float(B)*100)//100)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
from decimal import Decimal

sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
#read = sys.stdin.buffer.read

def main():
    N1 = list(readline().split())
    N = int(N1[0]); M = Decimal(N1[1])
    ans = int(N*M)
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def main():
    A, B = (str(i) for i in input().split())
    a = int(A)
    b = int("".join(b for b in B if b != "."))
    ans = a*b
    print(ans//100)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
A,B = map(float, input().split())
a = int(A)
b = round(B*100)
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 = map(str, input().split())
A = int(A)
B = float(B)
B = int(1000 * B)
ans = A * B // 1000
print(ans)

Submission status: Accepted

Solution code:
ab = list(input().split())
a = int(ab[0])
b = int(float(ab[1]) * 1000)

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
a, b = input().split()
a = int(a)
b_ = b[0]+b[2]+b[3]
b100 = int(b_)
# print(a*b)
print(int((a*b100)//100))

Submission status: Accepted

Solution code:

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

A=int(A)
B=int(B*1000)

ans=A*B//1000

print(ans)

Submission status: Accepted

Solution code:
"""
[a,b]=list(map(float,input().split()))
import math
a=int(a)
b=int(b*100)
ans=a*b
ans=ans/100
ans=math.floor(ans)
print(ans)
"""
[a,b]=list(input().split())
a=int(a)
b12=list(b.split('.'))
bkai=int(int(b12[0])*100+int(b12[1]))
ans=a*bkai
ans=ans//100
print(ans)

Submission status: Accepted

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

a = int(a)
b = int(float(b)*1000)
print(int(a*b)//1000)

Submission status: Accepted

Solution code:
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

a,b = input().split()
a,b = int(a), float(b)
b += 0.00001
b = int(b*100)
# print(b)
print(int((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])
print((A * B)//100)

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
A, B = [s for s in input().split()]
A = int(A)
B = round(float(B) * 100)

print(str(A * B // 100))

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
n=input().split()
a = int(n[0])
b=Decimal(n[1])
ans = a*b

print(int(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
in_ = list(input().split())
A = int(in_[0])
B = Decimal(in_[1])
ans = Decimal(A * B)
print(int(ans))

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:
def main():
    a,b=map(float,input().split())
    a=int(a)
    print(int((b*100+0.1)//1)*a//100)
main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sun May 31 21:07:49 2020

@author: NEC-PCuser
"""

A, B = map(str, input().split())
A = int(A)
B = float(B) * 1000 // 1

C = A * int(B) // 1000
print(C)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  a,b=LS()
  a=int(a)
  b=b.replace('.','')
  b=int(b)
  
  ans=a*b
  return ans//100

# main()
print(main())

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

b = b*100
b = round(b)

ans = a*b


print(ans//100)

Submission status: Accepted

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

Submission status: Accepted

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

A = int(A)
B = float(B)
if A==0:
    print('0')
    exit()

print((A * int(B*1000) )// 1000)

Submission status: Accepted

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


input = sys.stdin.readline
def IS(cb): return cb(input().strip())
def IL(cb): return [cb(s) for s in input().strip().split()]
def IR(cb, rows): return [IS(cb) for _ in range(rows)]
def ILL(cb, rows): return [IL(cb) for _ in range(rows)]


def solve():
    ss = input().strip().split()
    A = int(ss[0])
    B = float(ss[1])
    print(A * int(B * 1000) // 1000)


solve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import math


def main():
    a, b = input().split()
    A = int(a)
    # B = int(math.floor(float(b) * 100))
    B = int(b.replace('.', ''))
    print(int(A * B // 100))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
###############################################################################
#Imports
import collections
import itertools
from functools import lru_cache
import sys
import math
from decimal import Decimal
###############################################################################
#Constants
MOD = int(1e9)+7
###############################################################################
#Helper


def helper():
	pass
###############################################################################
#Solver


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


###############################################################################
#Driver
t = 1
for _ in range(t):
	solve()
###############################################################################

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline    ####
def int1(x): return int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def SI(): return input().split()

def printlist(lst, k='\n'): print(k.join(list(map(str, lst))))
INF = float('inf')

from math import ceil, floor, log2
from collections import deque
from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product
from heapq import heapify, heappop, heappush

sys.maxsize = 1_000_000_000_000_000_000_0

def solve():
    a, b = map(float, input().split())

    a = int(a)
    b = int(b * 100 + 0.5)

    # print(a, b)
    t = a * b
    print((t - t % 100) // 100)

if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print( m )

Submission status: Accepted

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

a = int(a)
b = int(float(b)*1000)

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

Submission status: Accepted

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

print(A * B // 100)

Submission status: Accepted

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

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

print(x * y // 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:
A, B = map(float, input().split())

a = int(A)
b = round(B * 100)

print(a * b // 100)

Submission status: Accepted

Solution code:
import decimal

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

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:
# coding: utf-8


def main():
    a, b = map(str, input().split())
    # print(b)

    a = int(a)
    b = str(b)
    # print(b)
    if len(b) == 1:
        b = b[0] + "00"
    elif len(b) == 3:
        b = b[0] + b[2] + "0"
    else:
        b = b[0] + b[2] + b[3]
    # b = b[0] + b[2] + b[3]
    b = int(b)
    # print(b)
    # exit()
    
    return a*b // 100


print(main())

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
a,b=input().split()
tmp = float(b)*1000
#print(int(int(a)*float(b)))
ans = int(a) * int(math.floor(tmp))
#print(ans)

ans = str(ans)
l = len(ans)

if l < 3:
    print(int(0))
else:
    print(int(ans[:l-3]))

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:
A, B = input().split()
A = int(A)
B = int(float(B)*1000)
ans = A*B//1000
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
import numpy as np
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN


def main():
    a = list( map( float, input().split()))
    a1 = int(a[0])
    a2 = Decimal(str(a[1])).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN)
    s = a1*a2
    print(math.floor(s))
    
if __name__ == '__main__':
    main()

Submission status: Accepted

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

def solve(A: int, B: float):
    # b_i = int((B - int(B))*100)
    # print(b_i)
    # b = int((A*b_i)//100)
    # a = A*int(B) + b
    # # print(b)
    # print(a)

    print(A*int(B*1000)//1000)

    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:
from decimal import *
num = input().split()
a = Decimal(num[0])
b = Decimal(num[1])
print(int(a*b))

Submission status: Accepted

Solution code:
import sys
#input = sys.stdin.readline
 
from fractions import Fraction
 
"""
 
"""
 
a, b = map(Fraction, input().split())
print(int(a*b))

Submission status: Accepted

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

c = b.split(".")
# print(c)

l = int(a)
m = int(c[0])
n = int(c[1])

ans = ( l * ( m*100 + n ) )// 100
print(ans)

Submission status: Accepted

Solution code:
from decimal import *
from math import *

getcontext().prec = 10000
a, b = map(Decimal, input().split())
print(floor(a * b))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b=map(float,input().split())
a=int(a//1)
bigb=int((b*1000)//1)
a_front=a//1000
a_back=a-a_front*1000
#print(a,b,bigb,a_front,a_back)
 
ans_front=a_front*bigb
ans_back=a_back*b
ans_back=int(ans_back//1)
print(int(ans_front+ans_back))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B=input().split(' ')
A = int(A)
if '.' in B:
    B_int,B_float = B.split('.')
    if len(B_float) == 1:
        print(A*int(B_int)+(A*int(B_float))//10)
        print(B_int,B_float)
    else:
        print(A*int(B_int)+(A*int(B_float)//100))

Submission status: Accepted

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

import math, decimal
print(int(A) * int(B.replace('.', '')) // 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:
#3問目
import math
from decimal import Decimal 
AB = input().split()
A = int(AB[0])
B = Decimal(AB[1])

print(int(A * B))

Submission status: Accepted

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


a = int(a)
b = int(1000*float(b))

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

Submission status: Accepted

Solution code:
from math import floor

a, b = input().split()
a = int(a)
b = int(float(b)*100+0.0001)

print(a*b//100)

Submission status: Accepted

Solution code:
from decimal import Decimal
import math


aaa = list(map(float, input().split()))

'''
aaa = [1000000000000000, 0.09]
A = 1000000000000000
B = 0.09
'''


'''
print(B)
print(A)
1000000000000000 0.09
999999999999999
'''
#print(math.floor(Decimal(＃A * B)))


print(int(Decimal("{}".format(aaa[0])) * Decimal("{}".format(aaa[1]))))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# n,m = map(int,sys.stdin.readline().split())
# a = tuple(map(int,sys.stdin.readline().split())) # single line with multi param
# a = tuple(sys.stdin.readline() for _ in range(n)) # multi line with single param
# a = tuple(tuple(map(int,sys.stdin.readline().rstrip().split())) for _ in range(N)) # multi line with multi param
# s = sys.stdin.readline().rstrip()
# n = int(sys.stdin.readline())
# INF = float("inf")
# sys.setrecursionlimit(10000)
import sys,collections,math
sys.setrecursionlimit(100000)
a,b = sys.stdin.readline().split()
a = int(a)
b = float(b)
b = int(b*1000)
print(a*b//1000)

Submission status: Accepted

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

r = list(map(float,input().split()))

x = Decimal(str(r[0])).quantize(Decimal('0'),rounding=ROUND_HALF_UP)
y = Decimal(str(r[1])).quantize(Decimal('0.01'),rounding=ROUND_HALF_UP)

z = x * y

z = math.floor(z)

print(z)

Submission status: Accepted

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

a = int(A)
b = round(B * 100)

print(a * b // 100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = input().split()
s1 = a[0]
s2 = a[1]
num1 = int(s1)
num2 = int(s2[0])*100 + int(s2[2]+s2[3])

print((num1*num2)//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np
from decimal import *
input = input().split(" ")
a, b = Decimal(input[0]), Decimal(input[1])
print(np.floor(a*b))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
 
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
 
a, b = input().split()
a = int(a)
b = int(float(b)*1000)
ans = a * b
print(ans // 1000)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# Template 1.0
import sys, re
from decimal import *
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, floor, trunc
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

i = Decimal(a)*Decimal(b)

print(int(i))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_FLOOR

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

ans = a * b

val_floor_d = ans.quantize(Decimal('0'), rounding=ROUND_FLOOR)

print(val_floor_d)

Submission status: Accepted

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

tmpA = int(A)
tmpB = int(float(B)*100.0+0.5)

ans = str(tmpA*tmpB)

ans=ans[:len(ans)-2]

if len(ans)==0:
    ans=0

print(ans)

Submission status: Accepted

Solution code:
import decimal

a, b = input().split()

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

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

a,b=input().split()

b=float(b)*100

b=Decimal(str(b)).quantize(Decimal('0'), rounding=ROUND_HALF_UP)


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

Submission status: Accepted

Solution code:
a, b = input().split()
A = int(a)
B = float(b)
B100 = round(100*B)
 
C=A*B100
print(str(C//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:
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *

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

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

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

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

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

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

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

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

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

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

inf = float('inf')
mod = 1000000007

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

def main():
	getcontext().prec = 100
	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:
a, b = input().split()
A = int(a)
B = float(b)
B100 = round(100*B)

C=A*B100
print(str(C//100))

Submission status: Accepted

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

Submission status: Accepted

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

import sys
import math
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

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

ans = int(A) * int(B * 1000000) // 1000000

print(int(ans))

Submission status: Accepted

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