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 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
#from math import gcd
import bisect
from collections import defaultdict
from collections import deque
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]

######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()

#####Shorten#####
def DD(arg): return defaultdict(arg)


#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
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

#####MakeDivisors######
def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors

#####MakePrimes######
def make_primes(N):
  max = int(math.sqrt(N))
  seachList = [i for i in range(2,N+1)]
  primeNum = []
  while seachList[0] <= max:
    primeNum.append(seachList[0])
    tmp = seachList[0]
    seachList = [i for i in seachList if i % tmp != 0]
  primeNum.extend(seachList)
  return primeNum

#####GCD#####
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#####BitCount#####
def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count

#####ChangeBase#####
def base_10_to_n(X, n):
  if X//n:
    return base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def base_n_to_10(X, n):
  return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))

#####IntLog#####
def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count

#############
# Main Code #
#############
A,B = SL()
print(int(int(A)*float(B)))

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

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

Submission status: Wrong Answer

Solution code:
import sys
from math import log2,floor,ceil,sqrt
# import bisect
# from collections import deque

# from types import GeneratorType
# def bootstrap(func, stack=[]):
#     def wrapped_function(*args, **kwargs):
#         if stack:
#             return func(*args, **kwargs)
#         else:
#             call = func(*args, **kwargs)
#             while True:
#                 if type(call) is GeneratorType:
#                     stack.append(call)
#                     call = next(call)
#                 else:
#                     stack.pop()
#                     if not stack:
#                         break
#                     call = stack[-1].send(call)
#             return call
#     return wrapped_function

Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
 
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7

a,b = [float(x) for x in sys.stdin.readline().split()]
print(floor(a*b))

Submission status: Wrong Answer

Solution code:
import sys 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
INF = 10 **18
A,B = read().split()
ans = float(A)*float(B)
print(int(ans))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

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

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

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:
# -*- coding: utf-8 -*-
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()))
m = A*B
ans =math.floor(m)
print(ans)

Submission status: Wrong Answer

