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():
	s  = inputStr()
	s = s.split()

	ans = int(int(s[0])*float(s[1]))

	print(ans)



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

Submission status: Wrong Answer

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

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

print((A * B) // 10000)

Submission status: Wrong Answer

Solution code:
import math

a,b = list(map(float, input().split()))
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
import math
import collections
import fractions
import itertools

def iput(): return int(input())
def mput(): return map(int, input().split())
def lput(): return list(map(int, input().split()))

def solve():
    a, b = input().split()
    a = int(a)
    b = float(b)
    print(math.floor(a*b))
    return 0

if __name__ == "__main__":
    solve()

Submission status: Wrong Answer

Solution code:
from sys import stdin
A,B = [float(x) for x in stdin.readline().rstrip().split()]
print(int(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
a,b = list(map(float,input().split()))

from decimal import Decimal
a = Decimal(a)
b = Decimal(b)
print(int(a*b))

Submission status: Wrong Answer

Solution code:
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
#======================================================#
def main():
    a, b = IS().split()
    a = int(a)
    b = float(b)
    print(int(a*b))

if __name__ == '__main__':
    main()

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 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=LF()
  return math.floor(a*b)

# main()
print(main())

Submission status: Wrong Answer

Solution code:

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

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

c=int(a*b)

print(c)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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



if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(10000000)
input=sys.stdin.readline

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

print(int(n*k))

Submission status: Wrong Answer

Solution code:
A, B = [eval(v) for v in input().strip().split(" ")]

print(int(A * B))

Submission status: Wrong Answer

Solution code:
A_B = list(map(float, input().split(" ")))

print(int(A_B[0] * A_B[1]))

Submission status: Wrong Answer

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

C()

Submission status: Wrong Answer

Solution code:
I = input().split()
A = int(I[0])
B = float(I[1])
B = int(B*100)
print( A*B//100 )

Submission status: Wrong Answer

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

from math import floor

print(floor(A * B))

Submission status: Wrong Answer

Solution code:
i,j=map(float,input().split())
k=int(i*j)
print(k)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math


def main():
    a, b = [float(e) for e in input().split()]

    print(math.floor(a * b))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
line= input().split(' ')
a= line[0]
b= line[1]

tot= int(a)*float(b)

tot= tot- tot%1
print(int(tot))

Submission status: Wrong Answer

Solution code:
def mp(): return map(int, input().split())
def lmp(): return list(map(int, input().split()))


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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
# from collections import defaultdict
# from collections import Counter
# from queue import Queue

def main():
    # N = int(input())

    N, M = [float(s) for s in input().split()]
    print(int(N * M))

    # As = []
    # for i in range(N):
    #     tmp = int(input())
    #     As.append(tmp)

    return 0

if __name__ == '__main__':
    sys.exit(main())

Submission status: Wrong Answer

Solution code:

a, b = list(map(float, input().split()))
print(int(a*b))

Submission status: Wrong Answer

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


print(int(a*b))

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-


def main():
    a_s, b_s = input().split()
    a, b = int(a_s), float(b_s)

    print(int(a * b))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
	return list(map(int,input().split()))
def m(): #複数文字
	return map(float,input().split())
def onem(): #Nとかの取得
	return int(input())
def s(x): #圧縮
	a = []
	if len(x) == 0:
		return []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa != x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x): #listをスペースごとに分ける
	return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
	return max(map(max,x))
def In(x,a): #aがリスト(sorted)
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
	ll = 0
	rr = r
	while True:
		mid = (ll+rr)//2

	if rr == mid:
		return ll
	if (ここに評価入れる):
		rr = mid
	else:
		ll = mid+1
"""

a,b = m()


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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

result = A * B

print(int(result))

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
from sys import stdin, setrecursionlimit
from math import floor


def main():
    input = stdin.buffer.readline
    a, b = map(float, input().split())
    print(floor(a * b))


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

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:

a, b = map(float, input().split())
import math
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
l = [float(x) for x in input().split()]
print(int(l[0]*l[1]))

Submission status: Wrong Answer

Solution code:
A_in, B_in = map(str, input().split())
A = int(A_in)
B = float(B_in)

print(int(A*B))

Submission status: Wrong Answer

Solution code:
A,B=input().split()
A=float(A)
B=float(B)
a=A*B
s=str(a)
ans=""
for i in range(len(s)):
    if s[i]==".":
        break
    ans=ans+s[i]

print(int(ans))

Submission status: Wrong Answer

Solution code:
import math
x = list(map(float, input().split()))
a = x[0]*x[1]
print(math.floor(a))

Submission status: Wrong Answer

Solution code:


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

print(int(A*B))

Submission status: Wrong Answer

Solution code:
import sys
def FI(): return list(map(float,sys.stdin.readline().rstrip().split()))
A,B = FI()
print(int(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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


def readstr():
    return input().strip()


def readint():
    return int(input())


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


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


def main():
    A, B = readstrs()
    A = int(A)
    B = float(B)
    print(int(A * B))


if __name__ == "__main__":
    main()

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

Submission status: Wrong Answer

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

import math

print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
from math import *
from sys import stdin,stdout
input=stdin.buffer.readline

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

Submission status: Wrong Answer

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

A = int(A)
B = list(B)

B.remove(".")

B = [int(b) for b in B]

ans = A * B[0] + A * B[1] // 10 + A * B[2] // 100

print(ans)

Submission status: Wrong Answer

Solution code:
from sys import stdin, stdout
from math import floor
a, b = map(float, input().split())

print(floor(a*b))

Submission status: Wrong Answer

Solution code:
from sys import stdin
def LF(): return list(map(float,stdin.readline().rstrip().split()))

tmp = LF()

print(int(tmp[0]*tmp[1]))

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
import math
a, b = map(float, input().split())
q = a*b
print(math.trunc(q))

Submission status: Wrong Answer

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

A = int(A)
B = float(B)
Bi = int(B)
bb = B-int(B)

print(int(A*bb)+A*Bi)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
S=lambda:input()
I=lambda:int(input())
L=lambda:list(map(float,input().split()))
LS=lambda:list(map(str,input().split()))
 
def main():
    a,b=L()
    import math
    print(math.floor((a*b)//1))
 
if __name__ == '__main__':
    main()

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:
import math as m
a,b =map(float, input().split())
print(m.floor(a * b))

Submission status: Wrong Answer

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

print(int(A*B+0.0001))

Submission status: Wrong Answer

Solution code:

import math

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

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

Submission status: Wrong Answer

Solution code:
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)

a,b = map(float,ipt().split())
b1 = int(b)
b2 = b-b1
print(int(a*b1+int(a*b2)))

Submission status: Wrong Answer

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

ans = A * B

print(int(ans // 1))

Submission status: Wrong Answer

Solution code:
from math import floor
a,s=input().split()
a=int(a)
k=s
s=float(s)
S=floor(s)
m=s-S
print(S*a+int(100*m)*a//100)

Submission status: Wrong Answer

Solution code:
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy

# If you use recursive call, uncomment this code
#sys.setrecursionlimit(10**6)

def main():
    N,M = input().split()
    N = int(N)
    M = float(M)
    print(int(N*M))

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations, combinations_with_replacement
from heapq import heappop, heappush
from fractions import gcd
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    s = list(input().split())
    a = int(s[0])
    b = float(s[1])
    b *= 100
    print(int(a*b//100))
    
if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

print(math.floor(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:

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

ab = a*b
#print(ab)
ac = int(ab)
print(ac)

Submission status: Wrong Answer

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

print(int(a * b))

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(200000)


def read():
    A, B = input().strip().split()
    return int(A), float(B)


def solve(A, B):
    b = int(B * 100)
    return A * b // 100


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

Submission status: Wrong Answer

Solution code:
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))
def getArray(intn):
    return [int(input()) for i in range(intn)]
def input():
    return sys.stdin.readline().rstrip()

from collections import defaultdict, deque, Counter
from sys import exit
import heapq
import math
import copy
from bisect import bisect_left, bisect_right

import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7

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

Submission status: Wrong Answer

Solution code:
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
#import sympy as syp(素因数分解とか)
Mod = 1000000007
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  #startline-------------------------------------------
    a, b = map(float,input().split())
    print(int(a*b))
if __name__ == "__main__":
    main() #endline===============================================

Submission status: Wrong Answer

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

###
# main
if(__name__ == '__main__'):
    # input
    a_in, b_in = input().split(" ")
    a = int(a_in)
    b = float(b_in)

    ans = int(a*b)

    print(ans)

# else:
    # do nothing

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# 初期入力
import sys
input = sys.stdin.readline
A,B = (float(x) for x in input().split())
ans =int(A *B)
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:

S = input().strip().split()
A = int(S[0])
B = float(S[1])
m = str(A * B)
print(m.split(".")[0])

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

q3()

Submission status: Wrong Answer

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

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:
def resolve():
    N, M = [float(i) for i in input().split()]
    print(int(N * M))


resolve()

Submission status: Wrong Answer

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

mul = A * B
C = int(mul)
print(C)

Submission status: Wrong Answer

Solution code:
#!/usr/bin python3
# -*- coding: utf-8 -*-

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
# vim: set fileencoding=utf-8

# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation


"""Module docstring
"""

import functools
import heapq
import itertools
import logging
import math
import os
import random
import string
import sys
from argparse import ArgumentParser
from collections import defaultdict, deque
from copy import deepcopy
from io import BytesIO, IOBase
from typing import Dict, List, Optional, Set, Tuple


def solve(values: List[int], nb: int) -> int:
    for _v in values:
        pass
    return nb


def do_job(stdin, stdout):
    "Do the work"
    LOG.debug("Start working")
    # first line is number of test cases
    a, b = stdin.readline().split()
    # values = []
    # for _ in range(N):
    #     values.append(stdin.readline().split())
    result = int(int(a) * float(b))
    print(result, file=stdout)


def print_output(testcase: int, result, stdout) -> None:
    "Formats and print result"
    if result is None:
        result = "IMPOSSIBLE"
    print("Case #{}: {}".format(testcase + 1, result), file=stdout)
    # 6 digits float precision {:.6f} (6 is the default value)
    # print("Case #{}: {:f}".format(testcase + 1, result), file=stdout)


BUFSIZE = 8192


class FastIO(IOBase):
    # pylint: disable=super-init-not-called, expression-not-assigned
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

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


class IOWrapper(IOBase):
    # pylint: disable=super-init-not-called
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        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")


def configure_log() -> None:
    "Configure the log output"
    log_formatter = logging.Formatter("L%(lineno)d - " "%(message)s")
    handler = logging.StreamHandler(IOWrapper(sys.stderr))
    handler.setFormatter(log_formatter)
    LOG.addHandler(handler)


LOG = None
# for interactive call: do not add multiple times the handler
if not LOG:
    LOG = logging.getLogger("template")
    configure_log()


def main(argv=None):
    "Program wrapper."
    if argv is None:
        argv = sys.argv[1:]
    parser = ArgumentParser()
    parser.add_argument(
        "-v",
        "--verbose",
        dest="verbose",
        action="store_true",
        default=False,
        help="run as verbose mode",
    )
    args = parser.parse_args(argv)
    if args.verbose:
        LOG.setLevel(logging.DEBUG)
    stdin = IOWrapper(sys.stdin)
    stdout = IOWrapper(sys.stdout)
    do_job(stdin, stdout)
    stdout.flush()
    for h in LOG.handlers:
        h.flush()
    return 0


if __name__ == "__main__":
    sys.exit(main())

Submission status: Wrong Answer

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

ans=int(a*b)

print(ans)