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:
def main():
    a, b = map(str, input().split())
    a = int(a)
    b = float(b)
    x = int(b)
    y = int(b*10) - 10*x
    z = int(b*100) - 100*x - 10*y
    ans = a*x*100 + a*y*10 + a*z
    print(ans//100)

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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


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


def solve():
    N, M = IL(float)
    print(int(N) * int(M * 100) // 100)


solve()

Submission status: Wrong Answer

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

ans = a*b
q, r = divmod(ans, 100)
#print(q, r)
print(q)

Submission status: Wrong Answer

Solution code:
from decimal import *

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

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

print(ans)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:

def s0():return input()
def s1():return input().split()
def s2(n):return [input() for x in range(n)]
def s3(n):return [input().split() for _ in range(n)]
def s4(n):return [[x for x in s] for s in s2(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b,yes="Yes",no="No"): print(yes if b else no)
# from sys import setrecursionlimit
# setrecursionlimit(1000000)
# from collections import Counter,deque,defaultdict
# import itertools
# import math
# import networkx as nx
# from bisect import bisect_left,bisect_right
# from heapq import heapify,heappush,heappop
a,b=s1()
a=int(a)
b=int(float(b)*100)

print(int(a*b/100))

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

Submission status: Wrong Answer

Solution code:
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy

if __name__ == "__main__":
    a,b = map(float,input().split())
    ans = a*b
    print(int(ans))

Submission status: Wrong Answer

Solution code:
N,M = map(float,input().split())
import math
from decimal import *
print(math.floor(Decimal(N*M)))

Submission status: Wrong Answer

Solution code:
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:
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 
#整数input
def ii(): return int(sys.stdin.readline().rstrip()) #int(input())
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) #list(map(int,input().split()))
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]
#文字列input
def ss(): return sys.stdin.readline().rstrip() #input()
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) #list(input().split())
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]

#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？

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

Submission status: Wrong Answer

Solution code:
import math

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
from collections import defaultdict, deque
import sys
import heapq
import bisect
import itertools
import queue
import copy
import time
import math
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7

def inp(): return int(sys.stdin.readline())

def inpl(): return list(map(float, sys.stdin.readline().split()))

def inpl_str(): return list(sys.stdin.readline().split())

a, b = inpl()
print(math.floor(a*b))

Submission status: Wrong Answer

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

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:

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
inputs = input().strip().split()
A = int(inputs[0])
B = int(float(inputs[1]) * 100)

ans = A * B // 100

print(ans)

Submission status: Wrong Answer

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

