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: Wrong Answer

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 = 18
	A,B  = map(float, input().split())

	numA = Decimal(A)
	numB = Decimal(B)
	ans = Decimal(numA*numB)

	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: Wrong Answer

Solution code:
import sys
import math

sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline

A, B = map(float, input().split())
A = int(A)
B_f, B_i = math.modf(B)

B_i = int(B)
B_f = math.floor(B_f * 10 ** 2) / (10 ** 2)

seisu = A * B_i
syousuu = A * B_f

print(int(seisu + syousuu))
# A = int(A)
# print(int(A * B))

Submission status: Wrong Answer

Solution code:
a,b=(float(x) for x in input().split())
ans = a*b
print(int(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
n=input().split()
a=float(n[0])
b=float(n[1])
ans=a*b
print(int(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
list = input().split(" ")
x = int(list[0]) * float(list[1])
print(int(x))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:

# -*- coding: utf-8 -*-
import sys

l = list(map(lambda x: float(x), str(input()).split(" ")))
print(int(l[0] * l[1]))

Submission status: Wrong Answer

Solution code:
import math
li = input().split()
a=int(li[0])
b=float(li[1])
c=int(b*100)
d=a*c
e=d//100
f=int(e)
print(f)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

print(int(a * b / 100))

Submission status: Wrong Answer

Solution code:
import numpy as np

nums = list(map(float, input().split()))
nums = np.array(nums, dtype=np.float128)
ans = np.array([nums[0]*nums[1]], dtype=np.uint64)
print(ans[0])

Submission status: Wrong Answer

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

print(int(int(a)*float(b)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from math import floor
A = [ float(num) for num in list(input().split())]
print(floor(A[0]*A[1]))

Submission status: Wrong Answer

Solution code:
import bisect
import sys



n, m = map(float, input().split())


ans = n*m
print(int(ans))

Submission status: Wrong Answer

Solution code:
x = input().split()
a = int(x[0])
b = float(x[1])
print(int(a * b))

Submission status: Wrong Answer

Solution code:
import math
a = input().split()
c = float(a[0])*float(a[1])
print(str(math.floor(c)))

Submission status: Wrong Answer

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

ans = A * B
print(math.floor(ans))

Submission status: Wrong Answer

Solution code:

A, B = map(eval, input().split())
print(str(B))
B = (str(B)[:4])
B = float(B)
print(int(A*B))

Submission status: Wrong Answer

Solution code:
import math

A,B=map(str,input().split())
a=int(A)
b=float(B)*100
#print(int(B))

bb=int(b)

print(math.floor(a*bb//100))

Submission status: Wrong Answer

Solution code:
import math as m
def main():
    A, B = input().split(' ')
    print(m.floor(float(A)*float(B)))

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
from math import floor, ceil


def main():

    A, B = map(float, input().split())
    B = round(B, 2)
    A = int(A)
    if A == 0 or B == 0.0:
        print(0)
        return
    AB = A*B
    AB = floor(AB)
    print(AB)


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math
a,b=list(input().split())
o=int(a)
t=float(b)
print(int(o*t))

Submission status: Wrong Answer

Solution code:
# n = int(input())
# m = float(input())
n , m = input().split()
a = int(n)
b = float(m)
op = (a*b)
po = int(op)
print(po)

Submission status: Wrong Answer

Solution code:
A, B = map(float, input().split())
mod = 10000
a = int(A // mod)
a2 = int(A % mod)
B = int(100 * B)
ans = a * B * mod + a2 * B 
print(ans // 100)

Submission status: Wrong Answer

Solution code:
x, y = [float(x) for x in input().split()]
ans = int(x*y)
print(ans)

Submission status: Wrong Answer

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

print(int(a*b))

Submission status: Wrong Answer

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 = 17
	A,B  = map(float, input().split())

	numA = Decimal(A)
	numB = Decimal(B)
	ans = Decimal(numA*numB)

	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: Wrong Answer

Solution code:
import math
 
a_0, b_0 = input().split()
a = int(a_0)


ans = a*int(b_0[0:-3]) +a*int(b_0[-2:])/100//1
print(int(ans))

Submission status: Wrong Answer

Solution code:
import numpy as np
import scipy as sp
import math

x, y = input().split()
a = int(x)
b = float(y)
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
nums = input().split()
a = int(nums[0])
b = int(float(nums[1])*100)
ans = str(a * b)
if len(ans) <= 2:
    print(0)
else:
    print(ans[:-2])

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
A, B = input().strip().split(" ")
A = int(A)
BZ, d1, d2 = int(B[0]), int(B[2]), int(B[3])
result = 0
result += A * BZ

AZ = int(A / 10)
Ad = A - AZ * 10
result += AZ * d1 + int(Ad * d1 / 10)

AZ = int(A / 100)
Ad = A - AZ * 100
result += AZ * d2 + int(Ad * d2 / 100)

# result = A * BZ + int((A * d1) / 10) + int((A * d2) / 100)
# print(A*BZ, int(str(A * d1)[:-1]), int(str(A * d2)[:-1]))
print(result)

Submission status: Wrong Answer

Solution code:
A, B = map(float, input().split())
A = int(A)
B = int(B * 100)
if A * B < 100:
    print(0)
else:
    print(str(A * B)[:-2])

Submission status: Wrong Answer

Solution code:
import sys
import numpy as np
import math
from collections import deque 
from functools import reduce

# input = sys.stdin.readline
a, b = map(float, input().split())

ab = np.array([float(a), float(b)*100])

print(int(ab[0]*ab[1]/100))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:

a,b = input().split()
a = float(a)
b = float(b)
new = int(a*b)

print(new)

Submission status: Wrong Answer

Solution code:
from math import trunc
things = list(input().split())
a = int(things[0])
b = float(things[1])
c = int(b*100)
answ = list(str(a*c))
answ.insert(-2, ".")
final = ""
for x in answ:
	if x != ".":
		final += x
	else:
		break
print(0) if final == "" else print(final)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

print(round(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# coding: utf-8
# Your code here!
import math

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

print(math.floor(a * b))

Submission status: Wrong Answer

Solution code:
import decimal
decimal.getcontext().prec = 3
S = input().split()
A = int(S[0])
B = float(S[1])

B = decimal.Decimal(B)

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

Submission status: Wrong Answer

Solution code:
from decimal import *

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

a, b = map(float, input().split())
print(Decimal(a) * Decimal(b) // 1)

Submission status: Wrong Answer

Solution code:
from math import trunc

List = input().split()

print(trunc(int(List[0]) * float(List[1])))

Submission status: Wrong Answer

Solution code:
import sys, math
input = sys.stdin.readline

def main():
    inpt = input()
    A = int(inpt.split()[0])
    B = float(inpt.split()[1])

    B = int(B * 100)

    print(math.floor((B * A)//100))

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math
A, B = input().split()
a = int(A)
b = B.replace('.', '')
Adam = int(b)
Eve = a * Adam
if B[-3] == '.':
    Zeus = math.floor(Eve / 100)
elif B[-2] == '.':
    Zeus = math.floor(Eve / 10)
else:
    Zeus = Eve
print(Zeus)

Submission status: Wrong Answer

Solution code:
import math

A,B=map(float, input().split())
A=int(A)
B=int(B*100)
print(int(math.floor(A*B/100)))

Submission status: Wrong Answer

Solution code:
import math
a,b=map(float,input().split())
a=int(a)
sum = int(math.trunc(a*b))
print(sum)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
A,B = map(float, input().split())
k=math.floor(A*B)
print(k)

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().split())
r = int(a*b)
print("{0:.0f}".format(r))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right
# from math import gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint

INF = float("inf")

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def mycount(ls,x):
    # lsはソート済みであること
    l = bisect_left(ls,x)
    r = bisect_right(ls,x)
    return (r-l)

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

def I():
    return int(input())

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

def RI():
    return list(map(int,input().split()))

def CI(n):
    return [ int(input()) for _ in range(n) ]

def LI(n):
    return [ list(map(int,input().split())) for _ in range(n) ]

def S():
    return input()

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

def RS():
    return list(input().split())

def CS(n):
    return [ input() for _ in range(n) ]

def LS(n):
    return [ list(input().split()) for _ in range(n) ]

a,b = MS()

a = int(a)
# print(a)
b = int( float(b)*100 )
# print(b)

c = a * b
# print(c)

ans = c//100
print(ans)

Submission status: Wrong Answer

Solution code:
s = input().split()
print(int(int(s[0]) * float(s[1])))

Submission status: Wrong Answer

Solution code:
from sys import stdin

def main():
  P = stdin.readline().rstrip().split()
  a = int(P[0])
  b = float(P[1])
  c = a*b
  print(int(c))
  return

main()

Submission status: Wrong Answer

Solution code:
list = input().split(" ")
a = float(list[0])
b = float(list[1])
c = int(a * b)
print(c)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a,b=[float(i) for i in input().split()]
print(math.floor((a*b)))

Submission status: Wrong Answer

Solution code:
import math
A,B=map(float, input().split())
ANS=math.floor(A*B)
print(ANS)

Submission status: Wrong Answer

Solution code:
def readInt():
    return list(map(float, input().split()))

a,b = readInt()
a = int(a)
count = 0
ans = 0
# print(a)
while a > 0:
    c = a % 10
    a = a // 10
    ans += int(c * (10**count) * b)
    count += 1
    # print(a,c)
print(int(ans))

Submission status: Wrong Answer

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

ans = int(int(A) * float(B))
print(ans)

Submission status: Wrong Answer

Solution code:
from math import factorial as fact
import math
import sys
import itertools
import numpy as np
from collections import Counter
import datetime
from collections import deque


#入力:N(int:整数)
def input1():
	return int(input())

#入力:N,M(int:整数)
def input2():
	return map(float,input().split())

#入力:[n1,n2,...nk](int:整数配列)
def input_array():
	return list(map(int,input().split()))

def keta(N):
	return len(str(N))


def input_daytime(input_time):
	time,distance=input_time.split()
	t=time.split(":")
	se=str(t[-1]).split(".")
	dt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))
	return dt1

def combinations(n,r):
	return list(itertools.combinations(range(n),r))



def all_sets(num_list):
	subsets=[]
	for i in range(2,len(num_list) + 1):
		for c in combinations(num_list, i):
			subsets.append(c) 
	return subsets

#公約数の列挙
def ch(x1):
	cf=[]
	for i in range(2,math.sqrt(x1)+1):
		if x1 % i==0:
			cf.append(i)
	return cf

def CountOneRoots(x,y):
	#x:縦，y:横
	return fact(x+y)/fact(x)/fact(y)

# 素因数分解
def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a
	
def count_str(m):
	tmp={}
	for i in range(10):
		if i in tmp:
			tmp[i]=1
		else:
			tmp[i]+=1
	return tmp

def is_prime(n):
	if n==1: return True

	for i in range(2,int(math.sqrt(n))+1):
		if n%i==0:
			return False
	return True


I=input().split()
a=float(I[0])
b=math.floor(float(I[1])*100)/100
print(math.floor(a*b))

Submission status: Wrong Answer

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

B_int = int(round(B*100))

print(int(A*B_int/100))

Submission status: Wrong Answer

Solution code:
list = []
a,b=input().split()
list.append((int(a), float(b)))

ans = int(list[0][0] * list[0][1])

print(ans)

Submission status: Wrong Answer

Solution code:
import math
from decimal import *
getcontext().prec=1
a,b=(input().split())
a=float(a)
b=float(b)
a=str(a)
b=str(b)
c=Decimal(a)*Decimal(b)
print(c)

Submission status: Wrong Answer

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

print(round(A * B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
A, B = input().split()
A = int(A)
B = float(B)
if A == 0 or B == float(0):
    print(0)
elif A == 1:
    print(int(B))
elif A // 100 == 1:
    A /= 100
    B *= 100
    print(int(A*B))
else:
    print(int(A*B))

Submission status: Wrong Answer

Solution code:
import math
A,B=list(map(float,input().split()))
A=int(A)
Bfloat, Bint = math.modf(B)
Bfloat=int(Bfloat*100)

ABfloat=int(A*Bfloat)
strABfloat=str(ABfloat)
lenABfloat=len(strABfloat)
#print(strABfloat)
temp=0
if lenABfloat>=3:
  for i in range(lenABfloat-2):
    temp+=int(strABfloat[i])*10**(lenABfloat-i-3)  
print(A*Bint+temp)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
import math

inputs = input().split(' ')
a,b = int(inputs[0]), float(inputs[1])
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
import math

a,b = map(float, input().split())
a = int(a)
b = int(b*(10**15))
print(b)
ans = a*b
ans = math.floor(ans)/(10**15)
ans = round(ans)
print(ans)

Submission status: Wrong Answer

Solution code:
import math
a, b = input().split()
a = int(a)
b = float(b)
c = a * b
print(math.trunc(c))

Submission status: Wrong Answer

Solution code:
import math

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

n = a*b
n = n//100

print(int(n))

Submission status: Wrong Answer

Solution code:
sakoda,andy=input().split()
x=int(sakoda)
y=int(float(andy)*100)
z=int(x*y)
print(x*y//100)

Submission status: Wrong Answer

Solution code:
c=list(input().split())

m1=int(c[0])
m2=list(str(c[1]).split('.'))
tot1=m1*int(m2[0])

tot2=m1*float(m2[1])/100

w=tot1+int(tot2)
print(w)

Submission status: Wrong Answer

Solution code:
A,B = map(float,input().split( ))
ans = A*B
if abs(round(ans) - ans) <= 1e-4:
    print(int(round(ans)))
else:
    print(int(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a,b = input().split()
if (float(a)<10**15 and float(b)<10):
    c = float(a)*float(b)
    d = str(c).split(".")[0]
    print(int(d))

Submission status: Wrong Answer

Solution code:
A, B = list(map(float, input().split()))
import math
print(math.floor(A * B))

Submission status: Wrong Answer

Solution code:
import math

(A,B) = input().split()
A = int(A)
B = float(B)
print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
a,b = input().strip().split()
a,b = [int(a), float(b)]
c = a*(b*100.0);
d = int(c/100)
print(d)

Submission status: Wrong Answer

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

print(A * B // 100)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a, b = map(str, input().split())
aa = int(a)
bb = int(float(b) * 100)
print(int((aa*bb//100)))

Submission status: Wrong Answer

Solution code:
a,b = map(str,input().split())
c,d = map(str,b.split('.'))
ans = int(a)*int(c)
tmp = int(str(int(a)*int(d))[:len(d)])*10**(len(a)-len(d)-1)
if tmp < 1:
    print(ans)
else:
    print(ans+tmp)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a,b=(float(x) for x in input().split())
print(a)
print(b)
ans = a*b
print(int(ans))

Submission status: Wrong Answer

Solution code:
a=input().split()
A=int(a[0])
B=float(a[1])
B_int=int(B)
B_float=int(B*100-int(B)*100)
#print(B_float)

ans=A*B_int+(A*B_float)//100
#print(A*B_int,(A*B_float)//100)
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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


A  = int(A)

B = float(B) * 100

print(int(A * B / 100))

Submission status: Wrong Answer

Solution code:
from decimal import Decimal
import math

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

A = int(aaa[0])
A = Decimal(A)
B = Decimal(aaa[1])

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

Submission status: Wrong Answer

Solution code:
#coding:utf-8

V = [int(float(i) * 100) for i in input().split()]

C = V[0] * V[1]

C = C / 10000

C = int(C)

print("{}".format(C))

Submission status: Wrong Answer

Solution code:
import math

A, B = map(str, input().split(' '))
A = int(A)
B = float(B)

print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
# coding: utf-8
input_length = input().split()

second_num = input_length[1].replace(".","")

print(int(int(input_length[0])*int(second_num)/100))