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:
import sys
stdin = sys.stdin
 
sys.setrecursionlimit(10**5) 
 
def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x)-1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

t,x = li()
print(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().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 = list(map(int, input().split()))
    print(t/x)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n, k = list(map(int, input().split(" ")))
print(n/k)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

t, x = map(float, input().split())

print(t / x)

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

a,b = getNM()
print(float(a)/float(b))

Submission status: Accepted

Solution code:
import sys

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

print(T / X)

Submission status: Accepted

Solution code:
#t = int(raw_input())
a,b = map(int, raw_input().split())
print a / (b*1.0)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def func():
    pass


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import numpy as np
import sys
input = sys.stdin.readline
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

T,X = IL()
print(T/X)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding:utf-8

import sys
# from collections import Counter, defaultdict

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

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()


t, x = LI()

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, raw_input().split())
print float(T)/X

Submission status: Accepted

Solution code:
def  inpl(): return list(map(int, input().split()))

T, X = inpl()
print(T/X)

Submission status: Accepted

Solution code:
def read():
    return int(input())


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


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


T, X = readmap()

print(T / X)

Submission status: Accepted

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

Submission status: Accepted

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

print(T / x)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from statistics import mean, median,variance,stdev
import sys
import math
import fractions

def j(q):
    if q==1: print("YES")
    else:print("NO")
    exit(0)


def ct(x,y):
    if (x>y):print("")
    elif (x<y): print("")
    else: print("")

def ip():
    return int(input())

#n = ip()                              #入力整数1つ
t,x= (int(i) for i in input().split())      #入力整数横2つ
#x,y,z = (int(i) for i in input().split())    #入力整数横3つ
#n,m,x,y= (int(i) for i in input().split())  #入力整数横4つ
#a = [int(i) for i in input().split()]        #入力整数配列
#a = input()                                  #入力文字列
#a = input().split()                          #入力文字配列

#jの変数はしようできないので注意


print(t/x)

Submission status: Accepted

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

Submission status: Accepted

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

ans = T/X
print(ans)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

def main():
    """Function."""
    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:
def solve():
    [x,y] = [int(x) for x in input().split()]
    return x/y


def main():
    print(solve())


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
import sys
# import bisect
# import math
# import numpy as np


"""Template"""


class IP:
    """
    入力を取得するクラス
    """
    def __init__(self):
        self.input = sys.stdin.readline

    def I(self):
        """
        1文字の取得に使います
        :return: int
        """
        return int(self.input())

    def S(self):
        """
        1文字の取得(str
        :return: str
        """
        return self.input()

    def IL(self):
        """
        1行を空白で区切りリストにします(int
        :return: リスト
        """
        return list(map(int, self.input().split()))

    def SL(self):
        """
        1行の文字列を空白区切りでリストにします
        :return: リスト
        """
        return list(map(str, self.input().split()))

    def ILS(self, n):
        """
        1列丸々取得します(int
        :param n: 行数
        :return: リスト
        """
        return [int(self.input()) for _ in range(n)]

    def SLS(self, n):
        """
        1列丸々取得します（str
        :param n: 行数
        :return: リスト
        """
        return [self.input() for _ in range(n)]

    def SILS(self, n):
        """
        Some Int LineS
        横に複数、縦にも複数
        :param n: 行数
        :return: list
        """
        return [self.IL() for _ in range(n)]

    def SSLS(self, n):
        """
        Some String LineS
        :param n: 行数
        :return: list
        """
        return [self.SL() for _ in range(n)]


