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: Accepted

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

from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import copy
from itertools import permutations
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right

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

from itertools import permutations
from math import factorial, hypot

#############
# Main Code #
#############

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

Submission status: Accepted

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

for s in range(len(B)):
    if B[s] != ".":
        B100 += B[s]

B100 = int(B100)

ans = A * B100 // 100

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
a,b=input().split()
a=Decimal(a)
b=Decimal(b)
ans=int(a*b)
print(ans)

Submission status: Accepted

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

print (int(c))

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

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

print (int(c))

Submission status: Accepted

Solution code:
from decimal import Decimal
a, b = input(). split()
a = int(a)
b = Decimal(b)
print(int(a*b))

Submission status: Accepted

Solution code:
import decimal
a,b=input().split()
print(int(int(a)*decimal.Decimal(b)))

Submission status: Accepted

Solution code:
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
from decimal import Decimal
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())


A,B = LS()
print(int(Decimal(A)*Decimal(B)))

Submission status: Accepted

Solution code:
from decimal import Decimal,ROUND_FLOOR
a,b=input().split()
b=Decimal(b)*100
print(int(int(a)*b//100))

Submission status: Accepted

Solution code:
A, B = input().split()
A = int(A)
B = B.split('.')
B = int(B[0])*100 + int(B[1])
res = '{:d}'.format(A*B)[:-2]
if res == '':
	print('0')
else:
	print(res)

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
b = int(b.replace('.', ''))
print(a * b // 10 ** 2)

Submission status: Accepted

Solution code:
import math
A,B = map(str,input().split())
A = int(A)
B = B.split('.')
if not len(B[1])==2:
    B[1].append('0')
B = int(''.join(B))
C = str(A*B)
C = C[:-2]
if C == '':
    C = 0
print(C)

Submission status: Accepted

Solution code:
from decimal import Decimal
A, B = [n for n in input().split()]
A = int(A)
B = Decimal(B)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

ans = (int(a) * int(1000*b))//1000

print(ans)

Submission status: Accepted

Solution code:
a,b = input().split()
a = int(a)
b,c = b.split('.')
b = int(b) * 100 + int(c)

print(a*b//100)

Submission status: Accepted

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

Submission status: Accepted

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

print (c)

Submission status: Accepted

Solution code:
a,b=map(str,input().split())
A=int(a)
B=""
for i in range(len(b)):
  if b[i]!=".":
    B+=b[i]
  else:
    pass
B=int(B)
ans=A*B//100
print(ans)

Submission status: Accepted

Solution code:
a,b = input().split()
a = int(a)
b = b.replace('.','')
b = int(b)
answer = str(a*b)
if (len(answer) <=2):
  print(0)
else:
  print(answer[:-2])

Submission status: Accepted

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

c = int(a)*int(b * 1000)//1000

print (c)

Submission status: Accepted

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()
A = int(A)
B = int(B[0]+B[2]+B[3])

print(A*B//100)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

    A = int(A)

    B_spl = B.split('.')
    L = len(B_spl[1])  # 小数部分の桁数, int化前に桁を調べる必要がある(末尾に0が続くケース)
    B_int, B_frac = map(int, B_spl)  # 整数部分, 小数部分

    ans = (A * B_int) + (A * B_frac) // pow(10, L)

    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

c = int(a)*int(float(b) * 1000)//1000

print (c)

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
from sys import stdin


def get_result(data):
    A, B = data
    return A * int(B * 100) // 100


if __name__ == '__main__':
    data = stdin.readline().rstrip().split(' ')
    data = [int(data[0]), Decimal(data[1])]
    result = get_result(data)
    print(result)

Submission status: Accepted

Solution code:
import decimal
a=list(map(decimal.Decimal,input().split()))
m=1
for x in a:
    m=m*x
print(int(m))

Submission status: Accepted

Solution code:
from decimal import *
A, B = input().split()
C = str(Decimal(A) * Decimal(B))
for i in C:
  if i ==".":
    exit()
  else:
    print(i, end ="")

Submission status: Accepted

Solution code:
# coding: utf-8
a, b = input().split()
a = int(a)
b = float(b) * 1000
b = int(b)
print(int((a * b) // 1000))

Submission status: Accepted

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

Submission status: Accepted

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

a = int(A)
b = int(float(B)*1000)

print(a*b//1000)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
A, B = input().split()
A = int(A)
B = int(B[0] + B[2] + B[3])
ans = str(A * B)
if len(ans) > 3:
    print(ans[:-2])
else:
    print(0)

Submission status: Accepted

Solution code:
from decimal import Decimal
import math
a,b = list(map(float, input().split()))
b *= 1000
A = int(a)
B = int(b)
#print(a)
#print(b)

#ab = a*b
#print(ab)

#ac = Decimal(a*b)
print(A*B//1000)

Submission status: Accepted

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

a = int(a)
b = int(b.replace(".",""))

print((a*b)//100)

Submission status: Accepted

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

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

B_by100 = int(B*100+0.5)
ans_by100 = A*B_by100

#print(str(ans_by100)[:-2])

ans=ans_by100//100
print(str(ans))

Submission status: Accepted

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

    A = int(A)
    B_int, B_frac = map(int, B.split('.'))  # 整数部分, 小数部分
    L = len(str(B_frac))  # 小数部分の桁数

    ans = (A * (B_int * 100 + B_frac)) // 100

    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *
getcontext().prec = 28
a,b = map(Decimal,input().split())
ans = a*b
print(int(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def c_multiplication_3():
    from decimal import Decimal
    A, B = [Decimal(i) for i in input().split()]
    return A * B // 1

print(c_multiplication_3())

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
import sys
import decimal

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

A, B = sr().split()
A = int(A)
B = decimal.Decimal(B) * 100
answer = A*B // 100
print(answer)

Submission status: Accepted

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

Submission status: Accepted

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

# slist = "abcdefghijklmnopqrstuvwxyz"
A,B = input().split()
A = int(A)
B = int(B.replace(".",""))

ans = (A*B)//100

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

Submission status: Accepted

Solution code:
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from math import ceil, floor, sqrt, gcd
from copy import deepcopy
from decimal import *

def main():
    a,b = map(Decimal, input().split())
    result = a*b
    print(int(result))
    
if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
from sys import stdin


def get_result(data):
    A, B = data
    return math.floor(A * B)


if __name__ == '__main__':
    data = stdin.readline().rstrip().split(' ')
    data = [int(data[0]), Decimal(data[1])]
    result = get_result(data)
    print(result)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
from sys import stdin


def get_result(data):
    A, B = data
    return int(A * B)


if __name__ == '__main__':
    data = stdin.readline().rstrip().split(' ')
    data = [int(data[0]), Decimal(data[1])]
    result = get_result(data)
    print(result)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

if __name__ == "__main__":
    A, B = input().split()
    A = Decimal(int(A))
    B = Decimal(B)
    print(int(A * B))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *

import numpy as np

import math

if __name__ == '__main__':
    a = [str(i) for i in input().split()]
    b = int(a[0])
    c = Decimal(a[1]) * Decimal(100)
    d = Decimal(a[0]) * Decimal(c) / Decimal(100)
    e = int(d)
    print(e)

Submission status: Accepted

Solution code:
ab=input().split()
a=int(ab[0])
b=ab[1].replace('.','')
b=int(b)
ans=a*b//100
print(ans)

Submission status: Accepted

Solution code:
A, B = input().split()
B1, B2 = B.split('.')
ans = int(A) * (int(B1) * 100 + int(B2))
print(ans // 100)