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

Submission status: Wrong Answer

Solution code:
from decimal import Decimal

A, B = input().split()

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

print(int((A*B)/Decimal(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:
import math

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

if __name__ == "__main__":
    main()

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

print((a*b)//100)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

print(a*b//100)

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
arr=list(map(float,input().strip().split()))[:2]
print(int(arr[0]*arr[1]))

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:
a, b = list(map(float, input().split()))
sum = str(a * b)
if '.' in sum:
    print(sum.split('.')[0])
else:
    print(sum)

Submission status: Wrong Answer

Solution code:
import math
from decimal import Decimal
a,b=map(float,input().split())
print(math.floor(Decimal(a)*Decimal(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:
import numpy as np

a = np.array(input().split(), dtype=np.float64)
ans = int(np.prod(a))
print(ans)

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sun May 31 21:07:49 2020

@author: NEC-PCuser
"""

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

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

MOD = 10 ** 9 + 7
INF = 10 ** 9

def main(kwargs):
    a = int(kwargs["a"])
    b = int(kwargs["b"] * 100)
    res = a * b // 100
    return res

if __name__ == "__main__":
    kwargs = {}

    cin = input().split()
    kwargs["a"], kwargs["b"] = [float(i) for i in cin]

    cout = main(kwargs)
    print(cout)

Submission status: Wrong Answer

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

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

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

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
#n = int(input())
#l = list(map(int, input().split()))
'''
A=[]
B=[]
for i in range():
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)'''
import math
a, b = map(float, input().split())
bn=math.floor(b)
#print(bn)
ans=a*bn
#print(ans,a*(b-bn))
print(math.floor(ans+a*(b-bn)))

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
a = int(a)
b100 = int(b * 100)
ans = str(a*b100)[:-2]
print(0 if ans == '' else 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:
import math
ls = list(input().split())
a = int(ls[0])
b = float(ls[1])
b_ = b * 100
ans = (a * b_) // 100

print(int(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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())
c = int(a)*float(b)
print(math.floor(c))

Submission status: Wrong Answer

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


def solve(A: int, B: float):
    B100 = int(B*100)
    print((A*B100)//100)
    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:
#C - Multiplication 3
A,B= map(float,input().split())
print(int(A*B))

Submission status: Wrong Answer

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

#a = int(input())
#b = list(map(int, input().split()))
a, b = map(float, input().split())
#s = input()
#s,t = input().split()
#
#readline = sys.stdin.readline
#n,m = [int(i) for i in readline().split()]
#ab = [[int(i) for i in readline().split()] for _ in range(n)]

print(int(a*b))

Submission status: Wrong Answer

Solution code:
k = input().split()
a = k[0]
b = k[1]
a = int(a)
b = float(b)
 
print(int(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 main():
    a,b = map(float,input().split())
    ans = int(a * b)

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

Submission status: Wrong Answer

Solution code:
from math import ceil
a,b=input().split()
a=int(a)
b=float(b)
print(ceil(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:
A, B = input().split(' ')

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

result = int(A * B)

print(result)

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

a = int(A)
b = B

print(int(a * b))

Submission status: Wrong Answer

Solution code:
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
# sys.setrecursionlimit(int(pow(10, 2)))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]





# @lru_cache(None)


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

Submission status: Wrong Answer

Solution code:
# coding: utf-8

import math
import re
import numpy as np

S = input().split(" ")
A = float(S[0])
B = float(S[1])

ans = math.floor(A * B)

print(ans)

Submission status: Wrong Answer

Solution code:
import sys
import math

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

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

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:
import math

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

Submission status: Wrong Answer

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

print(int(ans))

Submission status: Wrong Answer

Solution code:
"""
~~ Author : Bhaskar
~~ Dated : 31~05~2020
"""

import sys
from bisect import *
from math import floor,sqrt,ceil,factorial as F,gcd,pi
from itertools import chain,combinations,permutations,accumulate
from collections import Counter,defaultdict,OrderedDict,deque
from array import array
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)-1
mod = 1000000007
lcm = lambda a,b : (a*b)//gcd(a,b)
setbit = lambda x : bin(x)[2:].count("1")

def solve():
    a,b = map(float,sys.stdin.readline().split())
    ans = a*b
    print(floor(ans))

if __name__ == "__main__":
    solve()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python
import sys
sys.setrecursionlimit(10**9)
from collections import deque,defaultdict
import heapq
from itertools import combinations
import bisect


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

print((a*b)//100)

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:
import math

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

Submission status: Wrong Answer

Solution code:
import numpy
[a, b] = list(map(float, input().split()))
product = a*b
print(int(numpy.floor(product)))

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

tmp = LF()
ans = (tmp[0]*tmp[1])//1
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
import string
import collections
from collections import Counter
from collections import deque


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
ab = list(map(float, input().split()))
# print(ab)
print(math.floor(ab[0]*ab[1]))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:


def read_int():
    return int(input().strip())


def read_ints():
    return list(map(int, input().strip().split(' ')))


def read_floats():
    return list(map(float, input().strip().split(' ')))


def solve():
    A, B = read_floats()
    return int(A*B)


if __name__ == '__main__':
    print(solve())

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:

import numpy as np;
from numba import jit




if __name__ == '__main__':
  A, B = map(float, input().split())
  ans = A * B
  print(int(ans))

Submission status: Wrong Answer

Solution code:
import math
# from collections import Counter

# N = int(input()) # 1行, 単数
# arg = list(map(int, input().split())) # 1行, 配列
# D = Counter(arg) # 出現数カウント

# print('Yes')
# print('No')
# print()


arg = list(map(float, input().split())) # 1行, 配列
A = arg[0]
B = arg[1]

print(math.floor(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
A, B = map(str, input().split())
A = int(A)
ans = A * int(B[0])
ans += A * int(B[2]) // 10
ans += A * int(B[3]) // 100

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

from collections import defaultdict, deque
from sys import exit
import math
import copy
from bisect import bisect_left, bisect_right
from heapq import *
import sys
# sys.setrecursionlimit(1000000)
INF = 10 ** 17
MOD = 1000000007

from fractions import *
def inverse(f):
    # return Fraction(f.denominator,f.numerator)
    return 1/f


def combmod(n, k, mod=MOD):
    ret = 1
    for i in range(n - k + 1, n + 1):
        ret *= i
        ret %= mod

    for i in range(1, k + 1):
        ret *= pow(i, mod - 2, mod)
        ret %= mod

    return ret
def bunsu(n):
    ret = []
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            tmp = 0
            while(True):
                if n % i == 0:
                    tmp += 1
                    n //= i
                else:
                    break
            ret.append((i, tmp))

    ret.append((n, 1))
    return ret

def solve():
    a, b = list(map(float, input().split()))
    print(((a*100) * (b*100))//10000)
def main():
    # n = getN()
    # for _ in range(n):
    solve()
if __name__ == "__main__":
    solve()

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

print(int(a*b))

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:
import math

a_0, b_0 = input().split()
a = int(a_0)
b = float(b_0)
ans = math.floor(a*b)
print(ans)

Submission status: Wrong Answer

Solution code:
a = list(input().split())
print(int(eval(a[0]) * eval(a[1])))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

a,b=input().rstrip().split(" ")
a=int(a)
b=float(b)
#print(b)
u=int(100*b)
#print(u)
print((a*u)//100)

Submission status: Wrong Answer

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

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

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

answer = a * b

print(answer // 100)

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:
import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

A2,B2=map(str, stdin.readline().split())
A=float(A2)
B=float(B2)
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:
A, B = map(float, input().split())
Bint = B*100
print(int(A*Bint/100))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# from math import factorial,sqrt,ceil #,gcd
# from itertools import permutations,combinations,combinations_with_replacement
# from collections import deque,Counter
# from bisect import bisect_left
# from heapq import heappush,heappop
# from numba import njit
# from functools import lru_cache # 簡単メモ化 @lru_cache(maxsize=1000)
# from fractions import gcd

# from decimal import Decimal, getcontext
# # getcontext().prec = 1000
# # eps = Decimal(10) ** (-100)

# import numpy as np    # numpy.lcm()
# from scipy.sparse.csgraph import shortest_path, dijkstra, floyd_warshall, bellman_ford, johnson
# from scipy.sparse import csr_matrix
# from scipy.special import comb,perm #permはnPk
# import networkx as nx
# G = Graph()

import math

# slist = "abcdefghijklmnopqrstuvwxyz"
A,B = input().split()
A = int(A)
B = float(B)*100

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

print(ans)
# for row in board:
#     print(*row,sep="")    #unpackして間にスペース入れずに出力する
# print("{:.10f}".format(ans))
# print("{:0=10d}".format(ans))

Submission status: Wrong Answer

Solution code:
N, M = input().strip().split()
N, M = [int(N), float(M)]
print(int(N*M//1))

Submission status: Wrong Answer

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

answer = int(a*b)

print(answer)

Submission status: Wrong Answer

Solution code:
from math import ceil, floor

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

Submission status: Wrong Answer

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

import math

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

print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
if __name__ == "__main__":
    a, b = map(float, input().split())
    print(int(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:
import numpy as np
import math

A,B = (float(x) for x in input().split())

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

Submission status: Wrong Answer

Solution code:
a=list(map(str,input().split()))
a1=int(a[0])
b=float(a[1])
k=a1*b
print(int(k))

Submission status: Wrong Answer

Solution code:
import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


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:
from math import floor
a = input().split()
n1 = int(a[0])
n2 = float(a[1])

print(floor(n1*n2))

Submission status: Wrong Answer

Solution code:
#!python3

iim = lambda: map(int, input().rstrip().split())

def resolve():
    a, b = input().split()
    a = int(a); b = float(b)

    print(int(a*b))

if __name__ == "__main__":
    resolve()

Submission status: Wrong Answer

Solution code:
#
# 　　  ⋀_⋀　 
#　　  (･ω･)  
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│ 
#  │＊　祈　＊│ 
#  │＊　願　＊│ 
#  │＊　　　＊│ 
#      ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ
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 fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    S=ST().split()
    A=int(S[0])
    B=float(S[1])
    B*=100

    B=int(B)
    # print(A,B)
    # print(A*B)

    print(A*B//100)
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math
i,j= list(map(float , input().split()))
ans = math.floor(i*j)
print(ans)

Submission status: Wrong Answer

Solution code:
A = list(map(str, input().split()))
print(int(int(A[0])*float(A[1])))

Submission status: Wrong Answer

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

print(main())

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
import numpy as np

ans = a * b

if int(ans) == ans:
    print(int(ans))
else:
    print(int(np.floor(ans)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

i, d = divmod(a*b, 1)

print(int(i))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

result = math.floor(A * B)

print(result)

Submission status: Wrong Answer

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

c = a*b
d = c%1
print(int(c-d))

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

print(math.floor(n * m))

Submission status: Wrong Answer

Solution code:


S=input().split()
A=int(S[0])
B=float(S[1])

#print(A,B)
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:
ab = input().split()
ab[0] = int(ab[0])
ab[1] = float(ab[1])

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

Submission status: Wrong Answer

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

#print(math.floor(a * b))
print(int((a * b) // 1))

Submission status: Wrong Answer

Solution code:
A,B=map(float,input().strip().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:
#-*- coding: utf-8 -*-
import math
a, b = map(float,input().split())
print(int(a*b))

Submission status: Wrong Answer

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

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:
A, B = map(float, input().split())
if float(B) >= 1:
    print(int(A*B))
else:
    print(0)

Submission status: Wrong Answer

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