Problem:


Score : 100 points

Problem Statement

In order to pass the entrance examination tomorrow, Taro has to study for T more hours.

Fortunately, he can leap to World B where time passes X times as fast as it does in our world (World A).

While (X \times t) hours pass in World B, t hours pass in World A.

How many hours will pass in World A while Taro studies for T hours in World B?

Constraints

All values in input are integers.

1 \leq T \leq 100

1 \leq X \leq 100

Input

Input is given from Standard Input in the following format:

T X

Output

Print the number of hours that will pass in World A.

The output will be regarded as correct when its absolute or relative error from the judge's output is at most 10^{-3}.

Sample Input 1

8 3

Sample Output 1

2.6666666667

While Taro studies for eight hours in World B where time passes three times as fast, 2.6666... hours will pass in World A.

Note that an absolute or relative error of at most 10^{-3} is allowed.

Sample Input 2

99 1

Sample Output 2

99.0000000000

Sample Input 3

1 100

Sample Output 3

0.0100000000



Sample input:
8 3


Sample output:
2.6666666667

Submission status: Accepted

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

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

t,x = LI()
print(t/x)

Submission status: Accepted

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

print(a/b)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
t,x = map(int,input().split())
print('{:.8f}'.format(t/x))

Submission status: Accepted

Solution code:
T,X = map(int,input().split())

print(T/X)

Submission status: Accepted

Solution code:
def main():
    t, x = map(float, input().split())
    print(t/x)
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# ABC 117: A – Entrance Examination
t, x = [int(s) for s in input().split()]
print(t / x)

Submission status: Accepted

Solution code:
p,q= input().split()
a,b =(int(p), int(q))
print(a/b)

Submission status: Accepted

Solution code:
from collections import deque
from collections import Counter
from itertools import product, permutations,combinations
from operator import itemgetter
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right, bisect
#pypyではscipy, numpyは使えない
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson, minimum_spanning_tree
#from scipy.sparse import csr_matrix, coo_matrix, lil_matrix
#import numpy as np
from fractions import gcd
from math import ceil,floor, sqrt, cos, sin, pi, factorial
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float('inf')
from datetime import datetime as dt

def main():
  t, x = map(int, readline().split())
  print(t/x)
  
  
  
if __name__ == '__main__':
  main()

Submission status: Accepted

Solution code:
def main():
  #n = int(input())
  #s = input()
  #s = input().split()
  t,x = list(map(int,input().split()))
  #a = [input() for i in range(n)]
  #a = [int(input()) for i in range(n)]
  #a = [input().split() for i in range(n)]
  #a = [list(map(int,input().split())) for i in range(n)]
  ans = 0
  count = 0
  lis = []
  
  print(t/x)

if __name__ == '__main__':
  main()

Submission status: Accepted

Solution code:
t, x = map(int, input().split())
ans = t/x
print(ans)

Submission status: Accepted

Solution code:
T, X = map(int, input().split())
A = T / X
print(A)

Submission status: Accepted

Solution code:
import itertools
import fractions
def main():
  t,x = map(int,input().split())
  print("{:.06}".format(t/x))
if __name__ == '__main__':
  main()

Submission status: Accepted

Solution code:
def main():
    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
    #from itertools import product
    from bisect import bisect_left,bisect_right
    import heapq
    from math import floor, ceil
    #from operator import itemgetter

    #inf = 10**17
    #mod = 10**9 + 7

    t,x = map(int, input().split())
    print(t/x)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
t,x = map(int,input().split())
print (t/x)

Submission status: Accepted

Solution code:
import sys

t, x = map(int, sys.stdin.readline().split())

def main():
    print(t / x)

if __name__ ==  '__main__':
    main()

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

if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    print(a[0]/a[1])

Submission status: Accepted

Solution code:
t, x = map(int, input().split())
print(t/x)

Submission status: Accepted

Solution code:
T, X = map(int,input().split())

print(T/X)

Submission status: Accepted

Solution code:
T,X = map(int,input().split());print(T/X)

Submission status: Accepted

Solution code:
import sys
from bisect import *
from heapq import *
from collections import *
from itertools import *
from functools import *
from math import *
from fractions import *

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