class Idea:
    def __init__(self):
        pass

    def HF(self, p):
        """
        Half enumeration
        半分全列挙です
        pの要素の和の組み合わせを作ります。
        ソート、重複削除行います
        :param p: list : 元となるリスト
        :return: list : 組み合わせられた和のリスト
        """
        return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))

    def Bfs2(self, a):
        """
        bit_full_search2
        bit全探索の改良版
        全探索させたら2進数のリストと10進数のリストを返す
        :return: list２つ : １個目 2進数(16桁)  2個目 10進数
        """
        # 参考
        # https://blog.rossywhite.com/2018/08/06/bit-search/
        # https://atcoder.jp/contests/abc105/submissions/4088632
        value = []
        for i in range(1 << len(a)):
            output = []

            for j in range(len(a)):
                if self.bit_o(i, j):
                    """右からj+1番目のiが1かどうか判定"""
                    # output.append(a[j])
                    output.append(a[j])
            value.append([format(i, 'b').zfill(16), sum(output)])

        value.sort(key=lambda x: x[1])
        bin = [value[k][0] for k in range(len(value))]
        val = [value[k][1] for k in range(len(value))]
        return bin, val

    def S(self, s, r=0, m=-1):
        """
        ソート関係行います。色々な設定あります。
        :param s: 元となるリスト
        :param r: reversするかどうか 0=False 1=True
        :param m: （2次元配列）何番目のインデックスのソートなのか
        :return: None
        """
        r = bool(r)
        if m == -1:
            s.sort(reverse=r)
        else:
            s.sort(reverse=r, key=lambda x: x[m])

    def bit_n(self, a, b):
        """
        bit探索で使います。0以上のときにTrue出します
        自然数だからn
        :param a: int
        :param b: int
        :return: bool
        """
        return bool((a >> b & 1) > 0)

    def bit_o(self, a, b):
        """
        bit探索で使います。1のときにTrue出すよ
        oneで1
        :param a: int
        :param b: int
        :return: bool
        """
        return bool(((a >> b) & 1) == 1)

    def ceil(self, x, y):
        """
        Round up
        小数点切り上げ割り算
        :param x: int
        :param y: int
        :return: int
        """
        return -(-x//y)

    def ave(self, a):
        """
        平均を求めます
        :param a: list
        :return: int
        """
        return sum(a) / len(a)


"""ここからメインコード"""


def main():
    # 1文字に省略
    r, e = range, enumerate
    ip = IP()
    id = Idea()

    """この下から書いてね"""
    t, x = ip.IL()
    print(t / x)


main()

Submission status: Accepted

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

print(a/b)

Submission status: Accepted

Solution code:
#import sys
#input = sys.stdin.readline
#template input
import bisect

def IT(): #整数1個
    return int(input())
def IL(): #整数複数
    return [int(_) for _ in input().split()]
def IS(): #文字列複数
    return [_ for _ in input().split()]
def ILS(n): #整数1つ　縦にズラーってなってるやつ
    return [int(input()) for _ in range(n)]
def SLS(n): #文字列　縦にズラーってなってるやつ
    return [input() for _ in range(n)]
def ILSS(n): #整数複数　縦にズラーってなってるやつ
    return [[int(_) for _ in input().split()] for j in range(n)]

#template technique
def bit_full_search(ss):
    n = len(ss)
    for i in range(1 << n):
        s = ""
        for j in range(n + 1):
            if ((1 & i >> j) == 1):
                s += ss[j]
        print(s)
def bit_full_search2(A):
    #https://blog.rossywhite.com/2018/08/06/bit-search/
    value = []
    for i in range(1 << len(A)):
        output = []

        for j in range(len(A)):
            if ((i >> j) & 1) == 1:
                #output.append(A[j])
                output.append(A[j])
        value.append([format(i, 'b').zfill(16), sum(output)])

    value.sort(key=lambda x:x[1])
    bin = [value[k][0] for k in range(len(value))]
    val = [value[k][1] for k in range(len(value))]
    return bin, val
def matching_bisect(list1_val, list2_val, n):
    #2分探索
    j = 0
    for i in range(len(list1_val)):
        j = bisect.bisect_left(list2_val, n - list1_val[i])
        if j < len(list2_val):
            if list1_val[i] + list2_val[j] == n:
                #ans = list2_bin[j] + list1_bin[i]
                break
    return j

"""ここからメインコード"""
def main():
    t, x = IL()
    print(t/x)



main()

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict
import math
def LI(): return list(map(int, input().split()))
def II(): return int(input())
def LS(): return input().split()
def S(): return input()
def IIR(n): return [II() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
mod = 1000000007

#A
t,x = LI()
print(t/x)
#B

#C

#D

#E

#F

#G

#H

#I

#J

#K

#L

#M

#N

#O

#P

#Q

#R

#S

#T

Submission status: Accepted

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

print(A/B)

Submission status: Accepted

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

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()]
print(t/x)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(200000)
input = sys.stdin.readline
n,m = map(int,input().split())
print(n/m)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

if max(L) < (sum(L) - max(L)):
    print('Yes')
else:
    print('No')

Submission status: Runtime Error

Solution code:
n=int(input())
L=list(map(int,input().split()))
L.sort()
ans=sum(L)-L[n-1]
if ans>L[n-1]:
    print('Yes')
else:
    print('No')

Submission status: Runtime Error

Solution code:
print("{:.4}".format(input() / input()))

Submission status: Runtime Error

Solution code:
#include <iostream>
using namespace std;
int main(void){
    // Your code here!
    double t,x;
    cin >> t >> x;
    cout << t/x << endl;
}

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N = int(inout())
L = input().split()
flag = 0

for i in range(N):
  L[i] = int(L[i])
  total += L[i]

for i in range(N):
  if L[i]*2 >= total:
    print("No")
    flag = 1
    break

if flag == 0:
  print("Yes")

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

print(T/X)

Submission status: Runtime Error

Solution code:
import sys 
N, M = map(int, input().split())
X = list(map(int, input().split()))

X = sorted(X)

anslis = []


if M <= N:
    print(0)
    sys.exit()


    
for i in range(M-1):
    ans = abs(X[i+1] - X[i])
    anslis.append(ans)
    ans = 0

anslis = sorted(anslis)

if N==1:
    print(sum(anslis))
else:
    print(sum(anslis[0:M-N]))

Submission status: Runtime Error

Solution code:
import sys 
N, M = map(int, input().split())
X = list(map(int, input().split()))

X = sorted(X)

anslis = []


if M <= N:
    print(0)
    sys.exit()


    
for i in range(M-1):
    ans = abs(X[i+1] - X[i])
    anslis.append(ans)
    ans = 0

anslis = sorted(anslis)

if N==1:
    print(sum(anslis))
else:
    print(sum(anslis[0:N+1]))

Submission status: Runtime Error

Solution code:
import sys 
N, M = map(int, input().split())
X = list(map(int, input().split()))

X = sorted(X)

anslis = []


if M <= N:
    print(0)
    sys.exit()


    
for i in range(M-1):
    ans = abs(X[i+1] - X[i])
    anslis.append(ans)
    ans = 0

anslis = sorted(anslis)

print(sum(anslis[0:N-1]))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
print(T / X)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
p = input()
li = p.split(' ').map(lambda x: float(x))
print(li[0]/li[1])

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
t,x=map(int,input().spllit());pirnt(t/x)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
n = int(input())
l = list(map(int,input().split()))
l.sort()
sum = 0
for i in range(n-1):
    sum += l[i]
if (sum <= l[n-1]):
    print("No")
else:
    print("Yes")

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
# input
T, X = int(input())

print(T / X)

Submission status: Runtime Error

Solution code:
# -*- coding: <encoding name> -*-
'''
T, X = int(input())
print(T / X)
'''
 T, X = map(int, input().split())
 print(T / X)

Submission status: Runtime Error

Solution code:
# -*- coding: <encoding name> -*-
'''
T, X = int(input())
print(T / X)
'''
 T, X = map(int(input()))
 print(T / X)

Submission status: Runtime Error

Solution code:
# -*- coding: <encoding name> -*-

T, X = int(input())
print(T / X)

Submission status: Runtime Error

Solution code:
# -*- coding: utf-8 -*-

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

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


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

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

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

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

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

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

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

T,X = inputIL()
pirnt(T/X)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N, M = map(int, input().split())
l = list(map(int, input().split()))

if M == 1:
    print(0)
else:
    l.sort()
    l_dist =[]

    for i in range(1, M):
        l_dist.append(abs(l[i]-l[i-1]))

    l_dist.sort()


    print(sum(l_dist[:len(l_dist)- (N-1)]))

Submission status: Runtime Error

Solution code:
x, y = int(input())
print(x/y)

Submission status: Runtime Error

Solution code:
x, y = int(input())
print(y/x)

Submission status: Runtime Error

Solution code:
n,m=map(int,input().split())
s=list(map(int,input().split()))

s.sort()
term=[]

for i in range(m-1):
    term.append(s[i+1]-s[i])

term.sort()

for i in range(n-1):
    del term[-1]

print(sum(term))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
# -*- coding: utf-8 -*-
N = int(input())
L = list(map(int, input().split()))
if max(L) > (sum(L)-max(L)):
    print("Yes")
else:
    print("No")

Submission status: Runtime Error

Solution code:
def nyu():
    N, M = map(int, input().split())
    X = list(map(int,input().split()))
    X.sort()
    return N,M,X


def kansu(N,M,X):

    x_abs = [X[m+1] -X[m] for m in range(M-1)]    
#    print(x_abs)
    cnt_n = N
    
    while cnt_n-1 > 0:
        x_abs[x_abs.index(max(x_abs))]  = -1
        cnt_n -= 1

    koma_max = 0
    sum = 0
    for m in range(M-1):
        if x_abs[m] != -1:
            koma_max += x_abs[m]

    print(koma_max)

 


N,M,X = nyu()
#print(X)

if M == 1:
    print(0)
else:
    kansu(N,M,X)

#print(S)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
from bisect import bisect_left, insort_left, bisect_right

_NUMINT_ALL = list(range(10))


def main():
    ans = solve()
    if ans is not None:
        print(ans)


def solve():
    N, M = iip(False)
    X = iip()
    X.sort()

    A = [X[i+1] - X[i] for i in range(len(X)-1)]
    A.sort()

    return sum(A[0:min(0, -N+1)])


#####################################################ライブラリ集ここから

def iip(listed=True, num_only=True):  # 数字のinputをlistで受け取る
    if num_only:
        ret = [int(i) for i in input().split()]
    else:
        ret = [int(i) if i in _NUMINT_ALL else i for i in input().split()]

    if len(ret) == 1 and not listed:
        return ret[0]
    return ret


def saidai_kouyakusuu(A):  # 最大公約数
    l = len(A)
    while True:
        m = min(A)
        mx = max(A)
        if m == mx:
            return m

        for i in range(l):
            if A[i] % m == 0:
                A[i] = m
            else:
                A[i] %= m


def sort_tuples(l, index):  # タプルのリストを特定のインデックスでソートする
    if isinstance(l, list):
        l.sort(key=lambda x: x[index])
        return l
    else:
        l = list(l)
        return sorted(l, key=lambda x: x[index])


def count_elements(l):  # リストの中身の個数を種類分けして辞書で返す
    d = {}
    for i in l:
        if i in d:
            d[i] += 1
        else:
            d[i] = 1
    return d


def safeget(l, index, default="exception"):  # listの中身を取り出す時、listからはみ出たり
    if index >= len(l):                      # マイナスインデックスになったりするのを防ぐ
        if default == "exception":
            raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
        else:
            return default
    elif index < 0:
        if default == "exception":
            raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
        else:
            return default
    else:
        return l[index]


def iipt(l, listed=False, num_only=True):  # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
    ret = []
    for i in range(l):
        ret.append(iip(listed=listed, num_only=num_only))
    return ret


def sortstr(s):  # 文字列をソートする
    return "".join(sorted(s))


def iip_ord(startcode="a"):  # 文字列を数字の列に変換する(数字と文字は1:1対応)
    if isinstance(startcode, str):
        startcode = ord(startcode)
    return [ord(i) - startcode for i in input()]


def YesNo(s):  # TrueFalseや1, 0をYesNoに変換する
    if s:
        print("Yes")
    else:
        print("No")


def fprint(s):  # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
    for i in s:
        print(i)


def bitall(N):  # ビット全探索用のインデックスを出力
    ret = []
    for i in range(2 ** N):
        a = []
        for j in range(N):
            a.append(i % 2)
            i //= 2
        ret.append(a)
    return ret

def split_print_space(s):  # リストの中身をスペース区切りで出力する
    print(" ".join([str(i) for i in s]))


def split_print_enter(s):  # リストの中身を改行区切りで出力する
    print("\n".join([str(i) for i in s]))


def soinsuu_bunkai(n):  # 素因数分解
    ret = []
    for i in range(2, int(n ** 0.5) + 1):
        while n % i == 0:
            n //= i
            ret.append(i)
        if i > n:
            break
    if n != 1:
        ret.append(n)
    return ret


def conbination(n, r, mod, test=False):  # nCrをmodを使って計算する
    if n <= 0:
        return 0
    if r == 0:
        return 1
    if r < 0:
        return 0
    if r == 1:
        return n
    ret = 1
    for i in range(n - r + 1, n + 1):
        ret *= i
        ret = ret % mod

    bunbo = 1
    for i in range(1, r + 1):
        bunbo *= i
        bunbo = bunbo % mod

    ret = (ret * inv(bunbo, mod)) % mod
    if test:
        # print(f"{n}C{r} = {ret}")
        pass
    return ret


def inv(n, mod):  #  modnにおける逆元を計算
    return power(n, mod - 2)


def power(n, p, mod_=mod):  # 繰り返し二乗法でn**p % modを計算
    if p == 0:
        return 1
    if p % 2 == 0:
        return (power(n, p // 2, mod_) ** 2) % mod_
    if p % 2 == 1:
        return (n * power(n, p - 1, mod_)) % mod_


if __name__ == "__main__":
    main()

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
8 3

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
n = int(input())
ls = [int(i) for i in input().split()]

if max(ls) < sum(ls) - max(ls):
    print("Yes")
else:
    print("No")

Submission status: Runtime Error

Solution code:
n = int(input())
a = [int(e) for e in input().split()]

ans ='Yes' if max(a)>= sum([e for e in a])-max(a) else 'No'
print(ans)

Submission status: Runtime Error

Solution code:
i=input().split()
print(i[0]/i[1])

Submission status: Runtime Error

Solution code:
t=int(input())
x=int(input())
print(t/x)

Submission status: Runtime Error

Solution code:
t=float(input())
x=float(input())
print(t/x)

Submission status: Runtime Error

Solution code:
N=int(input())
A=list(map(int,input().split()))
L=sorted(A,reverse=True)
if L[0]<sum(L[1:]):
  print("Yes")
else:
  print("No")

Submission status: Runtime Error

Solution code:
input()
L=list(map(int,input().split()))
print("Yes" if sum(L)>2*max(L) else "No")

Submission status: Runtime Error

Solution code:
input()
l=list(map(int,input().split()))
print('Yes' if sum(l) >2*max(l) else 'No')

Submission status: Runtime Error

Solution code:
input()
l=list(map(int,input().split()))
print('Yes' if 2*max(l)< sum(l) else 'No')

Submission status: Runtime Error

Solution code:
input()
l=list(map(int,input().split()))
print('Yes' if max(l)*2< sum(l) else 'No')

Submission status: Runtime Error

Solution code:
int(input())
l=list(map(int,input().split()))
print('Yes' if max(l)*2< sum(l) else 'No')

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

print(t / x)

Submission status: Runtime Error

Solution code:
N, M = map(int, input().split()) 
X_lines = str(input())
X_lines = X_lines.split()
X = []
for i in range(len(X_lines)):
    X.append(int(X_lines[i]))

X_arrays = X
X_arrays.sort()      
X_max = X_arrays[len(X_arrays)-1]
X_min = X_arrays[0]
X_kyokai = [X_min]
if not N == 1:
    for i in range(N-1):
        X_kyokai.append((1/N)*((i+1)*X_max +(N-i-1)*X_min))
X_kyokai.append(X_max)

X_all_lines = [[]]
if not len(X_kyokai)-2 == 0:
    for i in range(len(X_kyokai)-2):
        X_all_lines.append([])
for i in range(len(X_kyokai)-1):
    for j in range(M):
        if X_kyokai[i] <= X_arrays[j] and X_arrays[j] < X_kyokai[i+1]:
            X_all_lines[i].append(X_arrays[j])
X_all_lines[len(X_kyokai)-2].append(X_max) 

sum_dif = 0
count = 0
for i in range(len(X_all_lines)):
    if len(X_all_lines[i]) == 0:
        count = count + 1
    else:
        i_max = X_all_lines[i][len(X_all_lines[i])-1]
        i_min = X_all_lines[i][0]
        dif = i_max - i_min
        sum_dif = sum_dif + dif

diff_arrays = []

for i in range(N):
    if len(X_all_lines[i]) >= 2:
        for j in range(len(X_all_lines[i])-1):
            diff_arrays.append(X_all_lines[i][j+1]-X_all_lines[i][j])
            
diff_arrays.sort()
diff_arrays.reverse()

if count >= 1:
    for i in range(count):
        sum_dif = sum_dif - diff_arrays[i]

print(str(sum_dif))

Submission status: Runtime Error

Solution code:
n, m = [int(el) for el in input().split(' ')]
X = [int(el) for el in input().split(' ')]
X = sorted(X)

if m <= n:
	print(0)
else:
	D = [0]*(m-1)
	for i in range(0, m-1):
		D[i] = X[i+1] - X[i]
	D = sorted(D)
	if n == 1:
		print(sum(D))
	else:
		print(sum(D[:-n+1]))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N,M = map(int,input().split())
X = list(map(int,input().split()))
X.sort()
ans = X[-1] - X[0]
d = []
for i in range(M-1):
    d.append(X[i+1]-X[i])
d.sort()
n = min(N-1,M-1)
for i in range(n):
    ans -= d[-i]
print(ans)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N = int(input())
L = sorted([int(_) for _ in input().split()])
if L[N - 1] < sum(L[:N - 1]):
    print('Yes')
else:
    print('No')

Submission status: Runtime Error

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

L_max = max(L)

print(L_max)

L_Down =sorted(L,reverse=True)

print(L_Down)

L_Down_Re = L_Down[1:len(L_Down)]

print(L_Down_Re)

L_Down_Re_Sum =  sum(L_Down_Re)

print(L_Down_Re_Sum)

if L_max <= L_Down_Re_Sum:
    print("Yes")
else:
    print("No")

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
n, m = map(int,input().split())
X = sorted(map(int,input().split()))
l = sorted([X[i+1] - X[i] for i in range(m-1)])
print(sum(l[:-n+1]))

Submission status: Runtime Error

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

AREA = x*y

AREA2 =(AREA/2) 


print(AREA2)

Submission status: Runtime Error

Solution code:
print(int(input())/int(input()))

Submission status: Runtime Error

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