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

Submission status: Wrong Answer

Solution code:
import math
input_nums = input().split()

output = 1


for num in input_nums:
    output *= float(num)   

print(math.floor(output))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from sys import stdin
from decimal import *


def floor(a,b):
    return a//b


def main():
    _in = [_.rstrip() for _ in stdin.readlines()]
    A, B = list(map(float, _in[0].split(' ')))  # type:list(int)
    # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
    A = Decimal(A)
    B = Decimal(B)
    cnt = A * B
    cnt = int(floor(cnt, 1))
    # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    print(cnt)


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import math

li = input().split()
n = int(li[0])
m = float(li[1])

print(math.floor(n*m))

Submission status: Wrong Answer

Solution code:
import math

digit = 3
digit10 = 10**(digit-1
)
a,b = map(float, input().split())
a = int(a)
b = math.floor(b*digit10)/digit10
result = a*b
print(math.floor(result))

Submission status: Wrong Answer

Solution code:
a,b=input().split()
a=int(a)
l=len(b)
b=int(float(b)*10**(l-2))//1
print(a*b//10**(l-2))

Submission status: Wrong Answer

Solution code:
import math

if __name__ == "__main__":

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

    print(math.floor(a*b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

input_list = input().split()
A = int(input_list[0])
B = float(input_list[1])
final_B = math.floor(B * 10 ** 2)

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import numpy as np
a, b = map(float, input().split())
A = np.array([a,b])
print(int(np.prod(A)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
#import time
import copy
#from collections import deque, Counter, defaultdict
#from fractions import gcd
#import bisect
import math
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**20
ri = lambda : int(input())
rs = lambda : input().strip()
rl = lambda : list(map(float, input().split()))
a,b = rl()

a_small=a%100
a_big =(a-a_small)
b_big =int(b)
b_small = b-b_big


print(int(a_big*b_big)  +int(a_small*b_big) +
      int(a_small*b_small) + (int(a_big/100)*int(b_small*100)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys


def _sa(): return sys.stdin.readline().strip().split()


def main():
    a, b = _sa()
    ab = int(a) * int(100.0 * float(b))
    return ab // 100


if __name__ == "__main__":
    print(main())

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

print(math.trunc(a*b))

Submission status: Wrong Answer

Solution code:
import math

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

c = a * b

print(math.floor(c))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
import math
readline = sys.stdin.readline
 
l = readline().split()
 
A = int(l[0])
B = float(l[1])
 
ans = A*B
print(math.floor(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
A, B = [x for x in input().split()]

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

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
A, B = map(float,input().split())
A = int(A)
ans = 0
A_H = A//100
for i in range(int(B*100)):
    ans += A_H
ans += int(A%100 * B)
print(int(ans))

Submission status: Wrong Answer

Solution code:
import math
N,K=input().split()
N=eval(N)
'''after=K.split(".")[1]
before=K.split(".")[0]
after=after[0:2]
K=eval(before+"."+after)
'''
K=eval(K)
K=round(K,2)
if K<10:
#print(before, after, K)
    print(int(math.trunc(N*K)))

Submission status: Wrong Answer

Solution code:
import sys
# from random import choice,randint
# from bisect import bisect_left as bl             
# from bisect import bisect_right as br  
# from collections import deque,defaultdict,Counter
from math import sqrt,floor,ceil
# from itertools import combinations,permutations
# from heapq import heapify,heappop,heappush,heappushpop
# inp=sys.stdin.readline
# out=sys.stdout.write
# flsh=sys.stdout.flush
# ranomd string generator --> a = ''.join(random.choices(string.ascii_lowercase, k = 1000))
 
sys.setrecursionlimit(10**9)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod1=998244353
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)]

#fact=[1]
#for i in range(1,100001):
#    fact.append((fact[-1]*i)%mod)
#ifact=[0]*100001
#ifact[100000]=pow(fact[100000],mod-2,mod)
#for i in range(100000,0,-1):
#    ifact[i-1]=(i*ifact[i])%mod
 
def MI(): return map(int, inp().strip().split())
def LI(): return list(map(int, inp().strip().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]
def LI_(): return [int(x)-1 for x in inp().strip().split()] #use list comprehension for loops
def LF(): return [float(x) for x in inp().strip().split()] #use try and except for dictionaries
def LS(): return inp().strip().split() #declare local variables ... for functions assing them to variables
def I(): return int(inp().strip()) # before using example ... func = len for using len() funtcion
def F(): return float(inp().strip()) #sort dictionary after zipping
def S(): return inp().strip() #use map function for mapping list to a fuction
def pf(s): return out(s+'\n')
def JA(a, sep): return sep.join(map(str, a)) #use this for string concatenation
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def modinv(n,p):return pow(n,p-2,p)
def ncr(n,r,p):                      
    t=((fact[n])*((ifact[r]*ifact[n-r])%p))%p
    return t

####################Actualcode################################
def solve():
    a,b=LF()
    a = int(a)
    b = b*(1000.0000000000000)
    ans = a*b
    ans = ans//1000
    print(int(ans))

def main():
    solve()


######## Python 2 and 3 footer by Pajenegod and c1729
py2 = round(0.5)
if py2:
    from future_builtins import ascii, filter, hex, map, oct, zip
    range = xrange

import os, sys
from io import IOBase, BytesIO

BUFSIZE = 8192
class FastIO(BytesIO):
    newlines = 0
    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.writable = "x" in file.mode or "w" in file.mode
        self.write = super(FastIO, self).write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
        return s
    def read(self):
        while self._fill(): pass
        return super(FastIO,self).read()

    def readline(self):
        while self.newlines == 0:
            s = self._fill(); self.newlines = s.count(b"\n") + (not s)
        self.newlines -= 1
        return super(FastIO, self).readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.getvalue())
            self.truncate(0), self.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        if py2:
            self.write = self.buffer.write
            self.read = self.buffer.read
            self.readline = self.buffer.readline
        else:
            self.write = lambda s:self.buffer.write(s.encode('ascii'))
            self.read = lambda:self.buffer.read().decode('ascii')
            self.readline = lambda:self.buffer.readline().decode('ascii')

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

inp = lambda: sys.stdin.readline().rstrip('\r\n')
out = lambda x: sys.stdout.write(x)
flsh= lambda: sys.stdout.flush()

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:

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

ans = A * B

ans =int(ans)
print(str(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:
A,B = list(map(float,input().split(" ")))

if A*B < 1:
  print(0)
else:
  print(int(A*B))

Submission status: Wrong Answer

Solution code:
import math
import itertools
import functools
import numpy as np



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

a = int(a)
s, t = map(int, b.split("."))

s = a * s
t =( a * t) / 100


print(int(s  + t))

Submission status: Wrong Answer

Solution code:
A, B = [s for s in input().split()]
A = int(A)
B = int(float(B) * 100)

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

Submission status: Wrong Answer

Solution code:
import math
if __name__ == "__main__":
    a, b = input().split()

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

    print((a * b) // 100)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
import re

a = input()
b = int(re.sub('\s.+$','',a))
c = float(re.sub('^.+\s','',a))
d = float(b * c)

d = math.floor(d)
d = int(d)
print (d)

Submission status: Wrong Answer

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

a = int(x[0])
b = float(x[1]) * 10000000
b = int(b)

print(a * b // 10000000)

Submission status: Wrong Answer

Solution code:
import numpy as np
a = list(map(float,input().split()))
print(int(a[0]*a[1]))

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:
def main():
    a, b = input().split()
    a = int(a)
    b = float(b)
    ans = int(a * b)
    print(ans)



if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
print(str(a * b).split('.')[0])

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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 * 100) // 100

print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
from fractions import Fraction

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

A=int(A)
B=int(B*100)
multi=A*B
multi=Fraction(multi,100)

print(int(multi))

Submission status: Wrong Answer

Solution code:
# coding: utf-8
a, b = input().split()
aa = int(a)
bb = float(b)
ans = str(aa * bb)
ten = ans.find(".")
# print(ten)
print(ans[:ten])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
a = int(a)
b = b * 100
b = int(b)
ans = str(a * b)
if ans[: len(ans) - 2] == '':
    print(int(ans) // 100)
else:
    print(ans[: len(ans) - 2])

Submission status: Wrong Answer

Solution code:
l=input().split()
a=l[0]
aa='0'*(15-len(a))+a
al=int(aa[0:7])
ar=int(aa[7:])
b=int(float(l[1])*100)
ans=ar*b
ans+=al*b*(10**9)
print(ans//100)

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:

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

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
b = round(b, 2)
c = (a*b)%1
sum = a*b
sum = sum - c
print(int(sum))

Submission status: Wrong Answer

Solution code:
import math

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

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

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

	s = str(ans)
	#print(s)
	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
import sys
sys.setrecursionlimit(10**9)

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

if __name__ == "__main__":
  main()

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

A = int(A)
B = float(B)

A_keta = len(str(A)) - 1

A_tmp = A / (10 ** A_keta)

res = (A_tmp * B) * (10 ** A_keta)

print(math.floor(res))

Submission status: Wrong Answer

Solution code:
import math
A, B = map(float, input().split())
A = int(A)
B_i = int(B)
B_f = B - B_i
ans = A * B
print(A*B_i + math.floor(A*B_f))

Submission status: Wrong Answer

Solution code:
import math

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

A = int(A)
B = int(B.replace(".", ""))

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

Submission status: Wrong Answer

Solution code:
import math

A, B = list(input().split())
A = int(A)
B = '{:.2f}'.format(float(B)).replace('.', '')
B = int(B)

# A *= 100
# B = int(B * 100)


AB = A * B / 100
floored = int(math.floor(AB))
print(floored)

# AB = A * B
# AB = str(AB)
# AB = AB[0:-2]
# AB = 0 if AB == '' else AB
# print(AB)

Submission status: Wrong Answer

Solution code:
s = input()

i = s.find(" ")

a = int(s[:i])
b = float(s[i+1:])

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

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(seisu + int(syousuu))
# A = int(A)
# print(int(A * B))

Submission status: Wrong Answer

Solution code:
from decimal import Decimal, getcontext

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

Submission status: Wrong Answer

Solution code:
from decimal import Decimal

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

print('{:.0f}'.format(c))

Submission status: Wrong Answer

Solution code:
import math
A = input().split()
a = float(A[0])
b = float(A[1])

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

Submission status: Wrong Answer

Solution code:
m,n = map(eval,input().split())
print(int(m*n))

Submission status: Wrong Answer

Solution code:
import math
list = input().split()
a=int(int(list[0])//100000)
b=int(float(list[1])//1)
c= float(list[1])%1
ans = a*b+int(a*c)
print(math.floor(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

a, b = map(float,input().split())
sub = a - int(a)
n = int(int(b) * sub)
m = int(a) * int(b)

print(n + m)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
def main():
    a,b = input().split()
    a = int(a)
    b_n = b[0]
    b_ = b[2:]
    print(int(str(a*int(b_n)+a*int(b_)/100).split('.')[0]))


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

A, B = [Decimal(x) for x in stdin.readline().rstrip().split()]

print(math.floor(float(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 = 50
	A,B  = map(float, input().split())

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

	s = str(ans)
	#print(s)
	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 numpy as np
a = list(map(float,input().split()))
print(int(a[0])*int(a[1]))

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().split())
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
b = Decimal(str(b)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
print(b)
a = Decimal(a)
ans = a*b
print(math.floor(ans))

Submission status: Wrong Answer

Solution code:
from sys import stdin

a, b = map(float, stdin.readline().split())
mul = a*b
print(int(mul))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
from io import StringIO
import unittest

import math
from decimal import Decimal, getcontext

getcontext().prec = 99


def resolve():
    A, B = input().split()

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


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """198 1.10"""
        output = """217"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """1 0.01"""
        output = """0"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """1000000000000000 9.99"""
        output = """9990000000000000"""
        self.assertIO(input, output)


if __name__ == "__main__":
    unittest.main()

Submission status: Wrong Answer

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