def main():
    T, X = map(int, input().split())
    print(T / X)

main()

Submission status: Accepted

Solution code:
# coding: utf-8
T, X = map(int, input().split())

print(T/X)

Submission status: Accepted

Solution code:
T,X=map(int,input().split())
print('{:.12f}'.format(T/X))

Submission status: Accepted

Solution code:
T,X = map(int,input().split())

ans = T/X

print(ans)

Submission status: Accepted

Solution code:
T, X = map(float, input().split())
print(T/X)

Submission status: Accepted

Solution code:
T,X=map(int,input().split())
ans=T/X
print(ans)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
INF = 10**10
MOD = 10**9 + 7
sys.setrecursionlimit(100000000)
from functools import lru_cache
from itertools import permutations

def main():
    t,x = map(int,input().split())
    print(t/x)
if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
t,x=map(int,input().split())

print("{:.10f}".format(t/x))

Submission status: Accepted

Solution code:
def main():
    t, x = map(int, input().split())

    print(t/x)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

main()

Submission status: Accepted

Solution code:
t, x = map(int, input().split())
ans = t / x
print(ans)

Submission status: Accepted

Solution code:
T,X = map(int,input().split(" "))
print(T/X)

Submission status: Accepted

Solution code:
# ABC117 A

def main():
    t, x = map(int, input().split())

    print(t / x)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
T,X = map(int,(input().split()))
print(T/X)

Submission status: Accepted

Solution code:

T,X = map(int, input().split())
t = T/X
print(t)

Submission status: Accepted

Solution code:
X, t = map(int, input().split())

print(X/t)

Submission status: Accepted

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

print(a / b)

Submission status: Accepted

Solution code:
# | Its_Rashid | #
a , b = map(int , input() . split())
print(a / b)

Submission status: Accepted

Solution code:
n, m = map(int, input().split())
print(n/m)

Submission status: Accepted

Solution code:
def main():
    t, x = map(int, input().split())
    ans = t / x
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#abc117 a
t,x=map(int,input().split())
print(t/x)

Submission status: Accepted

Solution code:
T,X = map(int, input().split())

print(T / X)

Submission status: Accepted

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

print(a/b)

Submission status: Accepted

Solution code:
a, x = map(int, input().split())
print(a/x)

Submission status: Accepted

Solution code:
import sys
import os


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

    t,x = list(map(int, sys.stdin.readline().split()))
    print(t/x)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def solve():
    T, X = map(int, input().split())
    print(T/X)

if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
t, x  =map(int, input().split())
print(t/x)

Submission status: Accepted

Solution code:
x=list(map(int, input().split()))
print(x[0]/x[1])

Submission status: Accepted

Solution code:
# A - Entrance Examination
t,x=list(map(int,input().split()))
print(t/x)

Submission status: Accepted

Solution code:
x,t=map(int,input().split())
print(x/t)

Submission status: Accepted

Solution code:
t, x=map(int,input().split())
print(t/x)

Submission status: Accepted

Solution code:
[T,X] = list(map(int,input().split()))
print(T/X)

Submission status: Accepted

Solution code:
# import bisect
# from collections import Counter, defaultdict, deque
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
# import itertools
# from operator import attrgetter, itemgetter
# import math

import sys

# import numpy as np

ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)

def main():
    t, x = list(map(int,ipti().split()))
    print(t/x)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x, t = list(map(int, input().split()))
print(x / t)

Submission status: Accepted

Solution code:
T,X=map(int,input().split())
t=T/X
print(str(t))

Submission status: Accepted

Solution code:
t,k = map(float, input().split())
ans = t / k
print(ans)

Submission status: Accepted

Solution code:
t, x = [int(i) for i in input().split()]

print(t/x)

Submission status: Accepted

Solution code:
T, X = list(map(int, input().split()))
print(T / X)

Submission status: Accepted

Solution code:
x,y = map(int,input().split())

print(x/y)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

T,X = list(map(int, input().rstrip().split()))
ans = T/X
print( Decimal(str(ans)).quantize(Decimal('0.0000000001'), rounding=ROUND_HALF_UP) )

Submission status: Accepted