Solution code:
I = input().split()
A = int(I[0])
B = float(I[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:
import math
A, B = input().split()
A = int(A)
B = int(float(B)*100)
print(A*B//100)

Submission status: Wrong Answer

Solution code:
import sys

sys.setrecursionlimit(10000000)
import os
import math
import bisect
import collections
import itertools
import heapq
import re
import queue

# import fractions

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


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

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())
F = A * B
print(round(F//1))

Submission status: Wrong Answer

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

ans = a*b 
ans = str(ans).split(".")
print(ans[0])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

print(int(a*b))

Submission status: Wrong Answer

Solution code:
from sys import stdin
def main():
    #入力
    readline=stdin.readline
    li=readline().strip().split()
    a=int(li[0])
    b=float(li[1])
    ans=int(a*b)
    print(ans)

if __name__=="__main__":
    main()

Submission status: Wrong Answer

Solution code:
inf = 10 ** 18
mod = 10 ** 9 + 7
a,b = map(float, input().split())
print(int(a*b))

Submission status: Wrong Answer

Solution code:
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub, or_

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

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

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

def read_float():
    return float(input())

def read_float_n():
    return list(map(float, input().split()))

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

def read_str_n():
    return list(map(str, input().split()))

def error_print(*args):
    print(*args, file=sys.stderr)



def main():
    a, b = read_float_n()
    print(math.floor(a * b))

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(10000000)
import numpy as np
from heapq import heapify, heappop, heappush
import copy
from math import gcd, ceil
from collections import deque
# queueとして使う場合 push, popleftを使う
from bisect import bisect_left, bisect_right
# bisect_left: 配列の順序関係が崩れない条件で挿入することができる一番左の点
# bisect_right: 配列の順序関係が崩れない条件で挿入することができる一番右の点
# A = [1, 1, 1, 2, 2, 2, 4]
# print(bisect_left(A, 2))  # 3
# print(bisect_right(A, 2))  # 6
# print(bisect_left(A, 3))  # 6
# print(bisect_right(A, 3))  # 6


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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
from collections import deque
import sys

def input():
    return sys.stdin.readline().rstrip()

li = list(input().split())

A, B = int(li[0]), float(li[1])

print(int(A * B))

Submission status: Wrong Answer

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

def solve(A: int, B: float):
    print(math.floor(A*B))
    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:
def resolve():
    import math
    n, m = map(float, input().split())
    print(math.floor(n*m))
resolve()

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

Submission status: Wrong Answer

Solution code:
def main():
    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(float, input_list())))

    A, B = input_number_list()
    print(int(A*B // 1))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

from math import floor

print(floor(a*b))

Submission status: Wrong Answer

Solution code:
import math

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

print(int(int(a) * b))

Submission status: Wrong Answer

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

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 numpy as np

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from sys import stdin
import math

def main():

    input = stdin.readline

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

    print(ans)

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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


if __name__ == "__main__":
    resolve()

Submission status: Wrong Answer

Solution code:
import sys
from collections import deque
import copy
def main():
    A, B = map(float, input().split())
    print(int(A * B))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
from math import floor

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

main()

Submission status: Wrong Answer

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

import sys
import math
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

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

ans = A * B * 100 // 100

print(int(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
a,b = map(float,input().split())
a = int(a)
b = int(100*b)

print(a*b//100)

Submission status: Wrong Answer

Solution code:
# coding: utf-8

import sys
import math
import collections
import itertools
import bisect
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return x if y == 0 else gcd(y, x%y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")

A, B = LS()
A = int(A)
B = float(B)

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

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
from sys import stdin


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


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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


def solve(A: int, B: float):
    print(round((A*B)//1))
    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:
import math
a, b = input().split()
a, b = int(a), float(b)
ans = a*b
print(math.floor(ans))

Submission status: Wrong Answer

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

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque 
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率

def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 10**9+7
    #w.sort(key=itemgetter(1),reversed=True)  #二個目の要素で降順並び替え

    #N = int(input())
    A,B = map(float, input().split())
    #A = tuple(map(int, input().split())) #1行ベクトル
    #L = tuple(int(input()) for i in range(N)) #改行ベクトル
    #S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列

    print(int(A*B))




if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

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:
print(int(eval(input().replace(' ','*'))))

Submission status: Wrong Answer

Solution code:
import sys
import math
import collections
from collections import deque
from functools import reduce
import heapq
#n = int(input())
a, b = map(float, sys.stdin.readline().split())
#n = input()
#a = list(map(int, sys.stdin.readline().split()))

        
print(math.floor(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:
# abc169_c.py
A, B = input().split()
A = float(A)
B = float(B)
print(int(A*B))

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

Submission status: Wrong Answer

Solution code:
from math import floor


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

    print(floor(A*B))


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
n,m=map(float, input().split())





print(int(n*m))

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:
import sys, math,os
from io import BytesIO, IOBase
#from bisect import bisect_left as bl, bisect_right as br, insort
#from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(float, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7


def main():

    a,b=mdata()
    out(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))

Submission status: Wrong Answer

Solution code:
# coding: utf-8

import sys
import math
from collections import Counter
import itertools
import fractions
#import numpy as np
#from functools import reduce

# 入力を整数に変換して受け取る
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
# 入力全てを整数に変換したものの配列を受け取る
def LI(): return list(map(int, sys.stdin.readline().split()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'

# リストを改行区切りで出力する
p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

def l_in():
    return list(map(int, input().split()))
a,b=input().split()
a=int(a)
b=float(b)

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

def solve():
    input = sys.stdin.readline
    A, B = map(float, input().split())
    B *= 100
    print(int(A * B) // 100)

    return 0

if __name__ == "__main__":
    solve()

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


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

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

from math import floor
print(floor(a*b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right
# from math import gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint

INF = float("inf")

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def mycount(ls,x):
    # lsはソート済みであること
    l = bisect_left(ls,x)
    r = bisect_right(ls,x)
    return (r-l)

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

def I():
    return int(input())

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

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

def CI(n):
    return [ int(input()) for _ in range(n) ]

def LI(n):
    return [ list(map(int,input().split())) for _ in range(n) ]

def S():
    return input()

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

def RS():
    return list(input().split())

def CS(n):
    return [ input() for _ in range(n) ]

def LS(n):
    return [ list(input().split()) for _ in range(n) ]

a,b = MS()

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

c = a*b

import math

ans = math.floor(c)

print(ans)

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:
def N(): return int(input())
def NM():return map(int,input().split())
def L():return list(NM())
def LN(n):return [N() for i in range(n)]
def LL(n):return [L() for i in range(n)]
l=list(input().split())
a=int(l[0])
b=float(l[1])
print(int(a*b//1))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
#from collections import deque,defaultdict
from sys import stdin
input = stdin.readline
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

Submission status: Wrong Answer

Solution code:
a, b = [i for i in input().split()]

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

Submission status: Wrong Answer

Solution code:
t=input().split(' ')

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

print(int(a*b))

Submission status: Wrong Answer

Solution code:
import sys
import math

readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip() # input string
ni = lambda: int(readline().rstrip()) # input int
nm = lambda: map(int, readline().split()) # input multiple int 
nl = lambda: list(map(int, readline().split())) # input multiple int to list

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

print((A*B)//100)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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