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:
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()))
from decimal import Decimal
#======================================================#
def main():
    a, b = IS().split()
    a = Decimal(int(a))
    b = Decimal(int(float(b)*100))
    print(Decimal(a*b)//100)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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



print(math.floor(int(a)*float(b)))

Submission status: Wrong Answer

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

def f(A, B):
    ans = str(A*B)

    return

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

if __name__ == "__main__":
    main()

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
from decimal import Decimal

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

Submission status: Wrong Answer

Solution code:
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    A, B = map(float, input().split())

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


main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

print(math.floor(A*B))

Submission status: Wrong Answer

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

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

i=input()

a,b=i.split(' ')
a_=int(a)
b_=float(b)
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:
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]

a,b = [float(w) for w in input().split()]
print(int(a*b//1))

Submission status: Wrong Answer

Solution code:
A,B=input().split()
A=int(A)
B=int(B[0]+B[2]+B[3])
X=str(A*B)
print(X[:-2])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

use=math.floor((a*b)//100)
print(use)

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python
from math import floor

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import io,sys
sys.setrecursionlimit(10**6)

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

Submission status: Wrong Answer

Solution code:
import math
from decimal import Decimal, getcontext

getcontext().prec = 99


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

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


resolve()

Submission status: Wrong Answer

Solution code:
# coding: utf-8
import math
A,B=input().split()
A=int(A)
B=float(B)
print(math.floor(A*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:
from pprint import pprint
import sys,math
sys.setrecursionlimit(10**7) 

A, B = [float(_) for _ in input().split()]
print(math.floor(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
print(int(eval(input().replace(" ", ".0*"))))

Submission status: Wrong Answer

Solution code:
from __future__ import print_function

from functools import reduce
from operator import mul
from collections import Counter
from collections import deque
from itertools import accumulate
from queue import Queue
from queue import PriorityQueue as pq
from heapq import heapreplace
from heapq import heapify
from heapq import heappushpop
from heapq import heappop
from heapq import heappush
import heapq
import time
import random
import bisect
import itertools
import collections
from fractions import Fraction
import fractions
import string
import math
import operator
import functools
import copy
import array
import re
import sys
sys.setrecursionlimit(500000)


input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return

# from fractions import gcd
# from math import gcd

# def lcm(n, m):
#     return int(n * m / gcd(n, m))


# def coprimize(p, q):
#     common = gcd(p, q)
#     return (p // common, q // common)


# def find_gcd(list_l):
#     x = reduce(gcd, list_l)
#     return x


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


mod = 1000000007


def combinations_count_mod(n, r):
    r = min(r, n - r)
    numer = reduce(lambda x, y: x*y % mod, range(n, n - r, -1), 1)
    denom = pow(reduce(lambda x, y: x*y % mod, range(1, r + 1), 1), mod-2, mod)
    return numer * denom % mod


def solve(a, b):
    a = int(a)
    b = int(float(b)*100)

    ans = a*b // 100
    return ans


a, b = input().strip().split()
print(solve(a, b))

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
A,B = input().split()
A = int(A)
B_i, B_d = map(int, B.split('.'))
if 1 <= B_d < 10:
    B_d *= 10

result_100 = A * (100*B_i+B_d)

print(str(result_100)[:-2])

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:
import sys
input = sys.stdin.readline
import math
def main():
    inp = input().split()
    ans = math.floor(int(inp[0])*int(float(inp[1])*100))
    ans = ans // 100
    print(int(ans))
if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
def examA():
    A, B = LI()
    ans = A*B
    print(ans)
    return

def examB():
    N = I()
    A = LI()
    for a in A:
        if a==0:
            print(0)
            return
    ans = 1
    for a in A:
        ans *= a
        if ans>10**18:
            print(-1)
            return
    print(ans)
    return

def examC():
    A, B = list(map(float,input().split()))
    ans = (A*B*100)//100
    print(int(ans+0.1))
    return

def examD():
    def factorization(n):
        arr = defaultdict(int)
        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[i] = cnt
        if temp != 1:
            arr[temp] = 1
        if arr == []:
            arr[n] = 1
        return arr
    C = [0,1,3,6,10,15,21,28,36,45]
    N = I()
    F = factorization(N)
    ans = 0
    #print(F)
    for f in F.values():
        for i in range(10):
            if C[i]>f:
                ans += i-1
                break
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 1<<60
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examC()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

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

print(int(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:
li = list(map(float, input().split()))
print(int(li[0]*li[1]))

Submission status: Wrong Answer

Solution code:
Num1, Num2 = map(float,input().split())
print(round(Num1 * Num2))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

print(int(a*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:
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*100)//100))

Submission status: Wrong Answer

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

a, b = map(float, input().split())
a = int(a)
i = trunc(a*b)

print(int(i))

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=map(float,input().split())
m=100
print(a*(b*m)//m)

Submission status: Wrong Answer

Solution code:
# 

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

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

print(int(A*B))

Submission status: Wrong Answer

Solution code:
from collections import defaultdict
from collections import deque
from itertools import accumulate
import math
def main():
    a,b=map(float, input().split())
    res = a*math.floor(b)
    bpp = []
    for i in range(len(str(b))):
        bpp.append(str(b)[i])
    if(len(str(b))>=3):
        res += a*(0.1)*int(bpp[2])
        if(len(str(b))==4):
            res += a*(0.01)*int(bpp[3])

    print(math.floor(res))

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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


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

N = int(N)
M1 = int(M * 100)
print((N*M1)//100)

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
    b = int(b)
    print(math.ceil(a*b//100))
    
if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import decimal

A, B = map(decimal.Decimal, input().split())


print((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:
def main():
    import math
    from builtins import int, map, list, float, print
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = (lambda: (sys.stdin.readline()).rstrip())
    input_list = (lambda: input().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

    A, B = input_list()
    a = int(A)
    B = str(B)
    B = B.replace(".", "")
    b = int(B)
    ans = a * b
    ans /= 100

    print(math.floor(ans / 100))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math
X = input().split()
A = int(X[0])
B = float(X[1])

print(math.floor(A *B))

Submission status: Wrong Answer

Solution code:
from math import *

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

Submission status: Wrong Answer

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

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

ab = a * b
AB = int(ab / 100)

print(AB)

Submission status: Wrong Answer

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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import sys,collections as cl,bisect as bs,math
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(math.floor(a*b))

Submission status: Wrong Answer

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

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

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

Submission status: Wrong Answer

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

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()
    print(int(a*b))

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:
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")

#solve
def solve():
    a, b = LF()
    a = int(a)
    b *= 100
    b = int(b)
    print(int(a * b) // 100)
    return


#main
if __name__ == '__main__':
    solve()

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())
a = int(a)
b1 = int(b)
b2 = int((b-b1)*10)
b3 = int((b-b1-b2/10)*100)
print(a*b1+a*b2//10+a*b3//100)

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import sys
#from collections import defaultdict, deque, Counter
#import bisect
#import heapq
#import math
#from itertools import accumulate
#from itertools import permutations as perm
#from itertools import combinations as comb
#from itertools import combinations_with_replacement as combr
#from fractions import gcd
#import numpy as np

stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18

def main():
    #n = int(stdin.readline().rstrip())
    A, B = map(float, stdin.readline().rstrip().split())
    #A = list(map(int, stdin.readline().rstrip().split()))
    #numbers = [[int(c) for c in l.strip().split()] for l in sys.stdin]
    #word = [stdin.readline().rstrip() for _ in range(n)]
    #number = [[int(c) for c in stdin.readline().rstrip()] for _ in range(n)]
    #zeros = [[0] * w for i in range(h)]
    ans = A*B
    ans = ans // 1
    print(int(ans))



main()

Submission status: Wrong Answer

Solution code:
A, B = input().split()
print(int(int(A)*int(B[0])+int(A)*(int(B[-2])/10)+int(A)*(int(B[-1])/100)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys

(a, b) = map(float, sys.stdin.readline().strip().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)

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a, b = (float(each) for each in input().split())
print(math.floor(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:
import math
a,b = map(float,input().split())

ans = a*math.floor(b)

print(math.floor(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# Contest No.: ABC169
# Problem No.: C
# Solver:      JEMINI
# Date:        20200531

import sys
import heapq

def main():
    a, b = map(str, sys.stdin.readline().split())
    a = int(a)
    b = float(b)
    b *= 10
    b = int(b)
    ans = a * b // 10
    print(ans)
    return

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, cos, radians, pi, sin
from operator import mul
from functools import reduce
from operator import mul

mod = 10 ** 9 + 7
INF = 10 ** 13
sys.setrecursionlimit(2147483647)
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]



a, b = LS()
a = int(a)
b = int(float(b) * 100)
print(a * b // 100)

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python
"""AtCoder Beginner Contest 169: C - Multiplication 3
https://atcoder.jp/contests/abc169/tasks/abc169_c
"""

__author__ = 'bugttle <bugttle@gmail.com>'


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

    print(int(A * B))

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
from sys import stdin
import math

a = stdin.readline().split()
print(math.floor(int(a[0])*float(a[1])))

Submission status: Wrong Answer

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

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

print(ans)

Submission status: Wrong Answer

Solution code:
import sys

A, B = map(float, sys.stdin.readline().rstrip().split())

print(int(A * B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from typing import List


def main():
    s: List[str] = input().split()

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

    # a = a_1 * 100 + a_2
    a_1: int = a // 100
    a_2: int = a % 100

    print(int(a_1 * int(b * 100) + a_2 * b))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

print(int(int(a[0])*float(a[1])))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import math
import bisect
#[int(x) for x in input().split()]
#map(int,input().split())
#for _ in range(int(input())):
a,b=map(float,input().split())
print(int((a*b)//1))

Submission status: Wrong Answer

Solution code:
import math

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

ans = a*b
f, i = math.modf(ans)
print(int(i))

Submission status: Wrong Answer

Solution code:
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

print(int(a * b))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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


def solve(A: int, B: float):
    r = math.floor(A*B)
    print(r)


# 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:
from decimal import *

# print('input >>')
A, B = map(float,(input().split()))

ans = Decimal(A) * Decimal(B)

# print('-----output-----')
print(int(ans))

Submission status: Wrong Answer

Solution code:
from decimal import *
import math

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

c = Decimal(a) * Decimal(b)



print(c.quantize(0, ROUND_FLOOR))

Submission status: Wrong Answer

Solution code:
a,b = input().split()
a = int(a)
b = float(b)
b_dig = int(b//1)
b_f = b%1

ans = a*b_dig
ans += (a*b_f)//1

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


def main():
    a, b = map(float, input().split())
    x = a * b * 100
    y = int(x / 100)
    print(y)
 
 
if __name__ == '__main__':
    import sys
    sys.setrecursionlimit(10000)
    main()

Submission status: Wrong Answer

Solution code:
import numpy as np
a,b=map(float,input().split())
a=np.array(a)
b=np.array(b)
b=b.astype(np.longdouble)
print(int(a*b))

Submission status: Wrong Answer

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

print(Decimal(A*B).quantize(0))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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