Solution code:
#117_A
T,X=map(int,input().split())
print(T/X)

Submission status: Accepted

Solution code:
print(eval(input().replace(" ", "/")))

Submission status: Accepted

Solution code:
T, X = [int(_) for _ in input().split()]
print(T / X)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
t, x = map(int, input().split())

print(t / x)

Submission status: Accepted

Solution code:
T,X = map(int,input().split())
print("{:.5f}".format(T/X))

Submission status: Accepted

Solution code:
T, X = map(int, input().split())

t = T / X
print(t)

Submission status: Accepted

Solution code:
t, x = map(int,input().split())
print("{0:.10f}".format(t/x))

Submission status: Accepted

Solution code:

T, X = map(int, input().split())
print(T/X)

Submission status: Accepted

Solution code:
t,x = list(map(int,input().split()))
print(t/x)

Submission status: Accepted

Solution code:
t,x = [int(x) for x in input().split()]

print(t/x)

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().rstrip()

def main():
    T, X = map(int, input().split())
    print(T / X)
    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
T,X = [int(i) for i in input().split()]
print(T/X)

Submission status: Accepted

Solution code:
t,x = map(int,input().split())
print(float(t/x))

Submission status: Accepted

Solution code:
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda x: [na() for _ in range(x)]
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()

t, x = na()
print(t / x)

Submission status: Accepted

Solution code:
x,y = map(int,input().split())
print(float(x/y))

Submission status: Accepted

Solution code:
t, x = map(int, input().split() )

print( t / x )

Submission status: Accepted

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


def main():
    T, X = map(int, input().split())
    print(T / X)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
T, X = list(map(int, input().split()))
print(format(T/X,'.4f'))

Submission status: Accepted

Solution code:
T,X=map(int,input().split())
print(float(T/X))

Submission status: Accepted

Solution code:
import sys

INPUT = lambda: sys.stdin.readline().rstrip()
MAP = lambda: map(int, INPUT().split())

sys.setrecursionlimit(10 ** 9)


def main():
    T, X = MAP()
    print(T/X)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
t,x = (int(i) for i in input().split())

print (float(t) / x)

Submission status: Accepted

Solution code:
T,X = map(int,input().split())
print( T/X)

Submission status: Accepted

Solution code:
import sys
import math
import itertools

t,x=list(map(float,input().split()))
print(float(t/x))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
 
import math
import itertools
import sys
import copy
 
# 入力
#A, B, C, D = map(int, input().split())
#L = list(map(int, input().split()))
#S = list(str(input()))
#N = int(input())
#S = str(input())
T, X= map(int, input().split())

print (T/X)

Submission status: Accepted

Solution code:
t,x = map(int,input().split())
print("{:1.9f}".format(t/x))

Submission status: Accepted

Solution code:
t,x=map(float,input().split())
print(round(t/x, 10))

Submission status: Accepted

Solution code:
def main():
    T, X = map(int, input().split(" "))
    print(T / X)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal

T, X = [Decimal(i) for i in input().split()]
ans = T / X
print(ans)

Submission status: Accepted

Solution code:
T, X = map(int, input().split())

ans = T / X

print(ans)

Submission status: Accepted

Solution code:
a, b = (int(i) for i in input().split())
print(a/b)

Submission status: Accepted

Solution code:
z = input()
z_list = z.split(" ")
t = int(z_list[0])
x = int(z_list[1])

a = t / x
print(a)

Submission status: Accepted

Solution code:
T, X = [int(i) for i in input().split()]

print(T / X)

Submission status: Accepted

Solution code:
"""
author : halo2halo
date : 16, Jan, 2020
"""

import sys
import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

T, X = map(int, readline().decode('utf8').split())
print(T/X)

Submission status: Accepted

Solution code:
T, X= map(int, input().split())
print(T/X)

Submission status: Accepted

Solution code:
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def my_round(a,dig=0):
    p = 10 ** dig
    return (a * p * 2 + 1) // 2 / p

def gcd(a,b): #最大公約数
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def lcm(a,b): #最小公倍数
    return a/gcd(a,b)*b

