input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
def m():
n = int(eval(input()))
a = list(map(int, input().split()))
def comb(x, y):
c = 1
p = 1
for i in range(y, 0, -1):
c = c * i
for i in range(x, x - y, -1):
p = p * i
return p / c
a.sort(reverse=True)
tmp = 0
ans = ""
for i, v in enumerate(a):
for k in range(i+1, n):
m = comb(v, a[k])
if tmp < m:
tmp = m
ans = "{0} {1}".format(v, a[k])
return ans
print((m()))
| def someone_ans():
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
x_max = a[n - 1]
center = a[0]
for i in range(1, n - 1):
if abs(center - x_max / 2) > abs(a[i] - x_max / 2):
center = a[i]
return "{0} {1}".format(x_max, center)
print((someone_ans()))
| p03380 |
import math
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
def comb(n, r):
return math.factorial(n) // math.factorial(n - r)
maxi = 0
i = n-1
key = a[i] // 2
ok = n
ng = -1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if key <= a[mid]: ok = mid
else: ng = mid
if ok < i:
if comb(a[i], a[ok]) > maxi:
maxi = comb(a[i], a[ok])
ans = [a[i], a[ok]]
if ng >= 0:
if comb(a[i], a[ng]) > maxi:
maxi = comb(a[i], a[ng])
ans = [a[i], a[ng]]
print(("{} {}". format(ans[0], ans[1]))) | import math
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
def comb(n, r):
return math.factorial(n) // math.factorial(n - r)
maxi = 0
i = -1
key = a[i] // 2
for j in range(n):
if a[j] > key:
break
# print(j, n-1)
# print(j, key, a)
if abs(a[j-1] - key) >= abs(a[j] - key) and j < n-1:
ans = [a[i], a[j]]
else:
ans = [a[i], a[j-1]]
# ok = n
# ng = -1
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if key <= a[mid]: ok = mid
# else: ng = mid
# if ok < i:
# if comb(a[i], a[ok]) > maxi:
# maxi = comb(a[i], a[ok])
# ans = [a[i], a[ok]]
# if ng >= 0:
# if comb(a[i], a[ng]) > maxi:
# maxi = comb(a[i], a[ng])
# ans = [a[i], a[ng]]
print(("{} {}". format(ans[0], ans[1]))) | p03380 |
n=int(eval(input()))
a=list(map(int,input().split()))
a.sort()
mx=0
alarge=a[n-1]
if a[0]>=alarge/2:
asmall=0
comb=1
for i in range(1,asmall+1): comb*=(alarge-i+1)/i
else:
j=0
while a[j]<alarge/2:
j+=1
if alarge<=a[j-1]+a[j]:
asmall=a[j-1]
else:
asmall=a[j]
comb=1
for i in range(1,asmall+1): comb*=(alarge-i+1)/i
print(("{} {}".format(alarge,asmall)))
| n=int(eval(input()))
a=list(map(int,input().split()))
a.sort()
alarge=a[n-1]
if a[0]>=alarge/2:
asmall=a[0]
else:
j=0
while a[j]<alarge/2:
j+=1
if alarge<=a[j-1]+a[j]:
asmall=a[j-1]
else:
asmall=a[j]
print(("{} {}".format(alarge,asmall))) | p03380 |
import math
n=eval(input())
a=list(map(int, input().split()))
a.sort()
a.reverse()
def comb(N,R):
return math.factorial(N)/( math.factorial(N-R)*math.factorial(R) )
c=a[0]
b=[0 for i in range(n)]
for i in range(1,n):
b[i]=abs(a[i]-c/2)
min_b=min(b[1:])
d=[]
for i in range(1,n):
if b[i]==min_b:
d.append( (comb(c,a[i]),a[i]) )
print(c,sorted(d, key=lambda x:x[0],reverse=True)[0][1])
| import math
n=eval(input())
a=list(map(int, input().split()))
a.sort()
a.reverse()
c=a[0]
b=[0 for i in range(n)]
for i in range(1,n):
b[i]=abs(a[i]-c/2)
min_b=min(b[1:])
d=[]
for i in range(1,n):
if b[i]==min_b:
d.append(a[i])
d.sort()
d.reverse()
print(c,d[0])
| p03380 |
#import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left, bisect_right #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')
N = int(input())
A = list(map(int, input().split()))
A.sort()
maxA = max(A)
fact = [1]
for i in range(1, maxA+10):
fact.append(fact[-1] * i % MOD)
def rev(x):
return pow(x, MOD-2, MOD)
def cmb(i, k):
if(i < k): return 0
return fact[i] * rev(fact[k]) * rev(fact[i-k]) % MOD
if N == 2:
print(A[1], A[0])
exit()
# print(' A', A)
maxA = max(A)
ind = bisect_left(A, maxA//2)
res = 0
ress = A[ind]
st = max(0, ind-2)
en = min(N, ind+2)
# print(' A[st], A[en]', A[st], A[en-1])
for i in range(st, en):
# print(' i', i)
val = cmb(maxA, A[i])
if res<val:
res = val
ress = A[i]
print(maxA, ress)
| # import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
enu = enumerate
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
N = int(input())
A = list(map(int, input().split()))
fact = [1]
for i in range(1, N + 10):
fact.append(fact[-1] * i % MOD)
def rev(x):
return pow(x, MOD - 2, MOD)
def cmb(i, k):
if i < k:
return 0
return fact[i] * rev(fact[k]) * rev(fact[i - k]) % MOD
A.sort()
if N == 2:
print(A[1], A[0])
exit()
mv = A[-1]
vm = mv // 2
bli = bisect_left(A, vm)
if bli == N - 1:
print(mv, A[bli - 1])
elif bli == 0:
print(mv, A[bli])
else:
if vm - A[bli - 1] < A[bli] - vm:
print(mv, A[bli - 1])
else:
print(mv, A[bli])
| p03380 |
dp_t = dict()
dp_p = dict()
def main():
n = int(eval(input()))
a = [int(s) for s in input().split(" ")]
a.sort(reverse=True)
max_comb = (0, 0)
max_num = 0
for i in range(n - 1):
for j in range(i + 1, n):
c = comb(a[i], a[j])
if max_num < c:
max_num = c
max_comb = (a[i], a[j])
print(("%d %d" % max_comb))
def comb(n, r):
t = 1
if n in dp_t:
t = dp_t[n]
else:
t = compute_kai(n)
p = 1
if (n, r) in dp_p:
p = dp_p[(n, r)]
else:
pr = 1
if r in dp_t:
pr = dp_t[r]
else:
pr = compute_kai(r)
if n - r in dp_t:
p = dp_t[n - r]
else:
p = compute_kai(n -r)
p *= pr
dp_p[(n, r)] = p
return t // p
def compute_kai(n):
if n in dp_t:
return dp_t[n]
else:
t = 1
for i in range(n):
t *= (n - i)
dp_t[n] = t
return t
if __name__ == '__main__':
main()
| dp_t = dict()
dp_p = dict()
def main():
n = int(eval(input()))
a = [int(s) for s in input().split(" ")]
a.sort(reverse=True)
t = a[0] // 2
p = a[-1]
if n == 2:
print(("%d %d" % (a[0], a[1])))
return
i = 1
while a[i] > t:
i += 1
if i >= n:
i -= 1
break
if abs(a[i - 1] - t) > abs(a[i] - t):
p = a[i]
else:
p = a[i - 1]
print(("%d %d" % (a[0], p)))
def main1():
n = int(eval(input()))
a = [int(s) for s in input().split(" ")]
a.sort(reverse=True)
max_comb = (0, 0)
max_num = 0
for i in range(n - 1):
for j in range(i + 1, n):
c = comb(a[i], a[j])
if max_num < c:
max_num = c
max_comb = (a[i], a[j])
print(("%d %d" % max_comb))
def comb(n, r):
t = 1
if n in dp_t:
t = dp_t[n]
else:
t = compute_kai(n)
p = 1
if (n, r) in dp_p:
p = dp_p[(n, r)]
else:
pr = 1
if r in dp_t:
pr = dp_t[r]
else:
pr = compute_kai(r)
if n - r in dp_t:
p = dp_t[n - r]
else:
p = compute_kai(n -r)
p *= pr
dp_p[(n, r)] = p
return t // p
def compute_kai(n):
if n in dp_t:
return dp_t[n]
else:
t = 1
for i in range(n):
t *= (n - i)
dp_t[n] = t
return t
if __name__ == '__main__':
main()
| p03380 |
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
M = A[-1]
a = M // 2
for i in range(N-1):
if A[i] <= a and A[i+1] >= a:
if (M-A[i])*A[i] >= (M-A[i+1])*A[i+1]:
ans = [M, A[i]]
else:
ans = [M, A[i+1]]
ans = [str(b) for b in ans]
ans = ' '.join(ans)
print(ans)
| n = int(input())
a = list(map(int, input().split()))
a.sort()
M = a[-1]
m = a[0]
C = -1
for i in range(n):
c = a[i]*(M-a[i])
if C < c:
C = c
m = a[i]
else:
break
print(M, m, sep=' ')
| p03380 |
n=int(input())
A=list(map(int,input().split()))
X=sorted(A)
maxim=X[n-1]
if maxim%2==0:
half=maxim//2
target=half
i=0
while True:
if (target+i in X)==1 and target+i != maxim:
print(maxim,end=" ")
print(target+i)
break
elif (target-i in X)==1 and target-i != maxim:
print(maxim,end=" ")
print(target-i)
break
else:
i=i+1
# print(i)
elif maxim%2==1:
half=maxim//2
target=half
i=0
while True:
if (target+i+1 in X)==1 and target+i+1 != maxim:
print(maxim,end=" ")
print(target+i+1)
break
elif (target-i in X)==1 and target-i != maxim:
print(maxim,end=" ")
print(target-i)
break
else:
i=i+1
# print(i)
| n=int(input())
A=list(map(int,input().split()))
maximal=max(A)
print(maximal,end=" ")
B=list(map(lambda x:abs(x - maximal/2),A))
minimam=B.index(min(B))
if A[minimam]==maximal:
print("0")
else:
print(A[minimam])
| p03380 |
from operator import mul
from functools import reduce
def cmb(n, r):
r = min(n - r, r)
if r == 0:
return 1
numer = reduce(mul, list(range(n, n - r, -1)))
denom = reduce(mul, list(range(1, r + 1)))
return numer // denom
n = int(eval(input()))
a = list(map(int, input().split()))
ai = max(a)
ans_val = 0
for aj in set(a):
if cmb(ai, aj) > ans_val:
ans = [ai, aj]
ans_val = cmb(ai, aj)
print((' '.join(map(str, ans))))
| from operator import mul
from functools import reduce
def cmb(n, r):
r = min(n - r, r)
if r == 0:
return 1
numer = reduce(mul, list(range(n, n - r, -1)))
denom = reduce(mul, list(range(1, r + 1)))
return numer // denom
n = int(eval(input()))
a = list(map(int, input().split()))
ai = max(a)
diff = float("inf")
for aj in set(a):
if abs(ai / 2 - aj) < diff:
ans = [ai, aj]
diff = abs(ai / 2 - aj)
print((' '.join(map(str, ans))))
| p03380 |
from operator import mul
from functools import reduce
def cmb(n, r):
r = min(n - r, r)
if r == 0:
return 1
numer = reduce(mul, list(range(n, n - r, -1)))
denom = reduce(mul, list(range(1, r + 1)))
return numer // denom
n = int(eval(input()))
a = list(map(int, input().split()))
ai = max(a)
diff = float("inf")
for aj in set(a):
if abs(ai / 2 - aj) < diff:
ans = [ai, aj]
diff = abs(ai / 2 - aj)
print((' '.join(map(str, ans))))
| n = int(eval(input()))
a = list(map(int, input().split()))
ai = max(a)
diff = float("inf")
for aj in set(a):
if abs(ai / 2 - aj) < diff:
ans = [ai, aj]
diff = abs(ai / 2 - aj)
print((' '.join(map(str, ans))))
| p03380 |
import math
n=int(eval(input()))
a=list(map(int,input().split()))
max_num=max(a)
middle_num=math.ceil(max_num/2)
middle_num_up=middle_num
middle_num_down=middle_num
if n>2:
for i in range(n):
if middle_num_up in a:
ans=middle_num_up
break
if middle_num_down in a:
ans=middle_num_down
else:
middle_num_up+=1
middle_num_down-=1
else:
ans=min(a)
print(("{} {}".format(max_num,ans))) | n=int(eval(input()))
a=list(map(int,input().split()))
a=sorted(a)
max_num=max(a)
middle_num=max_num/2
num=0
for i in range(n):
if a[i]> middle_num:
num=i
break
if middle_num-a[num-1]<=-middle_num+a[num]:
print(("{} {}".format(max_num,a[num-1])))
else:
print(("{} {}".format(max_num,a[num]))) | p03380 |
from math import factorial as f
def nCr(n, r):
return f(n) // (f(r) * f(n-r))
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
max_comb = 0
r = 0
for i in range(n-1):
tmp = nCr(a[-1], a[i])
if tmp > max_comb:
max_comb = tmp
r = a[i]
ans = "{} {}".format(a[-1], r)
print(ans)
if __name__ == "__main__":
main()
| def main():
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
r = 0
c = a[-1] / 2
for i in range(n-1):
if abs(c-r) > abs(c-a[i]):
r = a[i]
ans = "{} {}".format(a[-1], r)
print(ans)
if __name__ == "__main__":
main()
| p03380 |
from math import factorial
from bisect import bisect
def C(n, r):
return factorial(n) // factorial(r) // factorial(n-r)
n=int(eval(input()))
a=sorted(map(int, input().split()))
z = a.pop()
r = bisect(a, z//2)
l = r - 1
if l < 0:
print(("%d %d" % (z, a[r])))
elif r >= len(a):
print(("%d %d" % (z, a[l])))
elif C(z, a[r]) > C(z, a[l]):
print(("%d %d" % (z, a[r])))
else:
print(("%d %d" % (z, a[l])))
| n=int(eval(input()))
a=list(map(int, input().split()))
b=max(a)
_,c=min([(abs(b/2-x), x) for x in a])
print(("%d %d" % (b, c)))
| p03380 |
def main():
n = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
m = A.pop()
B = [[a, abs(a - (m / 2))] for a in A]
B.sort(key = lambda x: x[1])
print(('{} {}'. format(m, B[0][0])))
if __name__ == '__main__':
main()
| def main():
n = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
ans = [str((m := A.pop())), ]
m /= 2
A = [(a, abs(a - m)) for a in A]
A.sort(key = lambda x: x[1])
ans.append(str(A[0][0]))
print((' '.join(ans)))
if __name__ == '__main__':
main()
| p03380 |
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush
from decimal import *
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
##### 累乗 #####
# pow(x, y, z) -> x**y % z
##### 割り算の切り上げ #####
# tmp = -(-4 // 3)
##### dict の for文 #####
# for k, v in d.items():
# print(k, v)
##### 進数の変換 #####
# bin_str = bin(i)[2:]
# oct_str = oct(i)
# hex_str = hex(i)
def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
N = inputInt()
A = inputList()
A.sort()
AA = A[::-1]
ans1 = AA[0]
ans2 = AA[-1]
mmm = combination(ans1, ans2)
for i,val in enumerate(AA):
ans11 = val
tmp = val // 2
ind = bisect_left(A, tmp)
tmp = A[ind]
if tmp == val:
continue
ans = combination(val, tmp)
#print("{} {} {}".format(ans11, tmp, ans))
if mmm < ans:
mmm = ans
ans1 = ans11
ans2 = tmp
print(("{} {}".format(ans1,ans2)))
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索のリバース
def bisect_left_reverse(a, x):
if a[0] <= x:
return 0
if x < a[-1]:
return len(a)
# 二分探索
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] <= x:
ok = mid
else:
ng = mid
return ok
def bisect_right_reverse(a, x):
if a[0] < x:
return 0
if x <= a[-1]:
return len(a)
# 二分探索
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] < x:
ok = mid
else:
ng = mid
return ok
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索
# 存在しない場合: None 存在する場合: その値
def binary_search(list, item):
low = 0
high = len(list) - 1
while low <= high:
mid = (low + high) //2
guess = list[mid]
if guess == item:
return mid
if guess > item:
high = mid -1
else:
low = mid + 1
return None
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# N 個のボールを K グループに分ける場合のパターン数
def sunuke(N, K, mod=10**9+7):
if N < K or K-1 < 0:
return 0
else:
return combination(N-1, K-1, mod)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
# comb = Combination(n+r-1, mod)
# return comb(n+r-1, r)
return combination(n+r-1, r, mod)
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# dfs のサンプル
def dfs(graph,parent,counter,edge):
stk = []
stk.append(edge)
while len(stk) > 0:
p = stk.pop()
for e in graph[p]:
if parent[p] == e:
continue
else:
parent[e] = p
counter[e] += counter[p]
stk.append(e)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush
from decimal import *
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
##### 累乗 #####
# pow(x, y, z) -> x**y % z
##### 割り算の切り上げ #####
# tmp = -(-4 // 3)
##### dict の for文 #####
# for k, v in d.items():
# print(k, v)
##### 進数の変換 #####
# bin_str = bin(i)[2:]
# oct_str = oct(i)
# hex_str = hex(i)
def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
N = inputInt()
A = inputList()
A.sort()
AA = A[::-1]
ans1 = AA[0]
ans2 = AA[-1]
ki = ans1 / 2
for i in AA:
if i == ans1:
continue
if abs(i-ki) < abs(ans2-ki):
ans2 = i
print(("{} {}".format(ans1,ans2)))
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索のリバース
def bisect_left_reverse(a, x):
if a[0] <= x:
return 0
if x < a[-1]:
return len(a)
# 二分探索
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] <= x:
ok = mid
else:
ng = mid
return ok
def bisect_right_reverse(a, x):
if a[0] < x:
return 0
if x <= a[-1]:
return len(a)
# 二分探索
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] < x:
ok = mid
else:
ng = mid
return ok
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索
# 存在しない場合: None 存在する場合: その値
def binary_search(list, item):
low = 0
high = len(list) - 1
while low <= high:
mid = (low + high) //2
guess = list[mid]
if guess == item:
return mid
if guess > item:
high = mid -1
else:
low = mid + 1
return None
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# N 個のボールを K グループに分ける場合のパターン数
def sunuke(N, K, mod=10**9+7):
if N < K or K-1 < 0:
return 0
else:
return combination(N-1, K-1, mod)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
# comb = Combination(n+r-1, mod)
# return comb(n+r-1, r)
return combination(n+r-1, r, mod)
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# dfs のサンプル
def dfs(graph,parent,counter,edge):
stk = []
stk.append(edge)
while len(stk) > 0:
p = stk.pop()
for e in graph[p]:
if parent[p] == e:
continue
else:
parent[e] = p
counter[e] += counter[p]
stk.append(e)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
main()
| p03380 |
def d_binomial_coefficients():
from bisect import bisect_left
N = int(eval(input()))
A = sorted([int(i) for i in input().split()]) # ソートしておく
n = A[-1] # comb(n, r) の n をこの値以外にする理由はない
r = min(A[:-1], key=lambda x: abs(n / 2 - x))
return '{0} {1}'.format(n, r)
print((d_binomial_coefficients())) | def d_binomial_coefficients():
N = int(eval(input()))
A = sorted([int(i) for i in input().split()]) # ソートしておく
n = A[-1] # n を大きく、r を n/2 に近づけると comb(n, r) は大きい
r = min(A[:-1], key=lambda x: abs(n / 2 - x))
return f'{n} {r}'
print((d_binomial_coefficients())) | p03380 |
import math
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort(reverse=True)
ans = 0
a_i = a[0]
a_j = a[1]
for idx in range(1, n):
if ans < combinations_count(a_i, a[idx]):
ans = combinations_count(a_i, a[idx])
a_j = a[idx]
print(("%d %d" % (a_i, a_j)))
| n = int(eval(input()))
a = list(map(int, input().split()))
a.sort(reverse=True)
max_a = max(a)
a.remove(max_a)
da = [abs(ai - max_a / 2) for ai in a]
med_i = da.index(min(da))
print(("%d %d" % (max_a, a[med_i])))
| p03380 |
def cmb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
n = int(eval(input()))
A = list(map(int, input().split()))
AS = sorted(list(set(A)))
n = AS[-1]
r = AS[0]
combM = cmb(n, r)
for i in range(1,len(AS)):
tempr = AS[i]
tempc = cmb(n, tempr)
if combM >= tempc:
break
r = tempr
combM = tempc
print((str(n) + ' ' + str(r)))
| n = int(eval(input()))
A = list(map(int, input().split()))
AS = sorted(list(set(A)))
n = AS[-1]
checkAS = len(AS)-1
nHalf = n/2
min = 10**10
for i in range(checkAS):
temp = abs(AS[i]-nHalf)
if min > temp:
r = AS[i]
min = temp
print((str(n) + ' ' + str(r))) | p03380 |
def isok(m):
p0 = 0
p1 = 1
p2 = 1
while p0 < N:
# l0>=m ??¨???????????????p1????±???????
if p1 <= p0: p1 = p0 + 1
while d[p1] - d[p0] < m and p1 - p0 < N:
p1 += 1
if d[p1] - d[p0] < m:
p0 += 1
continue
l0 = d[p1] - d[p0]
# l1>=l0??¨???????????????p2????±???????
if p2 <= p1: p2 = p1 + 1
while d[p2] - d[p1] < m and p2 - p0 < N:
p2 += 1
if d[p2] - d[p1] < m:
p0 += 1
continue
l1 = d[p2] - d[p1]
if L - l0 - l1 >= l1:
return True
p0 += 1
return False
N = int(eval(input()))
A = [0] * N
L = 0
for i in range(N):
A[i] = int(eval(input()))
L += A[i]
d = [0] * (2*N)
for i in range(1, 2*N):
d[i] = d[i-1] + A[(i-1)%N]
left = 1
right = L // 3
ans = 0
while left <= right:
m = (left + right) // 2
if isok(m):
ans = m
left = m + 1
else:
right = m - 1
print(ans) | def d(p, q):
return pos[p] - pos[q]
def solve():
p0, p1, p2 = 0, 0, 0
best = 0
while p0 < N:
# p1????±???????
if p1 <= p0: p1 = p0 + 1
while d(p1, p0) <= best and p1 - p0 < N:
p1 += 1
if d(p1, p0) <= best:
p0 += 1
continue
# p2????±???????
while d(p2, p1) > d(p1, p0) and p2 > p1:
p2 -= 1
if p2 <= p1: p2 = p1 + 1
while d(p2,p1) < d(p1, p0) and p2 - p0 < N:
p2 += 1
if d(p2, p1) < d(p1, p0):
p0 += 1
continue
# check
if L - d(p2, p0) >= d(p1, p0):
best = d(p1, p0)
if best >= L//3:
return best
else:
p0 += 1
return best
N = int(eval(input()))
A = [0] * N
L = 0
for i in range(N):
A[i] = int(eval(input()))
L += A[i]
pos = [0] * (2*N)
for i in range(1, 2*N):
pos[i] = pos[i-1] + A[(i-1)%N]
print((solve())) | p00523 |
# def makelist(n, m):
# return [[0 for i in range(m)] for j in range(n)]
# n = int(input())
# a, b = map(int, input().split())
# s = input()
N, T = list(map(int, input().split()))
A = list(map(int, input().split()))
diff = [0]*N
mini = A[0]
for i in range(1, N):
now = A[i]
if now <= mini:
mini = now
else:
diff[i] = now - mini
sa = max(diff)
ans = 0
mini = A[0]
l = 1
r = 0
for i in range(1, N):
now = A[i]
if mini == now:
l += 1
elif now < mini:
if r > 0:
ans += min(l, r)
r = 0
mini = now
l = 1
else: # now > mini
if now - mini == sa:
r += 1
if r > 0:
ans += min(l, r)
print(ans)
| N, T = list(map(int, input().split()))
A = list(map(int, input().split()))
diff = -1
mini = A[0]
cnt = 0
ans = 0
for i in range(1, N):
now = A[i]
if mini > now:
mini = now
else:
if now - mini == diff:
cnt += 1
elif now - mini > diff:
diff = now - mini
ans = max(ans, cnt)
cnt = 1
ans = max(ans, cnt)
print(ans)
| p03948 |
N, T = list(map(int, input().split()))
a = [int(i) for i in input().split()]
d = [max(a[i:]) - a[i] for i in range(N-1)]
ans = d.count(max(d))
print(ans) | N, T = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = [a[0]]
m = b[0]
for i in range(1,N):
if m > a[i]:
m = a[i]
b.append(m)
c = [a[i] - b[i] for i in range(N)]
print((c.count(max(c)))) | p03948 |
N,T = list(map(int,input().split()))
A = list(map(int,input().split()))
h = []
B = [0]*N
for i in range(N):
h.append(A[i])
h = [min(h)]
B[i] = h[0]
j = []
C = [0]*N
for i in range(N-1,-1,-1):
j.append(A[i])
j = [max(j)]
C[i] = j[0]
B = B[:-1]
C = C[1:]
D = list([C[x]-B[x] for x in range(N-1)])
t = max(D)
s = 0
D.append(0)
for i in range(N-1):
if D[i] == t and D[i] > D[i+1]:
s += 1
print(s)
| N,T = list(map(int,input().split()))
A = list(map(int,input().split()))
B = [0]*N
C = [0]*N
h = A[0]
B[0] = h
for i in range(1,N):
h = min(A[i],h)
B[i] = h
h = A[-1]
C[-1] = h
for i in range(N-2,-1,-1):
h = max(A[i],h)
C[i] = h
B = B[:-1]
C = C[1:]
D = list([C[x]-B[x] for x in range(N-1)])
t = max(D)
s = 0
D.append(0)
for i in range(N-1):
if D[i] == t and D[i] > D[i+1]:
s += 1
print(s)
| p03948 |
N, T = list(map(int, input().split()))
A_n = list(map(int, input().split()))
max_profit = A_n[1] - A_n[0]
min_element = min(A_n[0], A_n[1])
for i in range(1, len(A_n)):
if A_n[i] - min_element > max_profit:
max_profit = A_n[i] - min_element
if A_n[i] < min_element:
min_element = A_n[i]
count = 0
for j in range(0, len(A_n)):
if (A_n[j] + max_profit) in A_n[j:]:
count += 1
print(count)
| N, T = list(map(int, input().split()))
A_n = list(map(int, input().split()))
count = 0
max_profit = A_n[1] - A_n[0]
min_element = min(A_n[0], A_n[1])
for i in range(1, len(A_n)):
if A_n[i] - min_element > max_profit:
max_profit = A_n[i] - min_element
count = 0
if A_n[i] - min_element == max_profit:
count += 1
if A_n[i] < min_element:
min_element = A_n[i]
print(count)
| p03948 |
N, T = list(map(int, input().split()))
towns = list(map(int, input().split()))
max_income = 0
ans = 0
for i in range(N-1):
buy = towns[i]
sell = max(towns[i+1:])
earn = sell-buy
if max_income == earn:
ans += 1
elif max_income < earn:
max_income = earn
ans = 1
print(ans)
| N, T = list(map(int, input().split()))
towns = list(map(int, input().split()))
p = towns[-1]
r = []
for i in reversed(list(range(N))):
if towns[i] >= p:
p = towns[i]
else:
r.append(p-towns[i])
res = r.count(max(r))
print(res)
| p03948 |
#!/usr/bin/env python3
def main():
n, t = list(map(int, input().split()))
an = list(map(int, input().split()))
mi = [an[0]]
se_mi = {0}
for i in range(1, n):
if mi[i - 1] > an[i]:
se_mi = {i}
elif mi[i - 1] == an[i]:
se_mi.add(i)
mi.append(min(mi[i - 1], an[i]))
ma = 0
se_ma = set()
for i in range(1, n):
be = an[i] - mi[i - 1]
if be > ma:
ma = be
se_ma = {i}
elif be == ma:
se_ma.add(i)
print((len(se_ma)))
main()
| #!/usr/bin/env python3
def main():
n, t = list(map(int, input().split()))
an = list(map(int, input().split()))
mi = [an[0]]
for i in range(1, n):
mi.append(min(mi[i - 1], an[i]))
ma = 0
num_ma = 0
for i in range(1, n):
be = an[i] - mi[i - 1]
if be > ma:
ma = be
num_ma = 1
elif be == ma:
num_ma += 1
print(num_ma)
main()
| p03948 |
from collections import Counter
N, T = list(map(int, input().split()))
A = list(map(int, input().split()))
maxA = [0 for _ in range(N + 1)]
minA = [float('inf') for _ in range(N + 1)]
for i, a in enumerate(A):
minA[i + 1] = min(minA[i], a)
for i, a in enumerate(reversed(A)):
maxA[-1 - i] = max(maxA[-1 - (i - 1)], a)
maxProfit = 0
for i in range(1, N):
if maxProfit < maxA[i + 1] - minA[i]:
maxProfit = maxA[i + 1] - minA[i]
pairs = set([])
for i in range(1, N):
if maxProfit == maxA[i + 1] - minA[i]:
pairs.add((minA[i], maxA[i + 1]))
ans = 0
for minVal, maxVal in pairs:
right = N - 1
maxCount = 0
while A[right] != maxVal:
right -= 1
for i in range(right):
if A[i] == minVal:
maxCount += 1
left = 0
minCount = 0
while A[left] != minVal:
left += 1
for i in range(left, N):
if A[i] == maxVal:
minCount += 1
ans += min(maxCount, minCount)
print(ans) | from collections import Counter
N, T = list(map(int, input().split()))
A = list(map(int, input().split()))
maxA = [0 for _ in range(N + 1)]
minA = [float('inf') for _ in range(N + 1)]
for i, a in enumerate(A):
minA[i + 1] = min(minA[i], a)
for i, a in enumerate(reversed(A)):
maxA[-1 - i] = max(maxA[-1 - (i - 1)], a)
maxProfit = 0
for i in range(1, N):
if maxProfit < maxA[i + 1] - minA[i]:
maxProfit = maxA[i + 1] - minA[i]
pairs = set([])
for i in range(1, N):
if maxProfit == maxA[i + 1] - minA[i]:
pairs.add((minA[i], maxA[i + 1]))
ans = len(pairs)
print(ans) | p03948 |
#!/usr/bin/env python3
import collections
def solve(n, t, xs):
trades = collections.defaultdict(int)
for i in range(n):
for j in range(i + 1, n):
delta = xs[j] - xs[i]
if delta > 0:
trades[delta] += 1
max_delta = max(trades.keys())
return trades[max_delta]
def main():
n, t = list(map(int, input().split()))
xs = list(map(int, input().split()))
print((solve(n, t, xs)))
if __name__ == '__main__':
main()
| #!/usr/bin/env pypy3
import collections
INF = 10 ** 10
def solve(n, t, xs):
trades = collections.Counter()
maxs = [INF for _ in range(n)]
maxs[n - 1] = xs[n - 1]
for i in range(n - 1)[::-1]:
maxs[i] = max(xs[i], maxs[i + 1])
for i in range(n):
delta = maxs[i] - xs[i]
if delta > 0:
trades[delta] += 1
max_delta = max(trades.keys())
return trades[max_delta]
def main():
n, t = list(map(int, input().split()))
xs = list(map(int, input().split()))
print((solve(n, t, xs)))
if __name__ == '__main__':
main()
| p03948 |
def slove():
import sys
import collections
input = sys.stdin.readline
n, t = list(map(int, input().rstrip('\n').split()))
a = list(map(int, input().rstrip('\n').split()))
b = collections.defaultdict(list)
m_c = 10 ** 9
for i, v in enumerate(a):
if i != 0 and m_c < v:
b[v-m_c] += [m_c]
m_c = min(m_c, v)
b = sorted(list(b.items()), reverse=True)[0]
print((len(collections.Counter(b[1]))))
if __name__ == '__main__':
slove()
| def slove():
import sys
import collections
input = sys.stdin.readline
n, t = list(map(int, input().rstrip('\n').split()))
a = list(map(int, input().rstrip('\n').split()))
d = collections.defaultdict(list)
min_b = 10 ** 9
max_p = 0
for v in a:
p = v - min_b
max_p = max(max_p, p)
d[p] += [min_b]
min_b = min(min_b, v)
print((len(d[max_p])))
if __name__ == '__main__':
slove()
| p03948 |
n,t = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
good = []
for i in range(len(a)-1):
good.append(max(a[i+1:])-a[i])
m = max(good)
count = 0
for g in good:
if g==m:count+=1
print(count)
| n,t = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
good = []
mmm = []
mmm.append(a[n-1])
for i in range(n-1):
mmm.append(max(mmm[i],a[n-i-2]))
mmm.reverse()
for i in range(len(a)-1):
good.append(mmm[i+1]-a[i])
m = max(good)
count = 0
for g in good:
if g==m:count+=1
print(count) | p03948 |
#!/usr/bin/env python3
N, T = list(map(int, input().split()))
A = list(map(int, input().split()))
d = -1
cnt, ans = 0, 1
for i in range(N - 1):
l = A[i]
r = max(A[i + 1:])
if l <= r:
if r - l == d:
cnt += 1
ans = max(ans, cnt)
else:
cnt = 1
d = max(d, r - l)
print(ans)
| #!/usr/bin/env python3
N, T = list(map(int, input().split()))
A = list(map(int, input().split()))
d = 0
ans = 1
l = A[0]
for a in A[1:]:
l = min(l, a)
r = a
if r - l == d:
ans += 1
elif r - l > d:
ans = 1
d = r - l
print(ans)
| p03948 |
import math
N, D = list(map(int, input().split()))
lst = [list(map(int, input().split())) for _ in range(N)]
ans = 0
for i in range(N):
for j in range(i+1, N):
tmp = 0
for x1, x2 in zip(lst[i], lst[j]):
tmp += (x1 - x2) ** 2
val = math.sqrt(tmp)
# if val.is_integer():
if val == int(val):
ans += 1
print(ans)
| import math
N, D = list(map(int, input().split()))
lst = [list(map(int, input().split())) for _ in range(N)]
ans = 0
for i in range(N):
for j in range(i+1, N):
tmp = 0
for x1, x2 in zip(lst[i], lst[j]):
tmp += (x1 - x2) ** 2
val = math.sqrt(tmp)
if val.is_integer():
# if val == int(val):
ans += 1
print(ans)
| p02982 |
import math
def main():
x = []
N, D = list(map(int, input().split()))
for _ in range(N):
y = list(map(int, input().split()))
x.append(y)
ans = 0
for i in range(N):
for j in range(i):
d1 = 0
for k in range(D):
d1 += pow(x[i][k]-x[j][k], 2)
d1 = math.sqrt(d1)
if d1 == int(d1): ans += 1
return ans
if __name__ == '__main__':
print((main())) | import math
def main():
N, D = list(map(int, input().split()))
pt = []
for _ in range(N):
p = list(map(int, input().split()))
pt.append(p)
ans = 0
for i in range(N):
for j in range(i):
l = 0
for k in range(D):
l += pow(pt[i][k]-pt[j][k], 2)
l = math.sqrt(l)
if l == int(l): ans += 1
return ans
if __name__ == '__main__':
print((main()))
| p02982 |
N, D = list(map(int, input().split()))
l = []
cnt = 0
for i in range (N):
l.append(list(map(int, input().split())))
for j in range (N-1):
for k in range (j+1, N):
t = 0
for d in range (D):
t += (l[j][d]-l[k][d])**2
if t**(1/2)%1 ==0:
cnt += 1
print(cnt) | N, D = list(map(int, input().split()))
X = []
for i in range(N):
X.append(list(map(int, input().split())))
cnt = 0
for j in range (N-1):
for k in range(j+1, N):
t = 0
for l in range(D):
t += (X[j][l]-X[k][l])**2
if t**(1/2)%1 ==0:
cnt += 1
print(cnt) | p02982 |
f=lambda:list(map(int,input().split()))
n,d=f();x=[list(f()) for _ in range(n)]
print((sum(sum((x[i][k]-x[j][k])**2 for k in range(d))**.5%1==0 for j in range(n) for i in range(j)))) | f=lambda:list(map(int,input().split()))
n,d=f();x=[list(f()) for _ in range(n)]
print((sum(sum((s-t)**2 for s,t in zip(x[i],x[j]))**.5%1==0 for j in range(n) for i in range(j)))) | p02982 |
n,d = list(map(int, input().split()))
x = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n-1):
for j in range(i+1,n):
s = 0
for k in range(d):
s += abs(x[i][k] - x[j][k])**2
s = s**0.5
if s.is_integer(): ans += 1
print(ans) | n,d = list(map(int, input().split()))
x = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n-1):
for j in range(i+1, n):
t = 0
for k in range(d): t += abs(x[i][k] - x[j][k])**2
t **= 0.5
if t.is_integer(): ans += 1
print(ans) | p02982 |
N, D = list(map(int, input().split()))
XX = [list(map(int, input().split())) for _ in range(N)]
ans = 0
for i1 in range(N):
for i2 in range(i1+1, N):
total = 0
for index in range(D):
total += (XX[i1][index] - XX[i2][index])**2
val = total ** (1/2)
if isinstance(val, complex):
val = val.real
if val.is_integer():
ans += 1
print(ans)
| N, D = list(map(int, input().split()))
XX = [list(map(int, input().split())) for _ in range(N)]
ans = 0
for i1 in range(N):
for i2 in range(i1+1, N):
total = 0
for index in range(D):
total += (XX[i1][index] - XX[i2][index])**2
val = int(total ** (1/2))
if total == val ** 2:
ans += 1
print(ans)
| p02982 |
n,d = list(map(int, input().split()))
a =[[int(x) for x in input().split()] for i in range(n)]
cnt =0
sei = [i*i for i in range(10000)]
for i in range(n):
for j in range(i):
dis = sum( [((a[i][k] - a[j][k] )*(a[i][k] - a[j][k])) for k in range(d)])
if dis in sei:
cnt +=1
print(cnt) | n,d = list(map(int, input().split()))
xd = [(list(int(_) for _ in input().split())) for i in range(n)]
ans =0
for i in range(n):
x1 = xd[i]
for j in range(i+1,n):
x2 = xd[j]
dis =0
for x,y in zip(x1,x2):
dis += (y-x) **2
k = dis **0.5
if int(k)**2 ==dis:
ans +=1
print(ans) | p02982 |
import itertools
import math
N, D = input().split()
cnt = 0
X = [list(map(int, input().split())) for _ in range(int(N))]
N = [i for i in range(0, int(N))]
N_list = list(itertools.combinations(N, 2))
for n in N_list:
length = 0
for x_1, x_2 in zip(X[n[0]], X[n[1]]):
length += (x_1-x_2)**2
length = math.sqrt(length)
if length == int(length):
cnt += 1
print(cnt) | import math
N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(int(N))]
cnt = 0
for i in range(N):
for j in range(i+1, N):
length = 0
for x_i, x_j in zip(X[i], X[j]):
length += (x_i-x_j)**2
length = math.sqrt(length)
if length == int(length):
cnt += 1
print(cnt) | p02982 |
N, D = list(map(int, input().split()))
X = []
for i in range(N):
X.append(list(map(int, input().split())))
#print(X)
ans = 0
for i in range(N):
for j in range(i+1, N):
dist_sq = 0
for x, y in zip(X[i], X[j]):
dist_sq += (x - y) ** 2
dist = dist_sq ** 0.5
#print(i, j, dist)
if dist - int(dist) == 0:
ans += 1
print(ans) | import math
def abc133_b():
N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
ans = 0
for i in range(N):
for j in range(i):
sq = 0
for k in range(D):
sq += (X[i][k] - X[j][k]) ** 2
rt = math.floor(math.sqrt(sq) + 0.5)
if rt * rt == sq: ans += 1
print(ans)
abc133_b() | p02982 |
def solve():
n,d = list(map(int, input().split()))
l = [[int(x) for x in input().split()] for _ in range(n)]
count = 0
for i in range(n):
Y = l[i]
for Z in l[i+1:]:
total = 0
for y,z in zip(Y,Z):
total += (y-z)**2
d = total**0.5
if d == int(d):
count += 1
return count
if __name__ == '__main__':
print((solve())) | import sys
def solve():
n,d = list(map(int, input().split()))
l = [list(map(int, X.split())) for X in sys.stdin.readlines()]
count = 0
for i in range(n):
Y = l[i]
for Z in l[i+1:]:
total = 0
for y,z in zip(Y,Z):
total += (y-z)**2
d = total**0.5
if d == int(d):
count += 1
return count
if __name__ == '__main__':
print((solve())) | p02982 |
a, b = list(map(int, input().split()))
c = []
e = 0
for i in range(a):
c.append(list(map(int, input().split())))
for i in range(a):
for j in range(i + 1, a):
d = 0
for k in range(b):
d += (c[i][k] - c[j][k]) ** 2
d = d ** 0.5
if d == int(d):
e += 1
print(e)
| a, b = list(map(int, input().split()))
c = [list(map(int, input().split())) for _ in range(a)]
e = 0
for i in range(a):
for j in range(i+1, a):
d = 0
for k in range(b):
d += (c[i][k] - c[j][k]) ** 2
d = d ** 0.5
if d % 1 == 0:
e += 1
print(e)
| p02982 |
import math
N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
count = 0
tmp = []
for i in range(N):
r1 = X[i]
for j in range(N):
t = str(i)+str(j)
if i == j or t in tmp or str(j)+str(i) in tmp:
continue
r2 = X[j]
ls = [(r1[j] - r2[j])**2 for j in range(D)]
res = math.sqrt(sum(ls))
if res % 1 == 0:
count += 1
tmp.append(t)
print(count) | import math
N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
count = 0
for i in range(N):
r1 = X[i]
for j in range(N-1, -1, -1):
if i == j:
break
r2 = X[j]
ls = [(r1[j] - r2[j])**2 for j in range(D)]
res = math.sqrt(sum(ls))
if res % 1 == 0:
count += 1
print(count) | p02982 |
import math
N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for i in range(N)]
cnt = 0
for i in range(N):
for j in range(i, N):
tmp = 0
if i == j:
continue
for k in range(D):
tmp += (X[i][k] - X[j][k]) ** 2
if math.sqrt(tmp).is_integer():
cnt += 1
print(cnt) | import math
N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for i in range(N)]
cnt = 0
for i in range(N):
for j in range(i+1, N):
tmp = 0
for k in range(D):
tmp += (X[i][k] - X[j][k]) ** 2
if math.sqrt(tmp).is_integer():
cnt += 1
print(cnt) | p02982 |
N, D = list(map(int, input().split()))
X = []
for _ in range(N):
X.append([int(x) for x in input().split()])
ans = 0
for i in range(N - 1):
for j in range(i + 1, N):
s = sum((X[i][d] - X[j][d])**2 for d in range(D))
if any(i**2 == s for i in range(1000)):
ans += 1
print(ans)
| N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
S = {i**2 for i in range(1000)}
ans = sum(
a != b and sum((x - y)**2 for x, y in zip(a, b)) in S
for a in X
for b in X
) // 2
print(ans)
| p02982 |
import math
N,D = list(map(int,input().split()))
X = [list(map(int,input().split()))for _ in range(N)]
count = 0
a = 0
for i in range(N):
for j in range(i + 1,N):
for k in range(D):
a += (X[i][k] - X[j][k])**2
if math.sqrt(a) == int(math.sqrt(a)):
count += 1
a = 0
print(count) | import math
n,d=list(map(int,input().split()))
x=[list(map(int,input().split())) for _ in range(n)]
count=0
for i in range(n-1):
for j in range(i+1,n):
c=0
for k in range(d):
c+=(x[i][k]-x[j][k])**2
if math.sqrt(c)==int(math.sqrt(c)):
count+=1
print(count)
| p02982 |
import math
n, d = list(map(int, input().split()))
x = [list(map(int, input().split())) for i in range(n)]
flag = 0
for y in range(len(x)):
for z in range(y+1, len(x)):
distance2 = 0
for i in range(d):
distance2 += (x[y][i] - x[z][i]) ** 2
distance = math.sqrt(distance2)
distance = float(distance)
if distance.is_integer():
flag += 1
print(flag)
| import math
N, D = list(map(int, input().split()))
x_list = []
for i in range(N):
x = list(map(int,input().split()))
x_list.append(x)
count = 0
for i in range(1, N + 1):
for j in range(1, N + 1):
if i >= j:
continue
distance2 = 0
for num in range(D):
distance2 += (x_list[i - 1][num] - x_list[j - 1][num]) ** 2
if math.sqrt(distance2).is_integer():
count += 1
print(count) | p02982 |
N,D=list(map(int, input().split()))
X=[ list(map(int, input().split())) for _ in range(N) ]
ans=0
for i in range(N):
for j in range(i+1,N):
t=0
for x, y in zip(X[i],X[j]):
t+=(x-y)**2
for h in range(1,10000):
if t==h**2:
ans+=1
break
print(ans) | # -*- coding: utf-8 -*-
import sys
N,D=list(map(int, sys.stdin.readline().split()))
X=[ list(map(int, sys.stdin.readline().split())) for _ in range(N) ]
L=[] #2乗した数
for i in range(201):
L.append(i**2)
ans=0
for i in range(N-1):
for j in range(i+1,N):
t=0
for x1,x2 in zip(X[i],X[j]):
t+=(x1-x2)**2
if t in L:
ans+=1
print(ans) | p02982 |
N,D=list(map(int,input().split()))
X=[list(map(int,input().split())) for i in range(N)]
l=len(X)
cnt=0
for i in range(l):
for j in range(i+1,l):
t=sum((X[i][d]-X[j][d])**2for d in range(D))**0.5
if t==int(t):cnt+=1
print(cnt) | N,D=list(map(int,input().split()))
X=[list(map(int,input().split())) for i in range(N)]
l=len(X)
cnt=0
for i in range(l):
for j in range(i+1,l):
t=sum((X[i][d]-X[j][d])**2for d in range(D))**0.5
cnt+=t==int(t)
print(cnt) | p02982 |
from math import sqrt
n, d = list(map(int, input().split()))
lst = []
cnt = 0
for i in range(n):
a = tuple(map(int, input().split()))
lst.append(a)
for i in range(n-1):
for j in range(i+1, n):
x = 0
for k in range(d):
x += (lst[i][k]-lst[j][k])**2
length = sqrt(x)
if length%1 == 0:
if length != 0:
cnt += 1
print(cnt) | n, d = list(map(int, input().split()))
lst = []
cnt = 0
for i in range(n):
a = list(map(int, input().split()))
lst.append(a)
for i in range(n-1):
for j in range(i+1, n):
x = 0
for k in range(d):
x += (lst[i][k]-lst[j][k]) ** 2
dist = x ** 0.5
if dist%1 == 0:
if dist != 0:
cnt += 1
print(cnt) | p02982 |
import math
n, d = list(map(int, input().split()))
x = []
cnt = 0
sum = 0
for _ in range(n):
tmp = list(map(int, input().split()))
x.append(tmp)
for i in range(n):
for j in range(i + 1, n):
sum = 0
for k in range(d):
sum += (x[i][k] - x[j][k]) ** 2
distance = math.sqrt(sum)
if distance.is_integer():
cnt += 1
print(cnt)
| n, d = list(map(int, input().split()))
x = []
cnt = 0
sum = 0
for _ in range(n):
tmp = list(map(int, input().split()))
x.append(tmp)
for i in range(n):
for j in range(i + 1, n):
sum = 0
for k in range(d):
sum += (x[i][k] - x[j][k]) ** 2
distance = sum ** 0.5
if distance.is_integer():
cnt += 1
print(cnt)
| p02982 |
n, d = list(map(int, input().split()))
X = []
for _ in range(n):
X.append([int(x) for x in input().split()])
ans = 0
for i in range(n - 1):
for j in range(i + 1, n):
s = sum((X[i][d] - X[j][d])**2 for d in range(d))
if any(k**2 == s for k in range(1000)):
ans += 1
print(ans)
| n, d = list(map(int, input().split()))
X = []
for _ in range(n):
X.append([int(x) for x in input().split()])
ans = 0
for i in range(n - 1):
for j in range(i + 1, n):
s = sum((X[i][d] - X[j][d])**2 for d in range(d))
if (s ** .5).is_integer():
ans += 1
print(ans) | p02982 |
import math
def main():
n, d, *x = list(map(int, open(0).read().split()))
cnt = 0
for i in range(n-1):
for j in range(i+1, n):
y = x[i*d:(i+1)*d]
z = x[j*d:(j+1)*d]
dist = 0
for cur_y, cur_z in zip(y, z):
dist += (cur_y - cur_z) ** 2
dist = math.sqrt(dist)
if dist == int(dist):
cnt += 1
ans = cnt
print(ans)
return()
if __name__ == '__main__':
main()
| def main():
n, d, *x = list(map(int, open(0).read().split()))
cnt = 0
for i in range(n-1):
for j in range(i+1, n):
y = x[i*d:(i+1)*d]
z = x[j*d:(j+1)*d]
dist_double = 0
for cur_y, cur_z in zip(y, z):
dist_double += (cur_y - cur_z) ** 2
dist = int(dist_double ** 0.5 + 0.5)
if dist ** 2 == dist_double:
cnt += 1
ans = cnt
print(ans)
return()
if __name__ == '__main__':
main()
| p02982 |
n,d = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(n)]
def dist_squere(x, y):
d = 0
for i,j in zip(x,y):
d += (i-j)**2
return d
squares = set([i*i for i in range(10000)])
def is_square(x):
return x in squares
from itertools import combinations
ans = 0
for x,y in combinations(X, 2):
if is_square(dist_squere(x, y)):
ans += 1
print(ans) | n,d = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(n)]
def dist_squere(x, y):
d = 0
for i,j in zip(x,y):
d += (i-j)**2
return d**.5
from itertools import combinations
ans = 0
for x,y in combinations(X, 2):
if dist_squere(x, y).is_integer():
ans += 1
print(ans) | p02982 |
import math
N,D=list(map(int,input().split()))
x=[]
s=0
cnt=0
for i in range(N):
X=list(map(int,input().split()))
x.append(X)
for i in range(N-1):
for j in range(i+1,N):
for k in range(D):
s+=(x[i][k]-x[j][k])*(x[i][k]-x[j][k])
s=math.sqrt(s)
#print(s)
if s==int(s):
cnt+=1
s=0
print(cnt) | import math
n,d=list(map(int,input().split()))
x=[]
for i in range(n):
a=list(map(int,input().split()))
x.append(a)
cnt=0
for i in range(n-1):
for j in range(i+1,n):
dis=0
for k in range(d):
dis+=(x[i][k]-x[j][k])*(x[i][k]-x[j][k])
dis=math.sqrt(dis)
if dis==int(dis):
cnt+=1
print(cnt) | p02982 |
N, D = list(map(int, input().split()))
X = [[int(j) for j in input().split()] for i in range(N)]
ans = 0
for i in range(N):
for j in range(i + 1, N):
acum = 0.0
for k in range(D):
acum += (X[j][k] - X[i][k]) ** 2
if float.is_integer(acum ** 0.5):
ans += 1
print(ans)
| N, D = list(map(int, input().split()))
X = [[int(j) for j in input().split()] for i in range(N)]
ans = 0
for i in range(N):
for j in range(i + 1, N):
acum = 0.0
for k in range(D):
acum += (X[j][k] - X[i][k]) ** 2
if (acum ** 0.5).is_integer():
ans += 1
print(ans)
| p02982 |
n,d=list(map(int,input().split()))
X=[]
for _ in range(n):
X.append(list(map(int,input().split())))
f=0
for i in range(n-1):
for j in range(i+1,n):
l=0
for a in range(d):
l+=(X[i][a]-X[j][a])**2
if int(l**(1/2))==l**(1/2):
f+=1
print(f) | n,d=list(map(int,input().split()))
X=[list(map(int,input().split())) for _ in range(n)]
f=0
for i in range(n-1):
for j in range(i+1,n):
l=0
for a in range(d):
l+=(X[i][a]-X[j][a])**2
if int(l**(1/2))==l**(1/2):
f+=1
print(f) | p02982 |
def dist(a, b):
res = 0
for i in range(D):
res += (a[i] - b[i]) ** 2
res = res ** 0.5
return res
N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for i in range(N)]
ans = 0
for i in range(N - 1):
for j in range(i +1, N):
if dist(X[i], X[j]).is_integer():
ans += 1
print(ans) | import math
N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
ans = 0
for i in range(N-1):
for j in range(i+1, N):
tmp = 0
for k in range(D):
tmp +=(X[i][k]-X[j][k])**2
tmp = math.sqrt(tmp)
if (tmp.is_integer()): ans += 1
print(ans)
| p02982 |
#!/usr/bin/env python3
import sys
import math
def solve(N: int, D: int, X: "List[List[int]]"):
count = 0
for i in range(N):
for j in range(i + 1,N):
sum = 0
for k in range(D):
sum += (X[i][k] - X[j][k]) ** 2
f = float(math.sqrt(sum))
if f.is_integer():
count += 1
print(count)
return
# Generated by 1.1.4 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()
N = int(next(tokens)) # type: int
D = int(next(tokens)) # type: int
X = [ [ int(next(tokens)) for _ in range(D) ] for _ in range(N) ] # type: "List[List[int]]"
solve(N, D, X)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
import math
def solve(N: int, D: int, X: "List[List[int]]"):
count = 0
for i in range(0, N - 1):
for j in range(i + 1, N):
sum = 0
for k in range(0, D):
sum += (X[i][k] - X[j][k]) ** 2
if math.sqrt(sum).is_integer():
count += 1
print(count)
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()
N = int(next(tokens)) # type: int
D = int(next(tokens)) # type: int
X = [[int(next(tokens)) for _ in range(D)] for _ in range(N)] # type: "List[List[int]]"
solve(N, D, X)
if __name__ == '__main__':
main()
| p02982 |
import math
n,d = list(map(int,input().split()))
x = [[0]*d for _ in range(n)]
for i in range(n):
x[i] = list( map( int, input().split() ) )
count = 0
for i in range(n):
for j in range(n):
if i <= j:
continue
dist = 0
for k in range(d):
dist += (x[i][k] - x[j][k])**2
dist = math.sqrt(dist)
if dist % 1 == 0:
count += 1
print(count)
| import math
n,d = list(map( int, input().split()))
point = [[0]*d for _ in range(n)]
for i in range(n):
point[i] = list( map( int, input().split()))
count = 0
for i in range(n):
for j in range(n):
if i < j:
sum = 0
for k in range(d):
sum += ( point[i][k] - point[j][k] ) ** 2
sum = math.sqrt(sum)
if sum % 1 == 0:
count += 1
else:
continue
print(count) | p02982 |
n,d = list(map(int,input().split()))
x = [list(map(int,input().split())) for i in range(n)]
ans = 0
def k(a,b):
dist = 0
for i in range(d):
dist +=(a[i]-b[i])**2
dist = dist**(1/2)
while dist > 0:
dist -= 1
if dist == 0:
return True
return False
for i in range(n):
for j in range(i+1,n):
if k(x[i],x[j]):
ans += 1
print(ans) | n,d = list(map(int,input().split()))
data = [list(map(int,input().split())) for i in range(n)]
def ok(x,y):
z = 0
for i in range(d):
z += (x[i]-y[i])**2
if z**(0.5) == int(z**(0.5)):
return True
else:
return False
ans = 0
for i in range(n):
for j in range(i+1,n):
if ok(data[i],data[j]):
ans += 1
print(ans) | p02982 |
def main():
x = int(eval(input()))
ans = 0
while x >= 500:
x -= 500
ans += 1000
while x >= 5:
x -= 5
ans += 5
print(ans)
main()
|
def main():
x = int(eval(input()))
ans = 0
ans += (x // 500) * 500
x -= ans
ans *= 2
ans += (x // 5) * 5
print(ans)
main()
| p02724 |
n=int(eval(input()))
ans=0
ans+=(n//500)*1000
n=n%500
ans+=(n//5)*5
print(ans) | n=int(eval(input()))
print(((n//500)*1000 + ((n%500)//5)*5)) | p02724 |
'''
問題：
高橋君は金色の硬貨が好きです。
自分が持っている 500円硬貨 1枚につき 1000、
5円硬貨 1枚につき 5の嬉しさ を得ます。
高橋君は X 円を持っています。
これを高橋君の嬉しさが最大になるように両替したとき、高橋君の嬉しさはいくらになりますか？
(なお、利用できる硬貨は 500 円玉、100 円玉、50 円玉、10 円玉、5円玉、1 円玉の 6 種類とします。)
'''
'''
Xは整数
0 ≦ X ≦ 1,000,000,000
'''
class A:
def __init__(self, money, yorokobi):
self.money = money
self.yorokobi = yorokobi
def calc_yorokobi(self, credit): # credit ：残金を入力として受け取り、喜びを計算して返す
return int(credit / self.money) * self.yorokobi
# def print_self(self):
# print(calc_yorokobi(self, credit))
#
# def calc_yorokobi(input_money, x, yorokobi):
# ret = input_money // x * yorokobi
# return ret
# 標準入力から X の値を取得する
input_x = int(eval(input()))
yorokobi_500 = A(500, 1000)
yorokobi_5 = A(5, 5)
result = 0 # 結果格納用
if input_x >= 500:
# print("1回目：{}".format(result))
result += yorokobi_500.calc_yorokobi(input_x) # 高橋500円の喜び
# print("2回目：{}".format(result))
result += yorokobi_5.calc_yorokobi(input_x % 500) # 高橋5円の喜び
# print("3回目：{}".format(result))
else:
result += yorokobi_5.calc_yorokobi(input_x)
print(result)
# ret1 = input_x // 500 # 500円で割った商
# ret2 = ret1 * 1000 # 高橋君 500円の喜び
# ret3 = input_x - (ret1 * 500) # X円から500円の枚数分を引いたお金
# ret4 = ret3 // 5 # （X円から500円の枚数分を引いたお金）÷ 5
# ret5 = ret4 * 5 # 高橋君 5円の喜び
# print(ret2 + ret5)
| '''
問題：
高橋君は金色の硬貨が好きです。
自分が持っている 500円硬貨 1枚につき 1000、
5円硬貨 1枚につき 5の嬉しさ を得ます。
高橋君は X 円を持っています。
これを高橋君の嬉しさが最大になるように両替したとき、高橋君の嬉しさはいくらになりますか？
(なお、利用できる硬貨は 500 円玉、100 円玉、50 円玉、10 円玉、5円玉、1 円玉の 6 種類とします。)
'''
'''
Xは整数
0 ≦ X ≦ 1,000,000,000
'''
class Yorokobi:
def __init__(self, money, yorokobi):
self.money = money
self.yorokobi = yorokobi
def calc_yorokobi(self, credit): # credit （残金？）を入力として受け取り、喜びを計算して返す
return (credit // self.money) * self.yorokobi
# 標準入力から X の値を取得する
input_x = int(eval(input()))
yorokobi_500 = Yorokobi(500, 1000)
yorokobi_5 = Yorokobi(5, 5)
result = 0 # 結果格納用
if input_x >= 500:
result += yorokobi_500.calc_yorokobi(input_x) # 高橋君 500円の喜び
result += yorokobi_5.calc_yorokobi(input_x % 500) # 高橋君 5円の喜び
else:
result += yorokobi_5.calc_yorokobi(input_x)
print(result)
# ret1 = input_x // 500 # 500円で割った商
# ret2 = ret1 * 1000 # 高橋君 500円の喜び
# ret3 = input_x - (ret1 * 500) # X円から500円の枚数分を引いたお金
# ret4 = ret3 // 5 # （X円から500円の枚数分を引いたお金）÷ 5
# ret5 = ret4 * 5 # 高橋君 5円の喜び
# print(ret2 + ret5)
| p02724 |
money=int(eval(input()))
happines=0
while money>=500:
happines+=1000
money-=500
while money>=5:
happines+=5
money-=5
print(happines) | money=int(eval(input()))
happines=0
while money>=500:
happines+=1000
money-=500
while money>=100:
happines+=100
money-=100
while money>=5:
happines+=5
money-=5
print(happines) | p02724 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
X = I()
X -= X % 5
X //= 5
print((1000*(X//100) + 5*(X % 100)))
| # ABC160-B
import sys
def I(): return int(sys.stdin.readline().rstrip())
X = I()
print((1000*(X//500) + 5*((X % 500)//5)))
| p02724 |
n=int(eval(input()))
a=0
while n>499:
n-=500
a+=1000
while n>4:
n-=5
a+=5
print(a) | n=int(eval(input()));print((n//500*1000+n%500//5*5)) | p02724 |
X = int(eval(input()))
ans = X // 500 * 1000 + (X % 500) // 5 * 5
print(ans) | X = int(eval(input()))
print(((X // 500) * 1000 + (X % 500) // 5 * 5)) | p02724 |
X = int(eval(input()))
a = X // 500
b = (X % 500) // 5
print((a * 1000 + b * 5))
| X = int(eval(input()))
ans = (X // 500) * 1000
X = X % 500
ans += (X // 5) * 5
print(ans)
| p02724 |
n=int(eval(input()))
k = 0
l = 0
while n>=500:
n = n-500
k = k+1
while n>5:
n -= 5 #n=n-5
l += 1
print((k*1000+ l*5 )) | n=int(eval(input()))
k = n//500
l = (n-500*k)//5
print((k*1000+ l*5 )) | p02724 |
X = int(eval(input()))
a = X // 500
X = X % 500
b = X // 5
print((a*1000+b*5)) | X = int(eval(input()))
a = X // 500 # 500円硬貨の枚数
X = X % 500 # 端数
b = X // 5 # 5円硬貨の枚数
print((a*1000+b*5)) | p02724 |
x = int(eval(input()))
ans = (x//500)*1000+((x%500)//5)*5
print(ans) | x = int(eval(input()))
print((x//500*1000+(x%500)//5*5)) | p02724 |
x = int(eval(input()))
count = 0
count_2 = 0
while x > 0:
if (x >= 500):
x -= 500
count += 1
else:
break
while x > 0:
if (x >= 5):
x -= 5
count_2 += 1
else:
break
print((1000 * count + 5 * count_2)) | X = int(eval(input()))
res = X // 500 * 1000
X %= 500
res += X // 5 * 5
print(res)
| p02724 |
x = int(eval(input()))
print((1000*(x // 500) + 5*((x % 500) // 5) )) | x = int(eval(input()))
print((1000*(x // 500) + 5*(x%500 // 5) )) | p02724 |
x=int(eval(input()))
a=x//500
x=x%500
b=x//5
print((a*1000+b*5)) | x=int(eval(input()))
a=x%500
b=x//500
print((1000*b+5*(a//5))) | p02724 |
def resolve():
x=int(eval(input()))
ans=0
while x>=500:
x-=500
ans+=1000
while x>=5:
x-=5
ans+=5
print(ans)
resolve() | n=int(eval(input()))
gg=0
gg+=(n//500)*1000
n=n-(n//500)*500
gg+=(n//5)*5
print(gg)
| p02724 |
X = int(eval(input()))
gohyaku = X//500
nokori = X % 500
goen = nokori//5
print((gohyaku*1000 + goen*5))
| # Problem B - Golden Coins
X = int(eval(input()))
gohyaku = X // 500
nokori = X % 500
goen = nokori // 5
# output
print((gohyaku * 1000 + goen * 5))
| p02724 |
x = int(eval(input()))
ans = 0
ans += (x//500)*1000
x %= 500
ans += (x//5)*5
print(ans) | X = int(eval(input()))
num1000 = X // 500
r500 = X % 500
num5 = r500 // 5
print((num1000 * 1000 + num5 * 5))
| p02724 |
n=int(eval(input()))
x=n//500
y=(n-x*500)//5
print((x*1000+y*5)) | n = int(eval(input()))
shou500 = n//500
shou5 = (n-shou500*500)//5
print((shou500*1000+shou5*5)) | p02724 |
def main():
X = int(eval(input()))
# 500円をp個、5円をq個とすると。500p+5q=Xが成り立ち、ansは1000p+5qになる
pmax = int(X/500)
ans = 0
tmp = 0
for p in range(pmax+1):
q = int((X-500*p)/5)
tmp = 1000*p + 5*q
ans = max(ans,tmp)
print(ans)
main()
| def main():
X = int(eval(input()))
# 500円をp個、5円をq個とすると。500p+5q=Xが成り立ち、ansは1000p+5qになる
p = int(X/500)
q = int((X-p*500)/5)
ans = 1000*p + 5*q
print(ans)
main()
| p02724 |
#!/usr/bin/env python3
X = int(eval(input()))
ans = 0
while X >= 500:
X -= 500
ans += 1000
while X >= 5:
X -= 5
ans += 5
print(ans)
| X = int(eval(input()))
cnt = 0
while X >= 500:
cnt += 1000
X -= 500
while X >= 5:
cnt += 5
X -= 5
print(cnt) | p02724 |
#template
def inputlist(): return [int(j) for j in input().split()]
from collections import Counter
#template
#issueから始める
X = int(eval(input()))
k = X //500
ans = 0
ans += 1000*k
X -= 500*k
l = X //5
ans += 5*l
print(ans) | N = int(eval(input()))
d = N // 500
mod = N % 500
d2 = mod // 5
print((d*1000+d2*5)) | p02724 |
S = int(eval(input()))
G = 500
GG = 5
g_count = 0
gg_count= 0
while S >= G:
S = S - G
g_count += 1
while S >= GG:
S = S - GG
gg_count += 1
print((g_count*1000 + gg_count*5))
| N = int(eval(input()))
NN = N // 500
MM = N % 500
LL = MM // 5
#print(NN, LL)
print((NN * 1000 + LL * 5)) | p02724 |
x = int(eval(input()))
count = 0
while (x >= 500):
count += 1000
x = x-500
while (x >= 5):
if x > 5:
count += 5
x = x-5
print(count) | #別回答
x = int(eval(input()))
print(((x//500*1000) + ((x%500)//5*5))) | p02724 |
def main():
n = int(eval(input()))
ans = 1000*(n//500)
n %= 500
ans += 5*(n//5)
print(ans)
main()
| def main():
x = int(eval(input()))
cnt = 0
cnt += 1000*(x//500)
x %= 500
cnt += 5*(x//5)
print(cnt)
main()
| p02724 |
i = int(eval(input()))
big_count = i // 500
small_count = (i - 500 * big_count) // 5
print((big_count * 1000 + small_count * 5))
| x = int(eval(input()))
big = x // 500
small = (x - big*500) // 5
print((big * 1000 + small * 5))
| p02724 |
n = int(eval(input()))
happy = 0
if n // 500 >= 1:
ha500 = n // 500
happy = 1000 * ha500
nokon = n % 500
if nokon // 5 >= 1:
ha005 = nokon // 5
happy = happy + 5 * ha005
else:
if n // 5 >= 1:
ha005 = n // 5
happy = 5 * ha005
print(happy) | n = int(eval(input()))
i = n % 500
happy = ((n//500)*1000 + (i//5)*5)
print(happy) | p02724 |
X =eval(input())
X=int(X)
point =0
while X>=5:
if X>=500:
X-=500
point+=1000
elif 5<=X<500:
X-=5
point+=5
print(point) | X =int(eval(input()))
a =int(X/500)
b=int((X%500)/5)
print((1000*a+5*b))
| p02724 |
x=int(eval(input()))
result=x//500*1000+x%500//5*5
print(result) | a=int(eval(input()))
cnt=(a//500)*1000
cnt+=((a%500)//5)*5
print(cnt)
| p02724 |
x =int(eval(input()))
total =0
count =0
for i in range(x):
if 500*i ==x:
count =i*1000
break
elif 500*i > x:
total =abs(500*(i-1) -x)
count =(i-1) *1000
# print(count)
break
if total ==0:
print(count)
else:
for i in range(x):
if 5*i ==total:
print("aa")
count +=i*5
elif 5*i >total:
count +=(i-1)*5
# print(count)
# total =abs(5*(i-1) -total)
break
print(count) | x =int(eval(input()))
total =0
count =0
for i in range(x):
if 500*i ==x:
count =i*1000
break
elif 500*i > x:
total =abs(500*(i-1) -x)
count =(i-1) *1000
# print(count)
break
if total ==0:
print(count)
else:
for i in range(x):
if 5*i ==total:
count +=i*5
break
elif 5*i >total:
count +=(i-1)*5
break
print(count) | p02724 |
X = int(eval(input()))
a = X // 500
b = (X % 500) // 5
print((a * 1000 + b * 5)) | X = int(eval(input()))
print((X // 500 * 1000 + (X % 500)//5*5)) | p02724 |
X = int(eval(input()))
print(((X//500)*1000 + (X%500)//5*5)) | X=int(eval(input()))
print((X//500*1000+X%500//5*5)) | p02724 |
x = int(eval(input()))
c_500 = 0
c_5 = 0
while True:
temp = x - 500
if temp < 0:
break
else:
c_500 += 1
x = temp
while True:
temp = x - 5
if temp < 0:
break
else:
c_5 += 1
x = temp
print((c_500 * 2 * 500 + c_5 * 5))
| x = int(eval(input()))
c_500 = x // 500
r_500 = x % 500
c_5 = r_500 // 5
print((c_500 * 1000 + c_5 * 5))
| p02724 |
X = int(eval(input()))
n = X//500
m = X%500
n1 = m//5
print((n*1000+n1*5)) | X = int(eval(input()))
n = X//500
m = (X%500)//5
print((1000*n+5*m)) | p02724 |
X = int(eval(input()))
n = X//500
m = (X%500)//5
print((1000*n+5*m)) | X = int(eval(input()))
n = X//500
ans = 1000*n
m = X%500
k = m//5
ans += 5*k
print(ans) | p02724 |
s = int(eval(input()))
count1=-1
count2=-1
while s>=0:
s=s-500
count1=count1 +1
s=s+500
if s==0:
yasashisa=count1*1000
print(yasashisa)
else:
while s >=0:
s=s-5
count2=count2 +1
yasashisa=count1*1000+count2* 5
print(yasashisa)
| s=int(eval(input()))
a= s//500
b=(s%500)//5
yasashisa=a*1000+b*5
print(yasashisa) | p02724 |
x = int(eval(input()))
fh = 0
f = 0
fh = x//500
x%=500
f = x//5
print((1000*fh+5*f)) | x = int(eval(input()))
ret = (x//500 * 1000) + ((x%500)//5)*5
print(ret) | p02724 |
x = int(eval(input()))
y500 = x // 500
y5 = (x % 500) // 5
print((y500 * 1000 + y5*5)) | x = int(eval(input()))
coin_500 = x // 500
coin_5 = (x-coin_500*500) // 5
print((coin_500 * 1000 + coin_5 * 5)) | p02724 |
X = int(eval(input()))
ans = X//500*1000
X = X % 500
ans += X//5*5
print(ans)
| def LI():
return list(map(int, input().split()))
X = int(eval(input()))
ans = X//500*1000
X = X % 500
ans += X//5*5
print(ans)
| p02724 |
n = int(eval(input()))
happy = 0
if n%500 == 0:
print((2*n))
else:
while n > 0:
if n == 0:
break
n-=500
if n<0:
n+=500
n-=5
if n<0:
n+=5
break
else:
happy+=5
else:
happy+=1000
print(happy)
| x = int(eval(input()))
total = 0
a = int(x / 500)
b = x % 500
c = int(b / 5)
total = a * 1000 + c *5
print(total) | p02724 |
def main():
n = int(eval(input()))
print((n//500*1000+(n%500)//5*5))
if __name__ == "__main__":
main() | x = int(eval(input()))
print((x//500*1000+(x%500//5)*5))
| p02724 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.