print(int(A*B))

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd
from itertools import permutations, combinations, product, accumulate, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
#from fractions import gcd
from decimal import *
def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(float, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True

a, b = MAP()
getcontext().prec = 10
a = Decimal(a)
b = Decimal(b)
print(int(a * b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

a = int(raw[0])
b = float(raw[1])

print(int(a*b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

print( int(A*B) )

Submission status: Wrong Answer

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



if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import sys
import math

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60


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

    return


if __name__ == '__main__':
    main()

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

print(int(A*B))

Submission status: Wrong Answer

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


def solve(A: int, B: float):
    bint = int(B*100)
    print(math.floor(A*bint/100.0))
    return


# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = float(next(tokens))  # type: float
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:

A,B = [float(i) for i in input().split()]

print(int(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:
A, B = [float(i) for i in input().split()]

print(int(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
import sys
from decimal import Decimal

input = sys.stdin.readline


def main():
    A, B = map(float, input().split())

    a = Decimal(A)
    b = Decimal(B)
    ans = a * b
    ans = int(ans)
    print(ans)


if __name__ == "__main__":
    main()

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()))

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



print(int(a*b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

S = input().strip().split()
A = int(S[0])
B = float(S[1])
print(math.floor(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:
import sys


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


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


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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# For taking integer inputs.
import math


def inp():
    return(int(input()))


# For taking List inputs.
def inlist():
    return(list(map(int, input().split())))


# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.
def instr():
    s = input()
    return(list(s[:len(s)]))


# For taking space seperated integer variable inputs.
def invr():
    return(map(float, input().split()))


a, b = invr()

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

print(int(A * B))

Submission status: Wrong Answer

Solution code:
#! python3
def LI():
    return list(map(float, input().split()))

a, b = LI()

def main():
    ans = int(a * b)
    print(ans)

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd, cos, radians, floor
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)

# UnionFind
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

# ダイクストラ
def dijkstra_heap(s, edge, n):
    #始点sから各頂点への最短距離
    d = [10**20] * n
    used = [True] * n #True:未確定
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        #まだ使われてない頂点の中から最小の距離のものを探す
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d

# 素因数分解
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

# 2数の最小公倍数
def lcm(x, y):
    return (x * y) // gcd(x, y)

# リストの要素の最小公倍数
def lcm_list(numbers):
    return reduce(lcm, numbers, 1)

# リストの要素の最大公約数
def gcd_list(numbers):
    return reduce(gcd, numbers)

# 素数判定
def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True


# limit以下の素数を列挙
def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P

# 同じものを含む順列
def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        # set（集合）型で重複を削除、ソート
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret


# ここから書き始める
a, b = map(float, input().split())
ans = floor(a * b)
print(ans)

Submission status: Wrong Answer

Solution code:
import math


if __name__ == "__main__":
    A, B = input().split()
    ai = int(A)
    bf = float(B)
    print(math.floor(ai*bf))

Submission status: Wrong Answer

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

print(int(ans//1))

Submission status: Wrong Answer

Solution code:
import sys

input = lambda: sys.stdin.readline().rstrip()


def solve():
    A, B = input().split()
    A = int(A)
    B = float(B)

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


if __name__ == '__main__':
    solve()

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:
import sys
import heapq
import random
import collections

# available on Google, not available on Codeforces
# import numpy as np
# import scipy
import math


def solve(a,b):  # fix inputs here
    # console("----- solving ------")
    return int(a*b)

def console(*args):  # the judge will not read these print statement
    print('\033[36m', *args, '\033[0m', file=sys.stderr)
    return


# for case_num in range(int(input())):
    # read line as a string
    # strr = input()

    # read line as an integer
# _ = int(input())
    
    # read one line and parse each word as a string
    # lst = input().split()

    # read one line and parse each word as an integer

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

    # read matrix and parse as integers (after reading read nrows)
    # lst = list(map(int,input().split()))
    # nrows = lst[0]  # index containing information, please change
    # grid = []
    # for _ in range(nrows):
    #     grid.append(input())

res = solve(a,b)

    # Google - case number required
    # print("Case #{}: {}".format(case_num+1, res))

    # Codeforces - no case number required
print(res)

Submission status: Wrong Answer

Solution code:


a, b = [float(x) for x in input().split()]

ans = str(a*b).split('.')
print(ans[0])
# print(int(a*b))

# print(int(1.99999999999999999999999999999999999999999999))

Submission status: Wrong Answer

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

ans=int(A*B)

print(ans)

Submission status: Wrong Answer

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

print(res)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
def input():
    return sys.stdin.readline()[:-1]

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().split())
b = int(b*100)
a = int(a)
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 = a * b
ans = math.floor(ans)
print(int(ans))

Submission status: Wrong Answer

Solution code:
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

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

print(int(a*b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
def solve () :
    a, b = input().split(" ")
    a = int(a)
    b = float(b)
    cur = a*int(b)
    mod = int(a*float( b-int(b) ))
    return cur+mod

print(solve())

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# coding: utf-8
import sys

stdin = sys.stdin
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))


def main():
    a,b = list(map(float, stdin.readline().split()))
    print(int(a*b))
    return


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(float, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#import numpy as np
from decimal import *

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

Submission status: Wrong Answer

Solution code:
# ABC169 C Multiplication 3

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

print(int(a*b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

A=int(lis[0])
B=float(lis[1])

print(int(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a, b = input().split()
if '.' in a:
    a = float(a)
else:
    a = int(a)
if '.' in b:
    b = float(b)
else:
    b = int(b)
ans = a*b
ans = str(ans)
tmp = ""
for s in ans:
    if s == '.':
        break
    tmp += s
print(tmp)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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(float, input().split())

print(int(a*b))

Submission status: Wrong Answer

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

a = int(x[0])

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

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(float,input().split())

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

Submission status: Wrong Answer

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

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()

    a,b = input().split()
    a = int(a)
    b = float(b)
    eps = 10**(-8)
    ans = int(a * b + eps)
    print(ans)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

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:
def main():
  import math
  xyz = list(input().split())
  A = int(xyz[0])
  B = float(xyz[1])
  print(math.floor(A*B))
main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

if __name__=="__main__":
    main()

Submission status: Wrong Answer

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