def divisors(a): # 約数列挙
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): #素数判定
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): #素数列挙
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def prime_fact(a): #素因数分解
    sqrt = math.sqrt(a)
    res = []
    i = 2
    if is_prime(a):
        res.append(a)
    else:
        while a!=1:
            while a%i==0:
                res.append(i)
                a //= i
            i += 1
    return res

def main():
    t,x = map(int,input().split())
    ans = t / x
    print(ans)
    return

if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    T, X = list(map(int, input().split()))
 
    print(T/X)
 
main()

Submission status: Accepted

Solution code:
def main():
    from sys import stdin
    r = stdin.readline()[:-1]
    #r = stdin.readlines()

    a, b = map(int, r.split())
    print(a/b)
    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
T, X =map(int, input().split())
print(T/X)

Submission status: Accepted

Solution code:
t, x = map(int, input().split())
print(t/float(x))

Submission status: Accepted

Solution code:
import sys

t, x = map(int, sys.stdin.readline().split())

def main():
    return t / x

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

Submission status: Accepted

Solution code:
T, X = list(map(int, input().split()))
print(T / float(X))

Submission status: Accepted

Solution code:
t,x = map(int, input().split())
print('{:.5f}'.format(t/x))

Submission status: Accepted

Solution code:
def main():
    T, X = list(map(int, input().split()))

    print(T/X)

main()

Submission status: Accepted

Solution code:
t,x = map(float,input().split())

print(t/x)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**9)
INF=10**18
def input():
    return sys.stdin.readline().rstrip()

def main():
    t,x=map(int,input().split())
    print(t/x)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
t, x = map(lambda x: int(x), input().split())

print(t/x)

Submission status: Accepted

Solution code:
t, x = list(map(int, input().split()))
print(t / x)

Submission status: Accepted

Solution code:
T, X = map(int, input().split())

print(T/X)

Submission status: Accepted

Solution code:
t, x = map(int, input().split())

print(t / x)

Submission status: Accepted

Solution code:

t,x = map(int,input().split())
print(t/x)

Submission status: Accepted

Solution code:
T,X= map(int,input().split())

print(T/X)

Submission status: Accepted

Solution code:
# coding: utf-8 

(n1, n2) = [int(i) for i in input().rstrip().split(" ")]
print(n1/n2)

Submission status: Accepted

Solution code:
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

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

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353


T, X = list(map(int, sys.stdin.buffer.readline().split()))

a=T/X
print(a)

Submission status: Accepted

Solution code:
def p_a():
    t, x = map(int, input().split())
    print(t / x)
    
p_a()

Submission status: Accepted

Solution code:
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b=INTM()
    print(a/b)
if __name__ == '__main__':
    do()

Submission status: Accepted

Solution code:
T, X  = map(int, input().split())
print(T/X)

Submission status: Accepted

Solution code:
N = list(map(int,input().split()))
print(N[0]/N[1])

Submission status: Accepted

Solution code:
t,x = map(int,input().split())

ans = t/x
print(ans)

Submission status: Accepted

Solution code:
def solve():
    T, X = map(int, input().split())
    print(T/X)


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
t,x = map(int,input().split())

print( t / x )

Submission status: Accepted

Solution code:
t,x=map(int,input().split())
print(float(t/x))

Submission status: Accepted

Solution code:
t, x = map(int, input().split())
print("{:.10f}".format(t / x))

Submission status: Accepted

Solution code:
T, X = map(int, input().split()) 

print(T / X)

Submission status: Accepted

Solution code:
import math

t, x = map(int, input().split())
print(t / x)

Submission status: Accepted

Solution code:
T, X = map(int, input().split())

print(float(T/X))

Submission status: Accepted

Solution code:
t,x = map(int, input().split())
print(t/x)

Submission status: Accepted

Solution code:

T, X = map(int, input().split())

print(T / X)

Submission status: Accepted

Solution code:
T, X = map( int, input().split() )
print( float( T / X ) )

Submission status: Accepted

Solution code:
def examA():
    T, X = LI()
    ans = T/X
    print(ans)
    return

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
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()
mod = 10**9 + 7
inf = float('inf')

if __name__ == '__main__':
    examA()

Submission status: Accepted

Solution code:
X, T = list(map(int, input().split()))
print(X / T)

Submission status: Accepted

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

print(A/B)

Submission status: Accepted

Solution code:
T, X = map(int, input().split())
print('{:.5f}'.format(T / X))

Submission status: Accepted

Solution code:
T, X = [float(x) for x in input().split()]
print(T/X)

Submission status: Accepted

Solution code:
(t, x) = map(int, input().split())
print(t / x)

Submission status: Accepted

Solution code:
N,A = map(int, input().split())
print(N/A)

Submission status: Accepted

Solution code:
t,x=map(int,input().split())
print('{:.5f}'.format(t/x))

Submission status: Accepted

Solution code:
t,x = map(int,input().split())
ans = t / x
print(ans)

Submission status: Accepted

Solution code:
T, X = [int(x) for x in input().rstrip().split()]
print(T / X)

Submission status: Accepted

Solution code:
table = [int(x) for x in input().split()]
t, x = table[0], table[1]
print(t / x)

Submission status: Accepted

Solution code:
t,x = map(int, input().split())

print(t/x)

Submission status: Accepted

Solution code:
t,x=map(int,input().split());print("%.10f"%(t/x))

Submission status: Accepted

Solution code:
T,X=map(int, input().split())  #複数数値入力　「A B」みたいなスペース空いた入力のとき

print(T/X)

Submission status: Accepted

Solution code:
t,x=map(int,input().split())
print(t/x)

Submission status: Accepted

Solution code:
T, X = map(int, input().split(" "))

print(T / X)

Submission status: Accepted

Solution code:
# ABC117a
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

t, x = map(int, input().split())
print(t/x)

Submission status: Accepted

Solution code:
str=input()
str=str.split(" ")
T=float(str[0])
X=float(str[1])
print(T/X)

Submission status: Accepted

Solution code:
T,X=list(map(int,input().split(" ")))

print(T/X)

Submission status: Accepted

Solution code:
T, X = [int(n) for n in input().split()]
print(T/X)

Submission status: Accepted

Solution code:
T,X=tuple(map(int,input().split()))
print(T/X)

Submission status: Accepted

Solution code:
T,X=map(int, input().split())
print(T/X)

Submission status: Accepted

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

print(a / b)

Submission status: Accepted

Solution code:
t,x=map(int,input().split(' '))
print(t/x)

Submission status: Accepted

Solution code:
T, X = list(map(int, input().split()))
print(T / X)

Submission status: Accepted

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

ans = a[0] /a[1]
print("{0:.10f}".format(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import os, sys, re, math

T,X = list(map(int,input().split(' ')))
print(T/X)

Submission status: Accepted

Solution code:
t, x = [int(a) for a in input().split()]
print(t/x)

Submission status: Accepted

Solution code:
import os, sys, re, math

(T, X) = [int(n) for n in input().split()]

print ('%f' % (T / X))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
t, x = map(int, input().split())
print (t/x)

Submission status: Accepted

Solution code:
t, x=map(int, input().split())
print(t/x)

Submission status: Accepted

Solution code:
T,X = (int(i) for i in input().split())

ans = T / X 
print(ans)

Submission status: Accepted

Solution code:
T, X = [int(i) for i in input().split()]
print(T/X)

Submission status: Accepted

Solution code:
T, X = [int(i) for i in input().split()]
print(T/X)

Submission status: Accepted

Solution code:
def main():
    t,x = map(int,input().split())
    print(t/x)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
T,X=map(float,input().split())
print(T/X)

Submission status: Accepted

Solution code:
t,x = map(float,input().split())
print (float(t/x))

Submission status: Accepted

Solution code:
#Entrance Examination
x, t = map(int, input().split())
print(x/t)

Submission status: Accepted

Solution code:
t,x = map(int,input().split())
ans = t/x
print(ans)

Submission status: Accepted

Solution code:
data = list(map(int,input().split()))

print(data[0]/data[1])

Submission status: Accepted

Solution code:
n,m=map(int,input().split())
a=n/m

print(round(a,10))

Submission status: Accepted

Solution code:
T, X = map(int, input().split())
t = T / X
print(t)

Submission status: Accepted

Solution code:
x, t = list(map(int, input().split()))
print(x/t)

Submission status: Accepted

Solution code:
T , X = map(int , input().split())

print(T / X)

Submission status: Accepted

Solution code:
# 2019-11-12 13:20:54(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np 

def main():
    t, x = [int(i) for i in sys.stdin.readline().split()]
    print(t / x)




if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
t, x = map(int, input().split());

print(t/x)

Submission status: Accepted

Solution code:
t, x = map(float, raw_input().split())

print t/x

Submission status: Accepted

Solution code:
t,x = map(int, input().split())

ret = t/x

print(ret)

Submission status: Accepted

Solution code:
t,x= map(int,input().split())
print(t/x)

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()

def main():
    t,x=map(int,input().split())
    print(t/x)

main()

Submission status: Accepted

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


def solve(T: int, X: int):
    print(T/X)
    return


# Generated by 1.1.6 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()
    T = int(next(tokens))  # type: int
    X = int(next(tokens))  # type: int
    solve(T, X)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
T, X = map(float, input().split())

print(T/X)

Submission status: Accepted

Solution code:
# ABC 117: A – Entrance Examination
t, x = [int(s) for s in input().split()]
print('{:.4f}'.format(t / x))

Submission status: Accepted

Solution code:
t, x = [int(i) for i in input().split()]
print(t / x)

Submission status: Accepted

Solution code:
T,X = map(int,input().split())
print(T / X)

Submission status: Accepted

Solution code:
from sys import stdin
import bisect

t,x = [int(x) for x in stdin.readline().rstrip().split()]

print(t/x)

Submission status: Accepted

Solution code:
T,X=[int(x) for x in input().split()]

ans=T/X
print(ans)

Submission status: Accepted

Solution code:
T,X = map(int,input().split())
ans = T / X
print(ans)

Submission status: Accepted

Solution code:
t, x = map(int, input().split())
# = int(input())
# = input()
# = list(map(int, input().split()))

print(t/x)

Submission status: Accepted

Solution code:
t,x =map(int, input().split())

print(t/x)

Submission status: Accepted

Solution code:
t,x=map(int,input().split())

print(t/x)

Submission status: Accepted

Solution code:
T, X = [int(x) for x in input().split()]
print(T/X)

Submission status: Accepted

Solution code:
(sT, sX) = input().split()
T = int(sT)
X = int(sX)
print (T / X)

Submission status: Accepted

Solution code:
T,X = map(int,input().split())
print('{:.10f}'.format(float(T/X)))

Submission status: Accepted

Solution code:
x,t = map(int, input().split())
print('{:.5f}'.format(x / t))

Submission status: Accepted

Solution code:
t , x = map(int,input().split())

print(t / x)

Submission status: Accepted

Solution code:
T, X = [int(x) for x in input().split()]
print(T/X)

Submission status: Accepted

Solution code:
import decimal

tx = input()
tx = tx.split()
t = int(tx[0])
x = int(tx[1])
result = decimal.Decimal(t/x)
print(result)

Submission status: Accepted

Solution code:
from sys import stdin
T,X = list(map(int,stdin.readline().strip().split()))
print(T/X)

Submission status: Accepted

Solution code:
t, x = map(int, input().split())

print("{:.10f}".format(t/x))

Submission status: Accepted

Solution code:
T,X=list(map(int,input().split()))
print(T/X)

Submission status: Accepted

Solution code:
T,X=map(int,input().split())
print("%5f"%(T/X))

Submission status: Accepted

Solution code:
t,x = list(map(int,input().strip().split()))
ans = t / x
print(ans)

Submission status: Accepted

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

def main():
    T,X = map(int, input().split())
    print(T/X)

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    T,X = map(int, input().split())
    print(T/X)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
t,x = map(int,input().split())
print(t /x)

Submission status: Accepted

Solution code:
t,x =map(int,input().split())
print(t/x)

Submission status: Accepted

Solution code:
string = input().split(" ")
a = int(string[0])
b = int(string[1])
print(a/b)

Submission status: Accepted

Solution code:
t, x = (int(x) for x in input().split())
print(float(t/x))

Submission status: Accepted

Solution code:
T,X = map(int,input().split())
print(T*1/X)