code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
178,025B
⌀ | question_pair_id
float64 27.1M
177,113B
⌀ | code1_group
int64 1
297
| code2_group
int64 1
297
|
|---|---|---|---|---|---|---|
n = input()
l = map(int, raw_input().split())
max = l[0]
min = l[0]
s = l[0]
k = 1
while k < n:
if max < l[k]:
max = l[k]
if min > l[k]:
min = l[k]
s = s + l[k]
k = k + 1
print min, max, s
|
def stack():
A = list(input().split())
lst = []
def add(a, b):
return b + a
def sub(a, b):
return b - a
def mul(a, b):
return b * a
def div(a, b):
return b / a
def calc(lst, f):
return lst.append(f(lst.pop(), lst.pop()))
for i in A:
if i == '+':
calc(lst, add)
elif i == '-':
calc(lst, sub)
elif i == '*':
calc(lst, mul)
elif i == '/':
calc(lst, div)
else:
lst.append(int(i))
print(*lst)
stack()
| 0 | null | 380,877,945,924 | 48 | 18 |
def insertion_sort(numbers, n, g):
"""insertion sort method
(only elements whose distance is larger than g are the target)
Args:
numbers: list of elements to be sorted
n: len(numbers)
g: distance
Returns:
partially sorted list, counter
"""
counter = 0
copied_instance = []
for data in numbers:
copied_instance.append(data)
for i in range(g, n):
target = copied_instance[i]
j = i - g
while j >= 0 and target < copied_instance[j]:
copied_instance[j + g] = copied_instance[j]
j -= g
counter += 1
copied_instance[j + g] = target
return copied_instance, counter
def shell_sort(numbers, n, key=lambda x: x):
"""shell sort method
Args:
numbers: list of elements to be sorted
n: len(numbers)
Returns:
sorted numbers, used G, swapped number
"""
counter = 0
copied_instance = []
for data in numbers:
copied_instance.append(data)
G = [1]
g = 4
while g < len(numbers):
G.append(g)
g = g * 3 + 1
G = G[::-1]
for g in G:
copied_instance, num = insertion_sort(copied_instance, n, g)
counter += num
return copied_instance, G, counter
length = int(raw_input())
numbers = []
counter = 0
while counter < length:
numbers.append(int(raw_input()))
counter += 1
numbers, G, counter = shell_sort(numbers, length)
print(len(G))
print(" ".join([str(x) for x in G]))
print(counter)
for n in numbers:
print(str(n))
|
class Unionfind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def root (self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.root(self.parents[x])
return self.parents[x]
def connect(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def isConnect(self, x):
return self.root(x) == self.root(y)
def size(self, x):
return -self.parents[self.root(x)]
N, M = map(int, input().split())
uf = Unionfind(N)
for i in range(M):
a, b = map(lambda x: int(x) - 1, input().split())
uf.connect(a, b)
ans = 0
for i in range(N):
ans = max(ans, uf.size(i))
print(ans)
| 0 | null | 1,959,948,117,568 | 17 | 84 |
a = int(input())
n = a + a*a + a*a*a
print(n)
|
def resolve():
a = int(input())
print(a + a ** 2 + a ** 3)
resolve()
| 1 | 10,250,933,825,000 | null | 115 | 115 |
from collections import Counter
import sys
sys.setrecursionlimit(10 ** 6)
mod = 1000000007
inf = int(1e18)
dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]
def inverse(a):
return pow(a, mod - 2, mod)
def usearch(x, a):
lft = 0
rgt = len(a) + 1
while rgt - lft > 1:
mid = (rgt + lft) // 2
if a[mid] <= x:
lft = mid
else:
rgt = mid
return lft
def main():
n, m = map(int, input().split())
ans = []
for i in range(1, (m+1)//2+1):
if len(ans) == m:
break
ans.append([i, m+2-i])
for i in range(1, (m+1)//2+1):
if len(ans) == m:
break
ans.append([m+1+i, 2*m+2-i])
for x in ans:
print(x[0], x[1])
main()
|
N,M,Q = map(int, input().split())
ab = tuple(tuple(map(int, input().split())) for _ in range(Q))
ans = 0
def dfs(A):
global ans
if len(A) == N:
tmp = 0
for i in range(Q):
a,b,c,d = ab[i]
if (A[b-1]-A[a-1]) == c:
tmp += d
if tmp > ans:
ans = tmp
else:
last = A[-1] if len(A) > 0 else 1
for i in range(last, M+1):
A.append(i)
dfs(A)
A.pop()
dfs([])
print(ans)
| 0 | null | 27,992,153,758,292 | 162 | 160 |
import math
n = int(input())
t = [0] * (n + 1)
m = math.floor(math.sqrt(n))
for i in range(1,m):
for j in range(1,m):
for k in range(1,m):
p = i*i+j*j+k*k+i*j+j*k+i*k
if p <= n:
t[p] += 1
for i in range(1,n + 1):
print(t[i])
|
n=int(input())
num=[0]*60001
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
i=x*x+y*y+z*z+x*y+y*z+z*x
if i <= n:
num[i]+=1
for i in range(n):
print(num[i+1])
| 1 | 8,086,478,548,348 | null | 106 | 106 |
import sys
n=int(input())
a=[int(i) for i in sys.stdin.readline().split()]
temps=[a[0]]+[0]*n
mod=1000000007
ans=0
for i in range(1,n):
ans+=temps[i-1]*a[i]
ans%=mod
temps[i]=a[i]+temps[i-1]
print(ans)
|
import sys
from itertools import combinations
input = lambda: sys.stdin.readline().rstrip()
mod = 10**9 + 7
n = int(input())
a = list(map(int, input().split()))
dp = [0 for _ in range(n)]
dp[0] = a[0]
# 累積和の計算
for i in range(1, n):
dp[i] = (a[i] + dp[i - 1]) % mod
ans = 0
for i in range(n):
ans += a[i] * (dp[n - 1] - dp[i])
ans %= mod
print(ans)
| 1 | 3,828,229,476,608 | null | 83 | 83 |
import sys
from math import gcd
def input(): return sys.stdin.readline().strip()
def main():
N = int(input())
A =list(map(int, input().split()))
all_gcd = A[0]
max_num = A[0]
for a in A:
all_gcd = gcd(all_gcd, a)
max_num = max(max_num, a)
if all_gcd != 1:
print("not coprime")
return
# エラトステネスの篩でmin_prime[i] = (iを割り切る最小の素数)を記録する
min_prime = [i for i in range(max_num + 1)]
for p in range(2, int(max_num**0.5) + 1):
if min_prime[p] != p: continue
for i in range(2 * p, max_num + 1, p): min_prime[i] = p
# Aの要素で出てきた素因数をusedに記録
used = [0] * (max_num + 1)
for a in A:
while a > 1:
p = min_prime[a]
if used[p]:
print("setwise coprime")
return
while a % p == 0: a //= p
used[p] = 1
print("pairwise coprime")
if __name__ == "__main__":
main()
|
n = int(input())
a = list(map(int,input().split()))
d = {}
for i in range(1,n+1):
if i not in d:
d[i] = 0
for i in range(len(a)):
d[a[i]] += 1
for i in range(1,n+1):
print(d[i])
| 0 | null | 18,243,397,644,228 | 85 | 169 |
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
idx_B = M-1
m = sum(B)
an = M
ans = 0
for a in [0] + A:
m += a
while idx_B >= 0 and m > K:
m -= B[idx_B]
idx_B -= 1
an -= 1
if m > K:
break
if an > ans:
ans = an
an += 1
print(ans)
|
from itertools import accumulate
n,m,k = map(int,input().split())
deskA = list(map(int,input().split()))
deskB = list(map(int,input().split()))
cumA = [0] + list(accumulate(deskA))
cumB = [0] + list(accumulate(deskB))
ans = 0
j = m
for i in range(n+1):
if cumA[i] > k:
continue
while cumA[i] + cumB[j] > k:
j -= 1
ans = max(i+j,ans)
print(ans)
| 1 | 10,806,326,549,330 | null | 117 | 117 |
n = int(raw_input())
print "",
for i in xrange(3,n+1):
x = i
if x % 3 == 0:
print i,
continue
while x:
if x % 10 == 3:
print i,
break
elif x / 10 != 0:
x = x / 10
continue
else:
break
|
# coding: utf-8
N = int(input())
A = [int(i) for i in input().split()]
q = int(input())
m = [int(i) for i in input().split()]
MAX_LENGTH = len(A)
dp = [[-1 for i in range(max(m) + 1)] for j in range(MAX_LENGTH + 1)]
# i番目以降の値を使ってmを作ればTrueを返す
def fullSearch(i, m):
# 終了条件
if m < 0:
return False
elif dp[i][m] != -1:
return dp[i][m]
elif m == 0:
return True
elif i >= MAX_LENGTH:
return False
else:
# 全探索かっこわるい
res = fullSearch(i + 1, m) or fullSearch(i + 1, m - A[i])
# のでメモ化
dp[i][m] = res
return res
for mi in m:
print("yes" if fullSearch(0, mi) else "no")
| 0 | null | 518,322,772,252 | 52 | 25 |
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
dp=[0 for _ in range(N+1)]
dp[1]=0
x=A[0]
for i,a in enumerate(A[1:],2):
if i%2!=0:
dp[i]=max(a+dp[i-2],dp[i-1])
x+=a
continue
dp[i]=max(a+dp[i-2],x)
print(dp[-1])
if __name__ == "__main__":
main()
|
INF = 10**18
def solve(n, a):
# 現在の位置 x 選んだ個数 x 直前を選んだかどうか
dp = [{j: [-INF, -INF] for j in range(i//2-1, (i+1)//2 + 1)} for i in range(n+1)]
dp[0][0][False] = 0
for i in range(n):
for j in dp[i].keys():
if (j+1) in dp[i+1]:
dp[i+1][j+1][True] = max(dp[i+1][j+1][True], dp[i][j][False] + a[i])
if j in dp[i+1]:
dp[i+1][j][False] = max(dp[i+1][j][False], dp[i][j][False])
dp[i+1][j][False] = max(dp[i+1][j][False], dp[i][j][True])
return max(dp[n][n//2])
n = int(input())
a = list(map(int, input().split()))
print(solve(n, a))
| 1 | 37,177,143,825,120 | null | 177 | 177 |
def main():
a, b, c = map(int, input().split())
if a < b < c:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
|
def get_ints():
return map(int, input().split())
def get_list():
return list(map(int, input().split()))
l, r, d = get_ints()
c = 0
for i in range(l, r + 1):
if i % d == 0:
c += 1
print(c)
| 0 | null | 3,981,257,184,352 | 39 | 104 |
def main():
N = int(input())
*A, = map(int, input().split())
ans = sum(A[i] & 1 for i in range(0, N, 2))
print(ans)
if __name__ == '__main__':
main()
|
import math
n = int(input())
a = n/2
print(math.ceil(a)-1)
| 0 | null | 80,409,858,239,480 | 105 | 283 |
def print8f(xy):
from decimal import Decimal, ROUND_HALF_UP
acc = Decimal("0.00000001")
x, y = xy
x = Decimal(str(x)).quantize(acc, rounding=ROUND_HALF_UP)
y = Decimal(str(y)).quantize(acc, rounding=ROUND_HALF_UP)
print("{:.8f} {:.8f}".format(x, y))
def kochCurve(p1p2, n, ang):
from math import sin, cos, radians, sqrt
if n == 0:
print8f(p1p2[1])
return
p1, p2 = p1p2
xd3 = (p2[0] - p1[0]) / 3
yd3 = (p2[1] - p1[1]) / 3
s = [p1[0] + xd3, p1[1] + yd3]
t = [p2[0] - xd3, p2[1] - yd3]
st = sqrt((s[0] - t[0])**2 + (s[1] - t[1])**2)
u = [s[0] + cos(radians(ang + 60)) * st,
s[1] + sin(radians(ang + 60)) * st]
kochCurve([p1, s], n - 1, ang)
kochCurve([s, u], n - 1, ang + 60)
kochCurve([u, t], n - 1, ang - 60)
kochCurve([t, p2], n - 1, ang)
def resolve():
n = int(input())
p1p2 = [[0, 0], [100, 0]]
print8f(p1p2[0])
kochCurve(p1p2, n, 0)
resolve()
|
def gcd(li):
a=max(li)
b=min(li)
while b>0:
a,b=b,a%b
return a
def lcm(li):
return li[0]*li[1]/gcd(li)
while True:
try:
li=[int(i) for i in input().split(" ")]
print("%i %i"%(gcd(li),lcm(li)))
except:break
| 0 | null | 60,258,646,212 | 27 | 5 |
d=int(input())
c=list(map(int,input().split()))
s=[]
for _ in range(d):
s_i=list(map(int,input().split()))
s.append(s_i)
t=[]
for _ in range(d):
t_i=int(input())
t.append(t_i)
dp=[0]*26
ans=0
for i in range(d):
s_i = s[i][t[i]-1]
ans+=s_i
dp[t[i]-1]=i+1
tmp=0
for j in range(26):
tmp+=c[j]*((i+1)-dp[j])
ans -= tmp
print(ans)
|
N, K, *A = [int(_) for _ in open(0).read().split()]
for a, b in zip(A, A[K:]):
print('Yes' if a < b else 'No')
| 0 | null | 8,562,931,448,542 | 114 | 102 |
n = int(input())
arr = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i + 1, n):
for k in range(j + 1, n):
if arr[i] != arr[j] and arr[i] != arr[k] and arr[j] != arr[k]:
if (arr[i] + arr[j]) > arr[k] and (arr[i] + arr[k]) > arr[j] and (arr[j] + arr[k]) > arr[i]:
ans += 1
print(ans)
|
n = int(input())
arr = list(map(int, input().split()))
res = 0
for ii, i in enumerate(arr):
for jj, j in enumerate(arr):
for kk, k in enumerate(arr):
if ii < jj < kk and i != j and j != k and k != i:
if i + j > k and j + k > i and k + i > j:
res += 1
print(res)
| 1 | 5,083,340,378,838 | null | 91 | 91 |
x = int(input())
import math
def check(n):
if n == 1: return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
n = x
while check(n) == False:
n += 1
print(n)
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
D = [len(set(LIST()))==1 for _ in range(N)]
for i in range(N):
if sum(D[i:i+3]) == 3:
print("Yes")
break
else:
print("No")
| 0 | null | 53,918,584,811,598 | 250 | 72 |
s = int(input())
m = s // 60
s = s % 60
h = m // 60
m = m % 60
print("{}:{}:{}".format(h, m, s))
|
S = int(input())
h = S // 3600
m = (S % 3600) // 60
s = (S % 3600) % 60
print(str(h) + ':' + str(m) + ':' + str(s))
| 1 | 332,103,714,240 | null | 37 | 37 |
input()
A = list(map(int, input().split()))
sum = 0
for i in range(1, len(A)):
if A[i] < A[i-1]:
sum += A[i-1] - A[i]
A[i] = A[i-1]
print(sum)
|
a = int(raw_input())
h = a / 3600
m = (a % 3600) / 60
s = a % 60
print "{0}:{1}:{2}".format(h, m, s)
| 0 | null | 2,416,242,388,342 | 88 | 37 |
D,T,S = (int(x) for x in input().split())
disable = D - T*S
if disable>0:
print("No")
else:
print("Yes")
|
from itertools import accumulate
n = int(input())
A = list(map(int, input().split()))
L = [0]
R = []
min_L = float("inf")
for i, a in enumerate(A):
b = A[-(i+1)]
if i%2 == 0:
L.append(a)
else:
R.append(a)
R.append(0)
L = list(accumulate(L))
R = list(accumulate(R[::-1]))[::-1]
ans = -float("inf")
if n%2:
def f(A):
temp = 0
left = 0
right = 0
for i in range(2, n, 2):
temp += A[i]
res = max(ans, temp)
for i in range(1, n//2):
temp -= A[i*2]
left, right = left+A[2*(i-1)], max(left, right)+A[2*(i-1)+1]
res = max(res, temp+max(left, right))
return res
ans = max(f(A), f(A[::-1]))
temp = 0
for i in range(1, n, 2):
temp += A[i]
ans = max(ans, temp)
else:
for l, r in zip(L, R):
ans = max(ans, l+r)
print(ans)
| 0 | null | 20,614,689,273,760 | 81 | 177 |
#n=int(input())
#a==map(int, input().split())
s=input()
print(chr(ord(s[0])+1))
|
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float('inf')
def solve(C: str):
return chr(ord(C)+1)
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
C = next(tokens) # type: str
print(f'{solve(C)}')
if __name__ == '__main__':
main()
| 1 | 92,552,119,650,112 | null | 239 | 239 |
str = input()
if str < 'a':
print('A')
else:
print('a')
|
S=str(input())
if S.isupper()==True:
print("A")
else:
print("a")
| 1 | 11,233,021,669,118 | null | 119 | 119 |
n = int(raw_input())
print "",
for i in xrange(3,n+1):
x = i
if x % 3 == 0:
print i,
continue
while x:
if x % 10 == 3:
print i,
break
elif x / 10 != 0:
x = x / 10
continue
else:
break
|
def main():
N, M, K = [int(x) for x in input().split()]
if M == 1:
if K == N - 1:
return 1
else:
return 0
if N == 1:
return M
mod = 998244353
fact = [1]
for i in range(1, N):
fact.append(fact[-1] * i % mod)
count = 0
for k in range(K + 1):
current = pow(M - 1, N - k - 1, mod) * M % mod
rev = pow(fact[k] * fact[N - 1 - k] % mod, mod - 2, mod)
current = (current * fact[N - 1] % mod) * rev % mod
count = (count + current) % mod
return count
if __name__ == "__main__":
print(main())
| 0 | null | 12,110,988,028,592 | 52 | 151 |
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import copy
import decimal
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [Scanner.string() for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [Scanner.int() for i in range(n)]
def solve():
N, K = Scanner.map_int()
A = Scanner.map_int()
for i in range(K, N):
if A[i - K] < A[i]:
print('Yes')
else:
print('No')
def main():
# sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
solve()
if __name__ == "__main__":
main()
|
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
n,k = map(int,readline().split())
lst1 = list(map(int,readline().split()))
for i in range(n-k):
if lst1[i] >= lst1[i+k]:
print("No")
else:
print("Yes")
| 1 | 7,168,105,960,178 | null | 102 | 102 |
n=int(input())
P=list(map(int,input().split()))
m = n + 1
cnt = 0
for i in range(n):
if m >= P[i]:
m = P[i]
cnt += 1
print(cnt)
|
def main():
n = int(input())
p = [int(i) for i in input().split()]
Min = [10**9]
ans = 0
for i in range(n):
Min.append(min(Min[-1],p[i]))
for i in range(n):
if Min[i]>p[i]:
ans += 1
print(ans)
main()
| 1 | 85,830,877,373,278 | null | 233 | 233 |
print(['SUN','MON','TUE','WED','THU','FRI','SAT'][::-1].index(input())+1)
|
s = input()
l = ['SUN','MON','TUE','WED','THU','FRI','SAT']
i = 7-l.index(s)
print(i)
| 1 | 132,570,138,767,990 | null | 270 | 270 |
# abc161_b.py
# https://atcoder.jp/contests/abc161/tasks/abc161_b
# B - Popular Vote /
# 実行時間制限: 2 sec / メモリ制限: 1024 MB
# 配点 : 200点
# 問題文
# N種類の商品に対して人気投票を行いました。商品 i は Ai票を得ています。
# この中から人気商品 M個を選びます。ただし、得票数が総投票数の 14M未満であるような商品は選べません。
# 人気商品 M個を選べるなら Yes、選べないなら No を出力してください。
# 制約
# 1≤M≤N≤100
# 1≤Ai≤1000
# Aiは相異なる
# 入力は全て整数
# 入力
# 入力は以下の形式で標準入力から与えられる。
# N M
# A1 ... AN
# 出力
# 人気商品 M個を選べるなら Yes、選べないなら No を出力せよ。
# 入力例 1
# 4 1
# 5 4 2 1
# 出力例 1
# Yes
# 総投票数は 12です。1 位の得票数は 5なので、これを選ぶことができます。
# 入力例 2
# 3 2
# 380 19 1
# 出力例 2
# No
# 総投票数は 400です。
# 2,3 位の得票数は総得票数の 14×2 未満なので、これらを選ぶことはできず、人気商品 2個を選べません。
# 入力例 3
# 12 3
# 4 56 78 901 2 345 67 890 123 45 6 789
# 出力例 3
# Yes
global FLAG_LOG
FLAG_LOG = False
def log(value):
# FLAG_LOG = True
# FLAG_LOG = False
if FLAG_LOG:
print(str(value))
def calculation(lines):
# S = lines[0]
# N = int(lines[0])
N, M = list(map(int, lines[0].split()))
values = list(map(int, lines[1].split()))
# values = list(map(int, lines[2].split()))
# values = list()
# for i in range(N):
# values.append(int(lines[i]))
# valueses = list()
# for i in range(N):
# valueses.append(list(map(int, lines[i+1].split())))
values.sort()
values = values[::-1]
log(f'values[M-1]=[{values[M-1]}]')
log(f'1/(4*M)=[{1/(4*M)}]')
if values[M-1]/sum(values) < 1/(4*M):
result = 'No'
else:
result = 'Yes'
return [result]
# 引数を取得
def get_input_lines(lines_count):
lines = list()
for _ in range(lines_count):
lines.append(input())
return lines
# テストデータ
def get_testdata(pattern):
if pattern == 1:
lines_input = ['4 1', '5 4 2 1']
lines_export = ['Yes']
if pattern == 2:
lines_input = ['3 2', '380 19 1']
lines_export = ['No']
if pattern == 3:
lines_input = ['12 3', '4 56 78 901 2 345 67 890 123 45 6 789']
lines_export = ['Yes']
return lines_input, lines_export
# 動作モード判別
def get_mode():
import sys
args = sys.argv
global FLAG_LOG
if len(args) == 1:
mode = 0
FLAG_LOG = False
else:
mode = int(args[1])
FLAG_LOG = True
return mode
# 主処理
def main():
import time
started = time.time()
mode = get_mode()
if mode == 0:
lines_input = get_input_lines(2)
else:
lines_input, lines_export = get_testdata(mode)
lines_result = calculation(lines_input)
for line_result in lines_result:
print(line_result)
# if mode > 0:
# print(f'lines_input=[{lines_input}]')
# print(f'lines_export=[{lines_export}]')
# print(f'lines_result=[{lines_result}]')
# if lines_result == lines_export:
# print('OK')
# else:
# print('NG')
# finished = time.time()
# duration = finished - started
# print(f'duration=[{duration}]')
# 起動処理
if __name__ == '__main__':
main()
|
N = int(input(""))
X = input("").split(" ")
X = [int(b) for b in X]
ans = 0
xb = int(round(sum(X) / len(X)))
for a in X:
ans += (a-xb)**2
print(ans)
| 0 | null | 51,989,248,366,188 | 179 | 213 |
S=input()[::-1]
ans=0
#支払う枚数
array = list(map(int, S))
L=len(array)
for i,n in enumerate(array):
if n< 5 :
ans+=n
elif n > 5:
ans+= 10-n
if i <L-1:
array[i+1] +=1
else:
ans +=1
else:
ans+=5
if i < L-1:
if array[i+1] >=5:
array[i+1] +=1
print( ans)
|
import sys
stdin = sys.stdin
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def ns(): return stdin.readline().rstrip() # ignore trailing spaces
N = ns()
ans = [0, 1000000000]
kuri = [0, 0]
five = 0
for n in N[::-1]:
n = int(n)
# print(ans)
ans_old = [ans[0], ans[1]]
ans[0] = min(ans_old[0] + n, ans_old[1] + n + 1)
ans[1] = min(ans_old[0] + 10 - n, ans_old[1] + 9 - n)
print(min(ans[0], ans[1] + 1))
| 1 | 70,850,473,260,690 | null | 219 | 219 |
N = int(input())
if N == 2:
print(1)
exit()
ans = 1
divisors = []
d = 2
while d*d < N:
if N % d == 0:
divisors.append(d)
divisors.append(N//d)
d += 1
if d*d == N:
divisors.append(d)
for d in divisors:
dummyN = N
while dummyN % d == 0:
dummyN //= d
if dummyN % d == 1:
ans += 1
N -= 1
divisors = []
d = 2
while d*d < N:
if N % d == 0:
divisors.append(d)
divisors.append(N//d)
d += 1
if d*d == N:
divisors.append(d)
ans += len(divisors)+1
print(ans)
|
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF = float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
N = int(input())
S = input()
if N % 2 == 0:
if S[:N//2] == S[N//2:]:
print("Yes")
else:
print("No")
else:
print("No")
| 0 | null | 94,258,876,291,140 | 183 | 279 |
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import itertools
import random
from decimal import *
input = sys.stdin.readline
def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
D = inputInt()
C = inputList()
S = []
for i in range(D):
s = inputList()
S.append(s)
ans1 = []
ans2 = []
for i in range(D):
bestSco1 = 0
bestSco2 = 0
bestI1 = 1
bestI2 = 1
for j,val in enumerate(S[i]):
if j == 0:
tmpAns = ans1 + [j+1]
tmpSco = findScore(tmpAns, S, C)
if bestSco1 < tmpSco:
bestSco2 = bestSco1
bestI2 = bestI1
bestSco1 = tmpSco
bestI1 = j+1
else:
tmpAns1 = ans1 + [j+1]
tmpAns2 = ans2 + [j+1]
tmpSco1 = findScore(tmpAns1, S, C)
tmpSco2 = findScore(tmpAns2, S, C)
if bestSco1 < tmpSco1:
bestSco2 = bestSco1
bestI2 = bestI1
bestSco1 = tmpSco1
bestI1 = j+1
if bestSco1 < tmpSco2:
bestSco2 = bestSco1
bestI2 = bestI1
bestSco1 = tmpSco2
bestI1 = j+1
ans1.append(bestI1)
ans2.append(bestI2)
for i in ans1:
print(i)
def findScore(ans, S, C):
scezhu = [inf for i in range(26)]
sco = 0
for i,val in enumerate(ans):
tmp = S[i][val-1]
scezhu[val-1] = i
mins = 0
for j,vol in enumerate(C):
if scezhu[j] == inf:
mins = mins + (vol * (i+1))
else:
mins = mins + (vol * ((i+1)-(scezhu[j]+1)))
tmp -= mins
sco += tmp
return sco
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
main()
|
import sys
import time
import random
import math
from collections import deque
import heapq
import itertools
from decimal import Decimal
import bisect
from operator import itemgetter
MAX_INT = int(10e18)
MIN_INT = -MAX_INT
mod = 1000000000+7
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()
def tami(ans):
res = 0
LastDay = [0]*26
for i in range(D):
res += s[i][ans[i]]
for j in range(26):
if ans[i] == j:
continue
res -= (i+1 - LastDay[j]) * c[j]
LastDay[ans[i]] = i+1
return res
def nasu():
res = []
LastDay = [0]*26
for d in range(1,D+1):
tmp = ["", 0]
for i in range(26):
if tmp[1] < s[d-1][i] + (d - LastDay[i]) * c[i]:
tmp = [i, s[d-1][i] + (d - LastDay[i]) * c[i]]
res.append(tmp[0])
LastDay[tmp[0]] = d
return res
def nbo(ans, score, num):
tmp_ans = ans[:]
for _ in range(num):
random_date = random.randint(0,D-1)
random_val = random.randint(0,25)
tmp_ans[random_date] = random_val
scoscore = tami(tmp_ans)
if scoscore > score:
return (True, tmp_ans, scoscore)
else:
return (False, tmp_ans, scoscore)
start = time.time()
D = I()
c = IL()
s = [IL() for i in range(D)]
ans = nasu()
#print(ans)
score = tami(ans)
#print(score)
end = time.time()
num = 10
cnt = 0
while (time.time() - start) < 1.8:
judge, anans, scoscore = nbo(ans, score, num)
if judge == True:
ans, score = anans, scoscore
#print(ans)
#print(tami(ans))
cnt += 1
if cnt == 1000:
cnt = 0
num = max(2, num-1)
for i in ans:
print(i+1)
| 1 | 9,706,198,695,798 | null | 113 | 113 |
l = 'abcdefghijklmnopqrstuvwxyz'
mp = [0 for _ in list(l)]
while True:
try:
in_data = list(filter(lambda x: 97 <= ord(x) <= 122 , raw_input().lower()))
except:
break
for s in in_data:
mp[ord(s) - 97] += 1
for i,j in zip(l, mp):
print "%s : %s" % (i, j)
|
import sys
alp=[]
for i in range(97,97+26):
alp.append(chr(i))
s=sys.stdin.read().lower()
for i in alp:
num=0
for j in s:
if i==j:
num+=1
print(i+' : '+str(num))
| 1 | 1,647,958,743,750 | null | 63 | 63 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
N,T = map(int,readline().split())
m = map(int,read().split())
AB = sorted(zip(m,m))
can_add = [0] * N
for n in range(N-1,0,-1):
x = can_add[n]
y = AB[n][1]
can_add[n-1] = x if x > y else y
dp = np.zeros(T,np.int64)
answer = 0
for i,(a,b) in enumerate(AB):
np.maximum(dp[a:], dp[:-a] + b, out = dp[a:])
x = dp.max() + can_add[i]
if answer < x:
answer = x
print(answer)
|
a,b=(int(x) for x in input().split())
print(a*b)
| 0 | null | 83,849,874,456,320 | 282 | 133 |
import itertools
N, M, Q = map(int, input().split())
max = 0
s = ''
for i in range(M):
s += str(i)
l = list(itertools.combinations_with_replacement(s, N))
m = [list(map(int, input().split())) for i in range(Q)]
for x in l:
count = 0
for y in m:
if int(x[y[1] - 1]) - int(x[y[0] - 1]) == y[2]:
count += y[3]
if count > max:
max = count
print(max)
|
n,s = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
mod = 998244353
dp = [[0 for i in range(s+1)] for j in range(n+1)]
dp[0][0] = 1
for i in range(n):
for x in range(s+1):
dp[i+1][x] = 2*dp[i][x]
if x-a[i] >= 0:
dp[i+1][x] += dp[i][x-a[i]]
dp[i+1][x] %= mod
print(dp[n][s])
| 0 | null | 22,669,373,456,030 | 160 | 138 |
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
B = []
C = []
for q in range(Q):
b, c = map(int, input().split())
B.append(b)
C.append(c)
sam = sum(A)
baketu = [0]*(100001)
for a in A:
baketu[a] += 1
for q in range(Q):
sam = sam + baketu[B[q]] * (C[q] - B[q])
baketu[C[q]] += baketu[B[q]]
baketu[B[q]] = 0
#print(baketu)
print(sam)
|
N=int(input())
A=list(map(int,input().split()))
SUM=sum(A)
Q=int(input())
List=[0 for _ in range(10**5+1)]
for a in A:
List[a]+=1
for q in range(Q):
B,C=map(int,input().split())
SUM-=B*List[B]
SUM+=C*List[B]
List[C]+=List[B]
List[B]=0
print(SUM)
| 1 | 12,097,936,517,832 | null | 122 | 122 |
N=int(input())
l=list(map(int,input().split()))
count=0
for k in range(1,N+1):
if k%2==1 and l[k-1]%2==1:
count+=1
print(count)
|
import sys
import math
import heapq
import bisect
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())
def FLIST(n):
res = [1]
for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
return res
def gcd(x, y):
if x < y: x, y = y, x
div = x % y
while div != 0:
x, y = y, div
div = x % y
return y
N,M=LI()
As=LI()
As.sort()
len_As = len(As)
Acum=[As[0]]
for i in range(1, len_As):
Acum.append(Acum[i-1]+As[i])
# print(As)
# print(Acum)
ok = 0
ng = 2*max(As)+1
pat = 0
sm = 0
while ng - ok > 1:
mid_sum = (ok + ng)//2
pat = 0
sm = 0
for A in As:
A2 = mid_sum - A
# print(A2)
lft = bisect.bisect_left(As, A2)
pat += len_As - lft
sm += Acum[len_As-1] - (lft and Acum[lft-1]) + (len_As - lft)*A
# print(pat, M, ok, ng)
if pat < M: ng = mid_sum
else: ok = mid_sum
pat = 0
sm = 0
for A in As:
A2 = ok - A
# print(A2)
lft = bisect.bisect_left(As, A2)
pat += len_As - lft
sm += Acum[len_As-1] - (lft and Acum[lft-1]) + (len_As - lft)*A
# print("lo:{} hi:{} pat:{} sum:{}".format(ok, ng, pat, sm))
print(sm - (pat-M)*ok)
| 0 | null | 57,876,498,164,000 | 105 | 252 |
n, m, l = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(m)]
for i in a:
c = []
for j in zip(*b):
c.append(sum([k * l for k, l in zip(i, j)]))
print(*c)
|
def sep():
return map(int,input().strip().split(" "))
def lis():
return list(sep())
n=int(input())
ar=lis()
data=[]
for i in range(n):
data.append((ar[i],i))
data.sort(reverse=True)
dp = [[0] * (n+1) for _ in range(n+1)]
for i in range(n):
a, p = data[i]
for j in range(i+1):
dp[i+1][j+1] = max(dp[i+1][j+1],dp[i][j] + abs(n-1-j-p)*a)
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + abs(i-j-p)*a)
#print(dp)
print(max(dp[-1]))
| 0 | null | 17,476,297,139,620 | 60 | 171 |
import sys
n = int(input())
A = list(map(int,sys.stdin))
cnt = 0
G = [int((2.15**i-1)/1.15)for i in range(17,0,-1)]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print('\n'.join(map(str,A)))
|
#import math
import collections
#n,k = map(int, input().split( ))
#A = list(map(int, input().split( )))
n = int(input())
A = list(map(int, input().split( )))
c = collections.Counter(A)
a = c.most_common()[0][1]
if a != 1:
print('NO')
else:
print('YES')
| 0 | null | 37,152,150,736,220 | 17 | 222 |
def main():
N, K = map(int, input().split())
ans = 0
while N > 0:
N //= K
ans += 1
print(ans)
if __name__ == '__main__':
main()
|
N=int(input())
L=list(map(int, input().split()))
count=0
for i in range(N):
for j in range(i+1,N):
for k in range(j+1,N):
L2=[L[i],L[j],L[k]]
L2.sort()
if L2[0]+L2[1]>L2[2] and L2[0] != L2[1] and L2[1] != L2[2] and L2[2] != L2[0]:
count+=1
print(count)
| 0 | null | 34,831,252,377,050 | 212 | 91 |
import math
while True:
n = int(input())
if n == 0:
break
s = [int(s) for s in input().split()]
ave = sum(s) / n
a = 0
for N in s:
a += (N - ave)**2
a = math.sqrt((a / n))
print(a)
|
import statistics
while True:
num = input()
if num == '0':
break
value = map(int, input().split())
print(statistics.pstdev(value))
| 1 | 195,062,823,620 | null | 31 | 31 |
n, k = map(int, raw_input().split())
w = [int(raw_input()) for _ in xrange(n)]
def check(P):
i = 0
for j in range(k):
s = 0
while s + w[i] <= P:
s += w[i]
i += 1
if i == n:
return True
return False
def solver():
left, right = 0, 100000 * 10000
while left < right:
mid = int((left + right) / 2)
if check(mid):
right = mid
else:
left = mid + 1
return right
print solver()
|
import sys
import heapq
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N, K = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
MOD = 10 ** 9 + 7
plus = []
minus = []
for a in A:
if a >= 0:
heapq.heappush(plus, -a)
else:
heapq.heappush(minus, a)
ans = 1
# 絶対マイナスになる場合
if len(plus) < K - min((K - K % 2), (len(minus) - len(minus) % 2)):
plus = []
minus = []
for a in A:
if a >= 0:
heapq.heappush(plus, a)
else:
heapq.heappush(minus, -a)
while K > 0:
if plus:
x = plus[0]
else:
x = float("inf")
if minus:
y = -minus[0]
else:
y = float("inf")
if abs(x) <= abs(y):
ans *= x
if plus:
heapq.heappop(plus)
else:
ans *= y
if minus:
heapq.heappop(minus)
ans %= MOD
K -= 1
print(ans)
else:
while K > 0:
if K >= 2 and len(minus) >= 2 and len(plus) >= 2:
x1 = plus[0]
x2 = plus[1]
y1 = minus[0]
y2 = minus[1]
if x1 * x2 <= y1 * y2:
y1 = heapq.heappop(minus)
y2 = heapq.heappop(minus)
ans *= (y1 * y2)
ans %= MOD
K -= 2
else:
x1 = -heapq.heappop(plus)
ans *= x1
ans %= MOD
K -= 1
elif K >= 2 and len(minus) >= 2:
y1 = heapq.heappop(minus)
y2 = heapq.heappop(minus)
ans *= (y1 * y2)
ans %= MOD
K -= 2
else:
x = -heapq.heappop(plus)
ans *= x
ans %= MOD
K -= 1
print(ans % MOD)
if __name__ == '__main__':
main()
| 0 | null | 4,739,538,993,728 | 24 | 112 |
from collections import defaultdict
def main():
n = int(input())
a = list(map(int, input().split(" ")))
d = defaultdict(lambda:0)
for i in range(n):
d[a[i]] += 1
if max(d.values()) >1:
print("NO")
else:
print("YES")
if __name__ == "__main__":
main()
|
IN = [i for i in map(int,input().split())]
K = IN[3]
A = min(IN[0],K)
B = min(IN[1], K -A)
C = min(IN[2],K -A- B)
print(A*1+B*0+C*(-1))
| 0 | null | 48,016,253,971,520 | 222 | 148 |
num_list = []
while True:
values = [int(x) for x in input().split()]
if 0 == values[0] and 0 == values[1]:
break
num_list.append(values)
for n, t in num_list:
ret = ' '.join(str(x + y + z) for x in range(1, n + 1) for y in range(x + 1, n + 1) for z in range(y + 1, n + 1))
cnt = 0
for x in ret.split():
if str(t) == x:
cnt += 1
print(cnt)
|
import sys
for i in sys.stdin:
n,x = map(int,i.split())
s = 0
if n==0 and x==0:
break
if x <= 3*n-3 and x >= 6:
for i in range(1,min(n-1,x//3)):
s += len(range(max(i+1,x-i-n),min(n,(x-i+1)//2)))
print(s)
| 1 | 1,283,270,642,250 | null | 58 | 58 |
A, B, K = map(int, input().split())
if K >= A+B:
print("0 0")
elif K <= A:
print("{} {}".format(A-K, B))
elif K > A:
print("0 {}".format(B-(K-A)))
|
A,B,K = map(int, input().split())
print(A-K, B) if K <= A else print(0,0) if (A+B) <= K else print(0, A+B-K)
| 1 | 104,480,996,565,370 | null | 249 | 249 |
X, Y = map(int, input().split())
mod = 10**9 + 7
def permute(n, m):
ret = 1
while n >= m:
ret *= n
# ret %= mod
n -= 1
return ret
def count_combinations(n, m):
fact = [1] * (n + 1)
inv = [i for i in range(n+1)]
fact_inv = [1] * (n + 1)
for i in range(2, n+1):
fact[i] = fact[i-1] * i % mod
inv[i] = (-inv[mod%i]*(mod//i))%mod
# inv[i] = mod - inv[mod % i] * (mod // i) % mod
fact_inv[i] = fact_inv[i-1] * inv[i] % mod
ret = (fact[n] * fact_inv[m] * fact_inv[n-m]) % mod
return ret
def count_comb2(n, m):
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, n + 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
if (m < 0) or (n < m):
return 0
m = min(m, n - m)
return fact[n] * factinv[m] * factinv[n-m] % mod
ret = 0
if (X+Y)%3 == 0:
m = (2*X - Y) // 3
n = (2*Y - X) // 3
if m >= 0 and n >= 0:
ret = count_combinations(n+m, m)
# ret = count_comb2(n+m, m)
print(ret)
|
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))
js = [None for _ in range(n)] # 周期とスコア増分
for s in range(n):
if js[s]:
continue
m = s
tmp = 0
memo = [[] for _ in range(n)]
i = 0
while True:
m = p[m] - 1
tmp += c[m]
memo[m].append((i, tmp))
if len(memo[m]) > 1:
js[m] = (memo[m][1][0] - memo[m][0][0], memo[m][1][1] - memo[m][0][1])
if len(memo[m]) > 2:
break
i += 1
ans = -100000000000
for s in range(n):
m = s
tmp = 0
visited = [0] * n
for i in range(k):
m = p[m] - 1
if visited[m]:
break
visited[m] = 1
tmp += c[m]
if js[m] and js[m][1] > 0:
ans = max(ans, tmp + js[m][1] * ((k - i - 1) // js[m][0]))
else:
ans = max(ans, tmp)
print(ans)
| 0 | null | 77,768,704,800,842 | 281 | 93 |
def main():
X, Y, A, B, C = map(int, input().split())
*P, = map(int, input().split())
*Q, = map(int, input().split())
*R, = map(int, input().split())
P.sort(reverse=True)
Q.sort(reverse=True)
ans = sum(sorted(P[:X] + Q[:Y] + R, reverse=True)[:X + Y])
print(ans)
if __name__ == '__main__':
main()
|
X, Y, A, B, C = map(int, input().split())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
r = list(map(int, input().split()))
p.sort(reverse=True)
q.sort(reverse=True)
cand = p[0:X] + q[0:Y] + r
cand.sort(reverse=True)
ans = sum(cand[0:X+Y])
print(ans)
| 1 | 44,775,534,622,832 | null | 188 | 188 |
N=int(input())
A=list(map(int, input().split()))
q=int(input())
Q=[list(map(int, input().split())) for _ in range(q)]
L=[0]*(10**5+1)
S=0
for i in range(N):
L[A[i]]+=1
S+=A[i]
for i in range(q):
S+=L[Q[i][0]]*(Q[i][1]-Q[i][0])
L[Q[i][1]]+=L[Q[i][0]]
L[Q[i][0]]=0
# print(L)
print(S)
|
import numpy as np
from collections import Counter
N=int(input())
Alist=list(map(int,input().split()))
Q=int(input())
bc=[]
for _ in range(Q):
bc.append(list(map(int,input().split())))
count=Counter(Alist)
result=0
for key,value in count.items():
result+=key*value
for i in range(Q):
if bc[i][0] in count.keys():
result+=(bc[i][1]-bc[i][0])*count[bc[i][0]]
count[bc[i][1]]+=count[bc[i][0]]
count[bc[i][0]]=0
print(result)
| 1 | 12,129,856,684,996 | null | 122 | 122 |
N = int(input())
music = []
for i in range(N):
music.append(input().split())
X = (input())
Time = 0
kama = False
for s,t in music:
if kama:
Time += int(t)
if s == X:
kama = True
print(Time)
|
H, W, _ = map(int, input().split())
L = [list(str(input())) for _ in range(H)]
ans = [[] * W for _ in range(H)]
k = 1
cnt = 1
for h in range(H):
if '#' not in L[h]:
cnt += 1
else:
pre = -1
for w in range(W):
if L[h][w] == '#':
for i in range(cnt):
ans[h-i].extend([k] * (w - pre))
k += 1
pre = w
else:
for i in range(cnt):
ans[h-i].extend([k-1] * (W - 1 - pre))
cnt = 1
cnt = 0
i = 1
while True:
if '#' not in L[-i]:
cnt += 1
i += 1
else:
break
for i in range(cnt):
ans[-cnt+i] = ans[-cnt-1]
for row in ans:
print(*row)
| 0 | null | 120,045,270,342,690 | 243 | 277 |
import sys
def input(): return sys.stdin.readline().strip()
def main():
N, M = map(int, input().split())
S = input()
def isOK(index):
return S[index] == "0"
ans = []
now = N
while now:
for step in range(min(now, M), -1, -1):
if step == 0:
print(-1)
exit()
if isOK(now-step):
ans.append(step)
now -= step
break
print(*ans[::-1], sep=" ")
if __name__ == "__main__":
main()
|
N,M = map(int,input().split())
S = input()
ans = []
i = N
while i > 0:
for m in range(M,0,-1):
if i-m <= 0:
ans.append(i)
i = 0
break
if S[i-m]=='0':
ans.append(m)
i -= m
break
else:
print(-1)
exit()
print(*ans[::-1])
| 1 | 138,508,748,479,520 | null | 274 | 274 |
import sys
from sys import stdin
input = stdin.readline
n,k = (int(x) for x in input().split())
w = [int(input()) for i in range(n)]
# 最大積載Pのトラックで何個の荷物を積めるか
def check(P):
i = 0
for j in range(k):
s = 0
while s + w[i] <= P:
s += w[i]
i += 1
if i == n:
return n
return i
def solve():
left = 0
right = 100000 * 10000 #荷物の個数 * 1個当たりの最大重量
while right - left > 1 :
mid = (right + left)//2
v = check(mid)
if v >= n:
right = mid
else:
left = mid
return right
print(solve())
|
from __future__ import print_function
import sys
sys.setrecursionlimit(500000)
import re
import array
import copy
import functools
import operator
import math
import string
import fractions
from fractions import Fraction
import collections
import itertools
import bisect
import random
import time
import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue
from itertools import accumulate
from collections import deque
from collections import Counter
from operator import mul
from functools import reduce
input = sys.stdin.readline
def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
return
# from fractions import gcd
# from math import gcd
# def lcm(n, m):
# return int(n * m / gcd(n, m))
# def coprimize(p, q):
# common = gcd(p, q)
# return (p // common, q // common)
# def find_gcd(list_l):
# x = reduce(gcd, list_l)
# return x
# def combinations_count(n, r):
# r = min(r, n - r)
# numer = reduce(mul, range(n, n - r, -1), 1)
# denom = reduce(mul, range(1, r + 1), 1)
# return numer // denom
# mod=1000000007
# def combinations_count_mod(n, r):
# r = min(r, n - r)
# numer = reduce(lambda x,y: x*y%mod, range(n, n - r, -1), 1)
# denom = pow( reduce(lambda x,y: x*y%mod, range(1, r + 1), 1) , mod-2, mod)
# return numer * denom % mod
def is_ok(p,n,k,w):
#
i_track = 0
i_w = 0
# トラックに積めるギリギリ(p)まで積んでいくことを繰り返していって，
# i_w(w_index) を0 ~ n-1 まで全部積めたら嬉しいねぇ
# 積載量pが小さすぎるゴミみてぇなトラックだったら先にトラックの数が尽きてしまって悲しいことになります
# 積載量pが十分大きい素敵なトラックだったら i_w(w_index) = n - 1 まで到達できてとっても嬉しくなれます
while i_track < k and i_w < n : # トラック全部
temp=0
while i_w < n and temp + w[i_w] <= p: # 一時積載tempがpを超えないギリギリを目指していけ
temp += w[i_w]
i_w+=1
# ギリギリまで ，背番号i_trackのトラック ，つまり今見ているトラックに積載したら
i_track += 1 #次のトラックに進みましょうね〜〜〜
return i_w == n
def solve(n,k,w):
#
ok = 10000 * 100000 # solve(ok)は解が存在すると分かっているような整数ok
ng = -1 # solve(ng)は解が存在しない(と分かっているような整数ng
ans = ok
# abs(ok-ng) つまり ok と ng の絶対差ですね，これが1未満つまりokとngが等しいということになったらですね，終了するんですね
while abs( ok - ng ) > 1: #abs(ok-ng) <= 1 というのはokとngがもうなんかね，アレなんですよ
mid = (ok + ng) // 2
#
if is_ok(mid,n,k,w):
ok = mid
ans = ok
else:
ng = mid
return ans
def main():
n,k = map(int,input().strip().split())
w=[]
for i in range(n):
w.append(int(input().strip()))
print(solve(n,k,w))
if __name__ == '__main__':
main()
| 1 | 87,792,570,150 | null | 24 | 24 |
A,B,C,K = [int(x) for x in input().split()]
if(A >= K):
print(K)
exit()
K = K - A
if(B >= K):
print(A)
exit()
K = K - B
print(A-K)
|
nk=list(map(int, input().split()))
a=list(map(int, input().split()))
n=nk[0]
k=nk[1]
for i in range(n-k):
if(a[i]<a[i+k]):
print("Yes")
else:
print("No")
| 0 | null | 14,601,872,708,348 | 148 | 102 |
N=int(input())
a=list(map(int,input().split()))
z=0
for i in range(0,N,2):
if int(a[i])%2==1:
z+=1
print(z)
|
N = int(input())
print(N + N**2 + N**3)
| 0 | null | 9,002,670,493,978 | 105 | 115 |
h,w,n=[int(input()) for _ in range(3)]
m=max(h,w)
print(0--n//m)
|
A,B,K = list(map(int,input().split()))
if K <= A:
print(A - K, B)
if A < K and K <= A + B:
print(0, A + B - K)
if A + B < K:
print(0, 0)
| 0 | null | 96,114,771,312,212 | 236 | 249 |
import sys
while(1):
H,W = map(int, raw_input().split())
if H==0 and W==0:
break
for i in range(H):
for j in range(W):
sys.stdout.write("#")
print ""
print ""
|
# coding: utf-8
# Your code here!
while(1):
H,W=map(int,input().split(" "))
if H==0 and W==0:
break
else:
for i in range(H):
for j in range(W):
print("#",end="")
print("")
print("")
| 1 | 774,242,793,520 | null | 49 | 49 |
num = list(map(int, input().split()))
class Dice:
def __init__(self, num):
self.state = {}
for i in range(1,6+1):
self.state[i] = num[i-1]
self.reversed_state = {}
for key,val in zip(self.state.keys(), self.state.values()):
self.reversed_state[val] = key
def search_side(self, x,y):
a = self.reversed_state[x]
b = self.reversed_state[y]
if str(a)+str(b) in '12651':
side = self.state[3]
elif str(b)+str(a) in '12651':
side = self.state[4]
elif str(a)+str(b) in '13641':
side = self.state[5]
elif str(b)+str(a) in '13641':
side = self.state[2]
elif str(a)+str(b) in '23542':
side = self.state[1]
elif str(b)+str(a) in '23542':
side = self.state[6]
return side
dice = Dice(num)
q = int(input())
for _ in range(q):
x,y = map(int, input().split())
ans = dice.search_side(x,y)
print(ans)
|
from math import cos,sin, pi
n = int(input())
def koch(n, l, r):
if n == 0:
return
s = ((2*l[0] + r[0])/3, (2*l[1] + r[1])/3)
t = ((l[0] + 2*r[0])/3, (l[1] + 2*r[1])/3)
u = ((t[0] - s[0]) * cos(pi/3) - (t[1] - s[1]) * sin(pi/3) + s[0],
(t[0] - s[0]) * sin(pi/3) + (t[1] - s[1]) * cos(pi/3) + s[1])
koch(n - 1, l, s)
print(s[0], s[1])
koch(n - 1, s, u)
print(u[0], u[1])
koch(n - 1, u, t)
print(t[0], t[1])
koch(n - 1, t, r)
print(0, 0)
koch(n, (0, 0), (100, 0))
print(100, 0)
| 0 | null | 188,699,160,360 | 34 | 27 |
A, B, C = list(map(int, input().split()))
s = set([A, B, C])
if len(s) == 1 or len(s) == 3:
print('No')
else:
print('Yes')
|
print('Yes' if len(set(map(int, input().split()))) == 2 else 'No')
| 1 | 67,971,292,105,850 | null | 216 | 216 |
k,n = map(int,(input().split()))
a = list(map(int,input().split()))
maxDis = 0
for i in range(len(a)-1):
if i == 0:
maxDis = a[i]+k-a[i-1]
elif abs(a[i]-a[i-1]) > maxDis:
maxDis = abs(a[i]-a[i-1])
if abs(a[i]-a[i+1]) > maxDis:
maxDis = abs(a[i]-a[i+1])
print(k-maxDis)
|
n = int(input())
if n % 2: print(0); exit()
n //= 2
ans = 0
while n >= 5:
n //= 5
ans += n
print(ans)
| 0 | null | 79,471,069,175,612 | 186 | 258 |
#ABC162-E Sum of gcd of Tuples(Hard)
"""
問題を「1~kまでの数字を用いた長さnの数列において、gcdがDになる数列はいくつあるか」
というふうに置き換える。(1<=D<=k)
更に制約を替えて、gcdが"Dの倍数"(但し,k以下)でも良いのでそれを全て求めよ、
というふうになった場合、全ての要素はD*n(nは整数,D*n<=k)となる。
この制約によって、そのような数列の数は(k/D)^nとして表せる。(これが大事)
例：
n = 3,k = 4の場合で、D(gcd)=2について求める
(4//2)**3 = 8※
そこで、大きい方からgcdがDになる数列の個数(これをメモ化)を求めていった場合、
Dの倍数がk以下であるならば、予めメモしておいたその値分を引いてやる。
これによって全ての通り数が求まる。
例の続き:
D=2について、D*n <= k という制約のもとでn=2が存在する。
D = 2*2 = 4の時の通り数は、4,4,4の1通り※なので、
D(gcd)=2となるパターン数は、※より、
8-1=7 となる。
(この7通りは2と4からなる数列で、全ての値が4になる場合を引いている)
"""
import sys
readline = sys.stdin.buffer.readline
n,k = map(int,readline().split())
mod = 10**9+7
ans = 0
count = [0]*(k+1)
for D in range(k,0,-1):
mul = k//D #何倍まであり得るか(あり得るものをcountから引く)
res = pow(mul,n,mod)
for i in range(2,mul+1):
res -= count[i*D]
count[D] = res #個数
ans += res*D #個数*値(求めたいのはgcdの合計値のため)
ans %= mod
print(ans)
|
S = input()
Sr = S[ : : -1]
hug = 0
for i in range(len(S)):
if S[i] != Sr[i]:
hug += 1
print((hug + 1) // 2)
| 0 | null | 78,459,792,343,548 | 176 | 261 |
import collections
n = int(input())
d = list(map(int,input().split()))
ma = max(d)
mod = 998244353
if d[0] != 0:
print(0)
exit()
p = [0 for i in range(ma+1)]
for i in range(n):
p[d[i]] += 1
if p[0] != 1:
print(0)
exit()
else:
ans = 1
for i in range(1,ma+1):
ans *= (p[i-1]**p[i])%mod
ans %= mod
print(ans)
|
from collections import*
n=input()
a=list(map(int,input().split()))
d=dict(Counter(a))
mod=998244353
ans=a[0]==0 and d[0]==1
for i in d:
if i==0:continue
ans*=pow(d.get(i-1,0),d[i],mod)
ans%=mod
print(ans)
| 1 | 154,312,876,838,552 | null | 284 | 284 |
x, y = map(int, input().split())
answer = 0
for a in [x, y]:
if a == 3:
answer += 100000
elif a == 2:
answer += 200000
elif a == 1:
answer += 300000
else:
pass
if x == 1 and y == 1:
answer += 400000
print(answer)
|
def main():
N = int(input())
A,B = [],[]
for _ in range(N):
a,b = [int(x) for x in input().split()]
A.append(a)
B.append(b)
A.sort()
B.sort()
if N % 2 == 1:
minMed = A[N//2]
maxMed = B[N//2]
print(int(maxMed-minMed)+1)
else:
minMed = A[N//2-1] + A[N//2]
maxMed = B[N//2-1] + B[N//2]
print(int(maxMed-minMed)+1)
if __name__ == '__main__':
main()
| 0 | null | 78,636,911,756,200 | 275 | 137 |
str_num = input()
num_list = str_num.split()
answer = int(num_list[0]) * int(num_list[1])
print(answer)
|
def main():
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
total_T_in_A = [0] * (N+1)
total_T_in_B = [0] * (M+1)
for i in range(1, N+1):
total_T_in_A[i] = total_T_in_A[i-1] + A[i-1]
for i in range(1, M+1):
total_T_in_B[i] = total_T_in_B[i-1] + B[i-1]
result = 0
for i in range(N+1):
# A から i 冊読むときにかかる時間
i_A_T = total_T_in_A[i]
if K < i_A_T:
continue
if K == i_A_T:
result = max(result, i)
continue
rem_T = K - i_A_T
# total_T_in_B は累積和を格納した、ソート済の配列
# B_i <= rem_T < B_i+1 となるような B_i を二分探索によって探す
first = total_T_in_B[1]
last = total_T_in_B[M]
if rem_T < first:
result = max(result, i)
continue
if last <= rem_T:
result = max(result, i + M)
continue
# assume that first <= rem_T <= last
first = 1
last = M
while first < last:
if abs(last - first) <= 1:
break
mid = (first + last) // 2
if rem_T < total_T_in_B[mid]:
last = mid
else:
first = mid
result = max(result, i + first)
print(result)
main()
| 0 | null | 13,386,894,322,908 | 133 | 117 |
x = list(map(int , input().split()))
s = set()
for i in x:
if i not in s:
s.add(i)
if len(s) == 2:
print('Yes')
else:
print('No')
|
a, b, c = map(int, input().split())
ret = "No"
if (a == b and a != c) or (b == c and c != a) or (c == a and a != b):
ret = "Yes"
print("{}".format(ret))
| 1 | 68,131,956,332,132 | null | 216 | 216 |
import numpy
a,b,x=map(int,input().split())
V=a*a*b
if x<=V/2:
y=2*x/b/a
theta=numpy.arctan(b/y)
print(theta*360/2/numpy.pi)
else:
x=V-x
y=2*x/a/a
theta=numpy.arctan(y/a)
print(theta*360/2/numpy.pi)
|
import math
a, b, x = map(int, input().split())
x /= a
def is_ok(theta):
if math.tan(theta) * b < a:
return x <= math.tan(theta) * b * b / 2
else:
p = a/math.tan(theta)
return x <= a*p/2+a*(b-p)
def bisect(ng, ok):
while (abs(ok - ng) > 1e-9):
mid = (ok + ng) / 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
ans = bisect(0, math.pi)
ans = 90- ans * 180 / math.pi
print(ans)
| 1 | 162,973,833,944,032 | null | 289 | 289 |
def solve():
N = int(input())
A = [int(i) for i in input().split()]
ans = 1
for i in range(N):
if ans == -1 and A[i] != 0:
continue
ans *= A[i]
if ans > 10**18:
ans = -1
print(ans)
if __name__ == "__main__":
solve()
|
K = int(input())
K1 = "ACL"
print(K*K1)
| 0 | null | 9,291,141,613,880 | 134 | 69 |
a,v = map(int, input().split())
b,w = map(int, input().split())
T = int(input())
if abs(b-a) <= (v-w)*T:
print('YES')
else:
print('NO')
|
import math
from math import gcd
INF = float("inf")
import sys
input=sys.stdin.readline
import itertools
def main():
n, m = map(int , input().split())
print(n*(n-1)//2+m*(m-1)//2)
if __name__=="__main__":
main()
| 0 | null | 30,225,974,568,452 | 131 | 189 |
s = input()
t = input()
print("Yes" if s == t[:len(t) - 1] else "No")
|
import itertools
n = int(input())
d = list(map(int, input().split()))
sum = 0
for i in itertools.combinations(d, 2):
sum += i[0] * i[1]
print(sum)
| 0 | null | 94,804,060,279,978 | 147 | 292 |
class UnionFind:
def __init__(self,n):
self.par = {i:i for i in range(1,n+1)}
self.rank = {i:0 for i in range(1,n+1)}
self.size = {i:1 for i in range(1,n+1)}
def find(self,x):
if x != self.par[x]:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self,x,y):
px,py = self.find(x),self.find(y)
res = 0
if px != py:
if self.rank[px] < self.rank[py]:
self.par[px] = py
self.size[py] += self.size[px]
res = self.size[py]
else:
self.par[py] = px
self.size[px] += self.size[py]
if self.rank[px] == self.rank[py]:
self.rank[px] += 1
res = self.size[px]
return res
n,m = map(int,input().split())
ans = 1
uf = UnionFind(n)
for _ in range(m):
a,b = map(int,input().split())
ans = max(ans,uf.union(a,b))
print(ans)
|
from collections import deque
n, x, y = map(int, input().split())
g = [[] for _ in range(n)]
for i in range(n - 1):
g[i].append(i + 1)
g[i + 1].append(i)
g[x - 1].append(y - 1)
g[y - 1].append(x - 1)
def bfs(g, n_node, start_node):
dist = [-1] * n_node
dist[start_node] = 0
que = deque([start_node])
while que:
node = que.popleft()
for j in g[node]:
if dist[j] != -1:
continue
dist[j] = dist[node] + 1
que.append(j)
return dist
ans = [0] * n
for i in range(n):
dist = bfs(g, n, i)
for d in dist:
ans[d] += 1
for a in ans[1:]:
print(a//2)
| 0 | null | 24,046,945,459,340 | 84 | 187 |
N = int(input())
AS = [int(i) for i in input().split()]
m = 10 ** 18
acc = 1
if 0 in AS:
print(0)
import sys
sys.exit()
for i in AS:
acc *= i
if acc > m:
print('-1')
import sys
sys.exit()
print(acc)
|
N = int(input())
sum_ = 0
for i in range(1, N + 1):
n = int(N / i)
sum_ += (n / 2) * (2 * i + (n - 1) * i)
print(int(sum_))
| 0 | null | 13,639,037,779,008 | 134 | 118 |
h,n = map(int,input().split())
Mag = []
for i in range(n):
AB = list(map(int,input().split()))
Mag.append(AB)
dp = [[float("inf")]*(h+1) for i in range(n+1)]
dp[0][0] = 0
for i in range(n):
for j in range(h+1):
dp[i+1][j] = min(dp[i+1][j],dp[i][j])
dp[i+1][min(j+Mag[i][0],h)] = min(dp[i+1][min(j+Mag[i][0],h)],dp[i+1][j]+Mag[i][1])
print(dp[n][h])
|
s = input()
n = len(s)
print("x"*n)
| 0 | null | 76,572,192,582,344 | 229 | 221 |
while(True):
n=int(input())
if(n==0):
break
val=list(map(int, input().split()))
sum=0
for i in val:
sum+=i
mean=sum/n
disp=0
for i in val:
disp+=(i-mean)**2
disp=disp/n
print(disp**0.5)
|
print('Yes' if input() in ['hi'*i for i in range(1,6)] else 'No')
| 0 | null | 26,560,309,527,798 | 31 | 199 |
def main():
x, n = map(int, input().split())
if n == 0:
print(x)
return
p_tuple = tuple(map(int, input().split()))
radius = 0
for i in range(100):
if x-radius not in p_tuple:
print(x-radius)
return
elif x+radius not in p_tuple:
print(x+radius)
return
else:
radius += 1
if __name__ == '__main__':
main()
|
import math
n = int(input())
def f(x,y,z):
return x**2 + y**2 + z**2 + z*x + x*y + y*z
current = [1,1,1]
ans = 0
p = [0 for _ in range(n+1)]
m = math.ceil(math.sqrt(n))+1
for i in range(1, m):
f_ = f(i, 1, 1)
if f_ > n:
break
for j in range(1, m):
f_ = f(i,j,1)
if f_ > n:
break
for k in range(1, m):
f_ = f(i,j,k)
if f_ > n:
break
p[f_] += 1
for i in range(1, n+1):
print(p[i])
| 0 | null | 11,118,840,493,880 | 128 | 106 |
#! /usr/bin/env python
# -*- coding : utf-8 -*-
input()
seq = [int(x) for x in input().split()]
for i in range(0, len(seq)):
key = seq[i]
j = i - 1
assert isinstance(i, int)
while j >= 0 and seq[j] > key:
seq[j + 1] = seq[j]
j -= 1
seq[j + 1] = key
print(' '.join(map(str,seq)))
|
S = list(input())
N = len(S)
if N % 2 == 0:
m = int(N/2)
LS = S[:m]
RS = S[N:m-1:-1]
ans = 0
for i in range(m):
if LS[i] == RS[i]:
pass
else:
ans += 1
else:
m = int((N+1)/2)
LS = S[:m-1]
RS = S[N:m-1:-1]
ans = 0
for i in range(m-1):
if LS[i] == RS[i]:
pass
else:
ans += 1
print(ans)
| 0 | null | 59,893,990,484,800 | 10 | 261 |
while True:
H, W = list(map(int, input().split()))
if H == 0 and W == 0:
break
for height in range(H):
for wide in range(W):
if height == 0 or height == H-1 or wide == 0 or wide == W-1:
print('#', end='')
else:
print('.', end='')
print('')
print('')
|
while True:
h,w=map(int,input().split())
if h==0 and w==0:
break
for y in range(h):
for x in range(w):
if y==0 or y==h-1 or x==0 or x==w-1:
print("#",end='')
else:
print(".",end='')
print()
print()
| 1 | 836,528,288,074 | null | 50 | 50 |
N = int(input())
ans = 0
wnasi = []
for i in range(1, int(pow(N - 1, 0.5)) + 1):
if (N - 1) % i == 0:
wnasi.append(i)
if i != (N - 1) // i:
wnasi.append((N - 1) // i)
ans += len(wnasi) - 1
wari = []
for i in range(2, int(pow(N, 0.5)) + 1):
if N % i == 0:
wari.append(i)
if i != N // i:
wari.append(N // i)
for i in wari:
if i == 1:
continue
tmpN = N
while True:
if tmpN % i == 0:
tmpN //= i
else:
if tmpN % i == 1:
ans += 1
break
print(ans + 1)
|
def divisor(n):
ret=[]
for i in range(1,int(n**0.5)+1):
if n%i==0:
a,b=i,n//i
if a!=b:
ret+=a,
ret+=b,
else:
ret+=a,
return sorted(ret)
def f(n):
return divisor(n)[1:]
def solve(n):
ans=f(n-1)
for k in f(n):
N=n
while N>=k:
if N%k==0:N=N//k
else:N=N%k
if N==1:ans+=k,
print(len(ans))
return 0
solve(int(input()))
| 1 | 41,089,867,723,380 | null | 183 | 183 |
S =input()
T = input()
n = len(S)-len(T)+1
count = []
for i in range(n):
c =0
for p in range(len(T)):
if S[i+p] != T[p]:
c += 1
count.append(c)
print(min(count))
|
S = int(input())
p = 10**9 +7
def pow_mod(p,a,n):
res = 1
while n > 0:
if n % 2 == 1:
res = (res * a) % p
n = n // 2
a = (a*a)%p
return res
n = 2000
fac = [1]
foo = 1
for i in range(1,n+1):
foo = (foo*i)%p
fac.append(foo)
#コンビネーションのmod
def comb_mod(n,k):
res = (fac[n] * pow_mod(p,fac[k],p-2) * pow_mod(p,fac[n-k],p-2)) % p
return res
ans = 0
for i in range(1,1+S//3):
t = S - 3*i
ans = (ans + comb_mod(t+i-1,t)) %p
print(ans)
| 0 | null | 3,514,295,698,000 | 82 | 79 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
if max(a) < 0:
a.sort()
ans = 1
if k % 2 == 0:
for e in a[:k]:
ans *= e
ans %= mod
else:
for e in a[-k:]:
ans *= e
ans %= mod
print(ans)
elif k == n:
ans = 1
for e in a:
ans *= e
ans %= mod
print(ans)
else:
neg = []
pos = []
for e in a:
if e < 0:
neg.append(e)
else:
pos.append(e)
neg.sort()
pos.sort(reverse=True)
ans = 1
if k % 2:
ans *= pos.pop(0)
k -= 1
nums = [e1 * e2 for e1, e2 in zip(neg[::2], neg[1::2])]
nums += [e1 * e2 for e1, e2 in zip(pos[::2], pos[1::2])]
nums.sort(reverse=True)
for e in nums[:k//2]:
ans *= e
ans %= mod
print(ans)
|
import sys
import math
N = int(input())
def solve(num):
d = math.floor(num**(1/2))
for i in range(1,d+1):
if num % i == 0:
yield [i,num//i]
if N == 2:
print(1)
sys.exit()
cnt = 0
for a,b in solve(N-1):
if a == b:
cnt += 1
else:
cnt += 2
cnt -= 1
for s in solve(N):
if s[0] == s[1]:
s.pop()
for a in s:
if a == 1:
continue
tmp = N
while True:
tmp,m = divmod(tmp, a)
if m == 0:
continue
elif m == 1:
cnt += 1
break
print(cnt)
| 0 | null | 25,429,295,921,822 | 112 | 183 |
N = int(input())
A_list = map(int, input().split())
# [活発度, もとの番号] のリストを降順に並べる
A_list = [[A, index] for index, A in enumerate(A_list)]
A_list.sort(reverse=True)
# print(A_list)
dp = [[0 for i in range(N+1)] for j in range(N+1)]
# print(dp)
for left in range(0, N):
for right in range(0, N - left):
# print(f'left, righte: { left, right }')
# print(A_list[left + right - 1][0])
activity = A_list[left + right][0]
distance_from_left = A_list[left + right][1] - left
# print(f'distance_from_left: { distance_from_left }')
distance_from_right = (N - 1 - right) - A_list[left + right][1]
# print(f'distance_from_right: { distance_from_right }')
dp[left + 1][right]\
= max(dp[left + 1][right],
dp[left][right] + activity * distance_from_left)
dp[left][right + 1]\
= max(dp[left][right + 1],
dp[left][right] + activity * distance_from_right)
# print('dp---')
# print(dp)
# print('---dp')
# print(dp)
dp_list = [flatten for inner in dp for flatten in inner]
print(max(dp_list))
|
from sys import maxsize
from itertools import product
n, k = map(int, input().split())
p = list(map(lambda x: int(x)-1, input().split()))
c = list(map(int, input().split()))
used = [0] * n
ss = []
for i in range(n):
if used[i]:
continue
now = i
s = []
while not used[now]:
used[now] = 1
s.append(c[now])
now = p[now]
ss.append(s)
res = -maxsize
for s in ss:
s_len = len(s)
cumsum = [0]
# 2周分の累積和
for i in range(2*s_len):
cumsum.append(cumsum[-1] + s[i%s_len])
max_sum = [-maxsize] * s_len
for i, j in product(range(s_len), repeat=2):
max_sum[j] = max(max_sum[j], cumsum[i+j] - cumsum[i])
for i in range(s_len):
if i > k:
continue
v = (k - i) // s_len
if i == 0 and v == 0:
continue
if cumsum[s_len] > 0:
res = max(res, max_sum[i] + cumsum[s_len] * v)
elif i > 0:
res = max(res, max_sum[i])
print(res)
| 0 | null | 19,515,184,628,160 | 171 | 93 |
a = input()
b = input()
print(a == b[:-1] and "Yes" or "No")
|
input = raw_input()
print int(input) ** 3
| 0 | null | 10,793,203,789,878 | 147 | 35 |
a,b=map(int, raw_input().split())
if a==b: print "a == b"
elif a>b: print "a > b"
else: print "a < b"
|
n=int(input())
a=list(map(int,input().split()))
res=1000
for i in range(1,n):
if a[i]>a[i-1]:
t=(res//a[i-1])*a[i]+res%a[i-1]
res=t
print(res)
| 0 | null | 3,840,993,411,320 | 38 | 103 |
n,k=map(int,input().split())
A=[0]+list(map(int,input().split()))
color=["white" for _ in range(n+1)]
DP,index=[],1
while 1:
if color[index]=="white":color[index]="gray"
elif color[index]=="gray":color[index]="black"
DP.append(A[index])
index=A[index]
if color[index]=="black":break
repeat=[]
for i in DP:
if color[i]=="black":
repeat.append(i)
if repeat[0]==i and len(repeat)!=1:
repeat.pop()
break
length=len(repeat)
cnt=0
for i in DP:
if repeat[0]==i:break
cnt +=1
if k<=cnt+length:
print(DP[k-1])
else:
k -=cnt
k %=length
print(repeat[k-1])
|
import sys
import copy
#import math
#import itertools
#import numpy as np
#import re
def func(x,m):
return x**2%m
N,X,M=[int(c) for c in input().split()]
myset = {X}
mydict = {X:0}
A = []
A.append(X)
s = X
i = 0
i_stop = i
#i=0は計算したので1から
for i in range(1,N):
A.append(func(A[i-1],M))
if A[i] in myset:
i_stop = i
break
myset.add(A[i])
mydict[A[i]] = i
s+=A[i]
if i == N-1:
print(s)
sys.exit(0)
if A[i] == 0:
print(s)
sys.exit(0)
if i!=0:
#最後にA[i]が出現したのは？
A_repeat = A[mydict[A[i_stop]]:i_stop]
s+=((N-1)-(i_stop-1))//len(A_repeat)*sum(A_repeat)
for k in range(((N-1)-(i_stop-1))%len(A_repeat)):
s+=A_repeat[k]
print(s)
| 0 | null | 12,808,236,657,590 | 150 | 75 |
#!python3
LI = lambda: list(map(int, input().split()))
# input
K = int(input())
S = input()
MOD = 10 ** 9 + 7
MAX = 2 * (10 ** 6) + 1
p25, p26 = [None] * MAX, [None] * MAX
fac, finv, inv = [None] * MAX, [None] * MAX, [None] * MAX
def comb_init():
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fac[i] = fac[i - 1] * i % MOD
inv[i] = -inv[MOD%i] * int(MOD / i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def comb(n, k):
if n < k or n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
def power_init():
p25[0] = 1
p26[0] = 1
for i in range(1, MAX):
p25[i] = p25[i - 1] * 25 % MOD
p26[i] = p26[i - 1] * 26 % MOD
def main():
comb_init()
power_init()
n = len(S)
ans = 0
for i in range(K + 1):
x = p25[i] * comb(i + n - 1, n - 1) % MOD * p26[K - i] % MOD
ans = (ans + x) % MOD
print(ans)
if __name__ == "__main__":
main()
|
def cmb(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 2*10**6+10
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
k=int(input())
n=len(input())
ans=0
for i in range(k,-1,-1):
ans=(ans+cmb(k+n,i)*pow(25,i,mod))%mod
print(ans)
| 1 | 12,777,942,546,128 | null | 124 | 124 |
def solve():
R, C, K = map(int, input().split())
item = [[0]*C for _ in range(R)]
for i in range(K):
r,c,v = map(int, input().split())
item[r-1][c-1] = v
last_dp = [[0]*(C+1) for _ in range(5)]
for i in range(1,R+1):
dp = [[0]*(C+1) for _ in range(5)]
for j in range(1,C+1):
for k in range(4): #横から取らない
dp[k][j] = dp[k][j-1]
#上から取らない
dp[0][j] = max(dp[0][j],last_dp[-1][j])
if item[i-1][j-1]>0:
#上からとる
dp[1][j] = max(dp[1][j],last_dp[-1][j]+item[i-1][j-1])
for k in range(1,4): #横から取る
dp[k][j] = max(dp[k][j],dp[k-1][j-1]+item[i-1][j-1])
for k in range(4):
dp[-1][j] = max(dp[-1][j],dp[k][j])
last_dp = dp
ans = last_dp[-1][-1]
return ans
print(solve())
|
R, C, K = map(int, input().split())
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = map(int, input().split())
V[r][c] = v
dp0 = [[0]*(C+1) for _ in range(R+1)]
dp1 = [[0]*(C+1) for _ in range(R+1)]
dp2 = [[0]*(C+1) for _ in range(R+1)]
dp3 = [[0]*(C+1) for _ in range(R+1)]
for i in range(R+1):
for j in range(C+1):
v = V[i][j]
la = lb = lc = ld = 0
if j > 0:
la = dp0[i][j-1]
lb = dp1[i][j-1]
lc = dp2[i][j-1]
ld = dp3[i][j-1]
dp2[i][j] = max(dp2[i][j], lc, lb + v)
dp3[i][j] = max(dp3[i][j], ld, lc + v)
if i > 0:
max_p = max(dp0[i-1][j], dp1[i-1][j], dp2[i-1][j], dp3[i-1][j])
dp0[i][j] = max(dp0[i][j], max_p, la)
dp1[i][j] = max(dp1[i][j], max_p + v, lb, la + v)
print(max(dp0[R][C], dp1[R][C], dp2[R][C], dp3[R][C]))
| 1 | 5,559,622,991,842 | null | 94 | 94 |
import sys
sys.setrecursionlimit(10**6) #再帰関数の上限
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def main():
mod = 10**9+7
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
if N%2!=0:
print(N//2+1)
exit()
print(N//2)
if __name__ == "__main__":
main()
|
S, T = input().split(' ')
A, B = map(int, input().split(' '))
U = input()
d = {S: A, T: B}
d[U] -= 1
print('{} {}'.format(d[S], d[T]))
| 0 | null | 65,736,973,712,010 | 206 | 220 |
N=int(input())
R=(1000-N%1000)%1000
print(R)
|
letters = input()
q = int(input())
for _ in range(q):
words = input().split()
command = words[0]
a, b = map(int, words[1:3])
if command == 'replace':
letters = ''.join([letters[:a], words[3], letters[b+1:]])
elif command == 'reverse':
letters = ''.join([letters[:a ], letters[a:b+1][::-1], letters[b+1:]])
elif command == 'print':
print(letters[a:b+1])
| 0 | null | 5,273,201,860,260 | 108 | 68 |
n = int(input())
x = list(map(int,input().split()))
x.sort()
ans = 10 ** 8
for p in range(x[0],x[-1]+1):
m = 0
z = 0
for i in range(n):
z = x[i] - p
m += (z ** 2)
ans = min(ans,m)
print(ans)
|
from sys import stdin
readline = stdin.readline
def i_input(): return int(readline().rstrip())
def i_map(): return map(int, readline().rstrip().split())
def i_list(): return list(i_map())
class UnionFind:
def __init__(self, n):
self.parents = [-1] * (n + 1)
self.rank = [0] * (n + 1)
def root(self, x):
if(self.parents[x] < 0):
return x
else:
self.parents[x] = self.root(self.parents[x])
return self.parents[x]
def unite(self, x, y) -> bool:
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.rank[x] > self.rank[y]:
self.parents[x] += self.parents[y]
self.parents[y] = x
else:
self.parents[y] += self.parents[x]
self.parents[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
return True
def members(self, x):
root = self.root(x)
return [i for i in range(self.n) if self.root(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents[1:]) if x < 0]
def is_same(self, x, y) -> bool:
return self.root(x) == self.root(y)
def size(self, x):
return -self.parents[self.root(x)]
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def main():
N, M = i_map()
u = UnionFind(N)
for _ in range(M):
A, B = i_map()
u.unite(A, B)
ans = len(u.roots()) - 1
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 33,710,976,853,732 | 213 | 70 |
#!/usr/bin/env python
def main():
N = int(input())
D = list(map(int, input().split()))
ans = 0
for i in range(N-1):
d1 = D[i]
for d2 in D[i+1:]:
ans += d1 * d2
print(ans)
if __name__ == '__main__':
main()
|
def solve():
n = int(input())
d = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i+1, n):
ans += d[i] * d[j]
print(ans)
if __name__ == '__main__':
solve()
| 1 | 168,608,697,299,280 | null | 292 | 292 |
s=input()
s_list=list(s)
s_list.append('0')
for i in range(len(s)):
if s_list[i]=='?':
if s_list[i+1]=='D':
if s_list[i-1]=='P':
s_list[i]='D'
else:
s_list[i]='P'
elif s_list[i+1]=='?':
if s_list[i-1]=='P':
s_list[i]='D'
else :
s_list[i]='P'
else :
s_list[i]='D'
s_list.pop()
a="".join(s_list)
print(a)
|
n = input()
l = map(int, raw_input().split())
k = 0
a = []
while n > 0:
a.append(l[n - 1])
n -= 1
print ' '.join(map(str, a))
| 0 | null | 9,670,565,460,580 | 140 | 53 |
def insertionSort( nums, n, g ):
cnt = 0
for i in range( g, n ):
v = nums[i]
j = i - g
while j >= 0 and nums[j] > v:
nums[ j+g ] = nums[j]
j -= g
cnt += 1
nums[ j+g ] = v
return cnt
def shellSort( nums, n ):
g = []
v = 1
while v <= n:
g.append( v )
v = 3*v+1
g.reverse( )
m = len( g )
print( m )
print( " ".join( map( str, g ) ) )
cnt = 0
for i in range( m ):
cnt += insertionSort( nums, n, g[i] )
print( cnt )
n = int( input( ) )
nums = [ int( input( ) ) for i in range( n ) ]
nums.append( 0 )
shellSort( nums, n )
nums.pop( )
for v in nums:
print( v )
|
import math
import sys
def insertionSort(data, N, g, cnt):
for i in range(g, N):
v = data[i]
j = i - g
while j >= 0 and data[j] > v:
data[j+g] = data[j]
j = j - g
cnt += 1
data[j+g] = v
return data, cnt
def shellSort(data, N, G, cnt):
h = 1
while (True):
if h > N:
break
G.append(h)
h = 3 * h + 1
m = len(G)
G.reverse()
for i in range(m):
data, cnt = insertionSort(data, N, G[i], cnt)
return m, G, cnt
def main():
N = int(input())
data = [int(input()) for _ in range(N)]
cnt = 0
G = []
m = 0
m, G, cnt = shellSort(data, N, G, cnt)
print(m)
print(' '.join(map(str, G)))
print(cnt)
for i in range(N):
print(data[i])
if __name__ == '__main__':
main()
| 1 | 31,031,427,968 | null | 17 | 17 |
s = str(input())
if s == 'SUN':
print(7)
elif s == 'MON':
print(6)
elif s == 'TUE':
print(5)
elif s == 'WED':
print(4)
elif s == 'THU':
print(3)
elif s == 'FRI':
print(2)
else:
print(1)
|
s = input()
S = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
print(7-S.index(s))
| 1 | 132,752,355,557,962 | null | 270 | 270 |
import math
a, b, x = map(int,input().split())
v = a*a*b
if x > v/2:
y = 2*(b-(x/(a*a)))
naname = math.sqrt((y*y) + (a*a))
cosine = a/naname
print(math.degrees(math.acos(cosine)))
elif x < v/2:
y = 2*x/(b*a)
naname = math.sqrt((y*y)+(b*b))
cosine = b / naname
print(90-math.degrees(math.acos(cosine)))
else:
naname = math.sqrt((a*a)+(b*b))
cosine = a/naname
print(math.degrees(math.acos(cosine)))
|
from collections import deque,defaultdict,Counter
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from bisect import bisect_left,bisect_right
from math import sqrt,gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint
from statistics import mean,median,mode
import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
def mycol(data,col):
return [ row[col] for row in data ]
def mysort(data,col,reverse=False):
data.sort(key=lambda x:x[col],reverse=revese)
return data
def mymax(data):
M = -1*float("inf")
for i in range(len(data)):
m = max(data[i])
M = max(M,m)
return M
def mymin(data):
m = float("inf")
for i in range(len(data)):
M = min(data[i])
m = min(m,M)
return m
def mycount(ls,x):
# lsはソート済みであること
l = bisect_left(ls,x)
r = bisect_right(ls,x)
return (r-l)
def mydictvaluesort(dictionary):
return sorted( dictionary.items(), key=lambda x:x[1] )
def mydictkeysort(dictionary):
return sorted( dictionary.items(), key=lambda x:x[0] )
def myoutput(ls,space=True):
if space:
if len(ls)==0:
print(" ")
elif type(ls[0])==str:
print(" ".join(ls))
elif type(ls[0])==int:
print(" ".join(map(str,ls)))
else:
print("Output Error")
else:
if len(ls)==0:
print("")
elif type(ls[0])==str:
print("".join(ls))
elif type(ls[0])==int:
print("".join(map(str,ls)))
else:
print("Output Error")
def I():
return int(input())
def MI():
return map(int,input().split())
def RI():
return list(map(int,input().split()))
def CI(n):
return [ int(input()) for _ in range(n) ]
def LI(n):
return [ list(map(int,input().split())) for _ in range(n) ]
def S():
return input()
def MS():
return input().split()
def RS():
return list(input())
def CS(n):
return [ input() for _ in range(n) ]
def LS(n):
return [ list(input()) for _ in range(n) ]
# ddict = defaultdict(lambda: 0)
# ddict = defaultdict(lambda: 1)
# ddict = defaultdict(lambda: int())
# ddict = defaultdict(lambda: list())
# ddict = defaultdict(lambda: float())
n,k = MI()
a = RI()
L = max(a)
def mycheck(l):
count = 0
for i in range(n):
count += a[i]//l
return count <= k
lb = 0
ub = L
for i in range(100):
# print(ub,lb)
mid = (lb+ub)/2
# print(mid)
flag = mycheck(mid)
# print(flag)
if flag:
ub = mid
else:
lb = mid
ans = ceil(lb)
print(ans)
| 0 | null | 85,042,994,458,140 | 289 | 99 |
n=int(input())
ans=0
for j,i in enumerate(input().split(),1):
if int(i)%2 and j%2:
ans+=1
print(ans)
|
n=int(input())
l=[0]
c=0
l=l+(list(map(int,input().split())))
try:
for i in range(1,n+1,2):
if l[i]&1:
c+=1
except:
pass
print(c)
| 1 | 7,677,107,864,060 | null | 105 | 105 |
x = int(input())
while x == 0:
x += 1
print(x)
exit(0)
while x == 1:
x -= 1
print(x)
exit(0)
|
n = int(input())
print(0 if n == 1 else 1)
| 1 | 2,940,761,970,628 | null | 76 | 76 |
import math
weeks = int(input())
money = 100
for i in range(0, weeks):
money = math.ceil(money * 1.05)
print(money * 1000)
|
n, m, x = map(int, input().split())
#n,m,x,i,j,l,money,k,o
books = []
for i in range(n):
books.append(list(map(int, input().split())))
ans = 10 ** 10000
import itertools
for i in range(n+1):
for j in itertools.combinations(books, i):#j:組み合わせ
l = [0] * m
money = 0
for k in j:
money += k[0]
for o in range(1, m + 1):
l[o-1] += k[o]
if all(a >=x for a in l):
if money < ans:
ans = money
if ans == 10 ** 10000:
print(-1)
else:
print(ans)
| 0 | null | 11,036,491,697,338 | 6 | 149 |
N, M = map(int, input().split())
A = list(map(int, input().split()))
total = sum(A)
print('Yes' if M <= len(list(filter(lambda x: x, map(lambda x: x * 4 * M >= total, A)))) else 'No')
|
N, M = map(int, input().split())
A = list(map(int, input().split()))
cnt = 0
total = sum(A)
for a in A:
if a >= total / (4*M):
cnt += 1
ans = 'Yes' if cnt >= M else 'No'
print(ans)
| 1 | 38,780,719,564,052 | null | 179 | 179 |
a, b = map(int, input().split())
c, d = map(int, input().split())
if a != c:
ans = 1
else:
ans = 0
print(ans)
|
m, d = map(int,input().split())
n, e = map(int,input().split())
print(int(e == 1))
| 1 | 124,730,710,027,456 | null | 264 | 264 |
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline ####
int1 = lambda x: int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def printlist(lst, k='\n'): print(k.join(list(map(str, lst))))
INF = float('inf')
from collections import deque
def solve():
N = II()
E = [[] for _ in range(N)]
for i in range(N-1):
a, b = MI1()
E[a].append((b, i))
E[b].append((a, i))
q = deque([(0, -1, -1)])
ans = [0] * (N-1)
while len(q) > 0:
current, v_pre, c_pre = q.popleft()
color = 1
for (nv, idx) in E[current]:
if nv == v_pre: continue
if color == c_pre:
color += 1
q.append((nv, current, color))
ans[idx] = color
color += 1
print(max(ans))
printlist(ans)
if __name__ == '__main__':
solve()
|
n = int(input())
ab = [list(map(int, input().split())) for _ in range(n - 1)]
from collections import defaultdict
g = defaultdict(list)
for a, b in ab:
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
k = 0
for key in g:
k = max(k, len(g[key]))
print(k)
ans = dict()
q = [(0, -1)] # (pos, used_color)
visited = set([0])
while q:
cur, col = q.pop()
if col == 0:
tmp = 1
else:
tmp = 0
for target in g[cur]:
if target not in visited:
q.append((target, tmp))
visited.add(target)
ans[(cur, target)] = tmp
if tmp + 1 == col:
tmp += 2
else:
tmp += 1
for a, b in ab:
key = (a-1, b-1)
print(ans[key] + 1)
| 1 | 135,999,534,730,260 | null | 272 | 272 |
#import math
import collections
#n,k = map(int, input().split( ))
#A = list(map(int, input().split( )))
n = int(input())
A = list(map(int, input().split( )))
c = collections.Counter(A)
a = c.most_common()[0][1]
if a != 1:
print('NO')
else:
print('YES')
|
N = int(input())
MX = 10**4
ans = {}
for x in range(1, 100):
for y in range(1, 100):
for z in range(1, 100):
tmp = x**2+y**2+z**2+x*y+x*z+y*z
if tmp > MX:
break
if not(tmp in ans):
ans[tmp] = 1
else:
ans[tmp] += 1
for i in range(1, N+1):
if i in ans:
print(ans[i])
else:
print(0)
| 0 | null | 41,174,683,590,560 | 222 | 106 |
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
ans = [0] * N
for a_i in A:
ans[a_i-1] += 1
for a in ans:
print(a)
|
N = int(input())
cc = list(map(int,input().split()))
num = [0]*N
for i in cc:
num[i-1] += 1
for i in num:
print(i)
| 1 | 32,646,596,248,838 | null | 169 | 169 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
def solve(K: int):
A = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14,
1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print(A[K-1])
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
solve(K)
if __name__ == '__main__':
main()
|
k, n = map(int, input().split())
a = [int(i) for i in input().split()]
a += [a[0] + k]
sum = 0
max = 0
# 最も長い辺を求める
for i in range(n):
d = abs(a[i] - a[i + 1])
sum += d
if max < d:
max = d
# 最も長い辺を通らずに1周回るのが最小
print(sum - max)
| 0 | null | 46,938,868,811,408 | 195 | 186 |
N, A, B = [int(_) for _ in input().split()]
MOD = 10 ** 9 + 7
var1 = pow(2, N, MOD) - 1
def f(x):
f1 = 1
for i in range(N - x + 1, N + 1):
f1 = (f1 * i) % MOD
# 逆元
f2 = 1
for i in range(2, x + 1):
f2 = (f2*i)%MOD
f2 = pow(f2, MOD - 2, MOD)
return (f1 * f2) % MOD
ans = var1 - f(A) - f(B)
print(ans % MOD)
|
n,a,b = map(int, input().split())
MOD = 10 ** 9 + 7
def comb(n, k):
nCk = 1
for i in range(n - k + 1, n + 1):
nCk *= i
nCk %= MOD
for i in range(1, k + 1):
nCk *= pow(i, MOD - 2, MOD)
nCk %= MOD
return nCk
print((((pow(2,n,MOD)-1-comb(n,a))%MOD)-comb(n,b))%MOD)
| 1 | 65,846,792,017,020 | null | 214 | 214 |
import numpy as np
N, M, X = map(int,input().split())
C = []
A = []
for i in range(N):
c = 0
a = []
c, *a = map(int,input().split())
C.append(c)
A.append(a)
inf = float("inf")
res = inf
for bit in range(1 << N):
Cost = 0
Wise = [0] * M
for i in range(N):
if (bit >> i) & 1:# i冊目を買うときの処理
Cost += C[i]
for j, a in enumerate(A[i]):
Wise[j] += a
#else:# i冊目を買わないときの処理（今回は何もしないので省略）
if min(Wise) >= X and Cost <= res:
res = Cost
if res == inf:
print("-1")
else:
print(res)
|
import numpy as np
def main() -> None:
n, m, x = map(int, input().split())
books = [tuple(map(int, input().split())) for _ in range(n)]
is_able = False
answer = float('inf')
for i in range(2**n):
money = 0
skills = np.zeros(m)
for j in range(n):
if ((i >> j) & 1):
money += books[j][0]
skills += books[j][1:]
if x <= skills.min():
is_able = True
answer = min(answer, money)
print(answer if is_able else -1)
return
if __name__ == '__main__':
main()
| 1 | 22,201,718,013,460 | null | 149 | 149 |
x=int(input())
for i in range(1001):
for j in range(100*i,105*i+1):
if x==j:
print(1)
exit(0)
print(0)
|
n,x,y=map(int,input().split())
#最短距離が１の時２の時、、、という風に実験しても途方に暮れるだけだった
#i,j固定して最短距離がどう表せるかを考える
def min_route_count(i,j):
return min(abs(j-i),abs(j-y)+1+abs(x-i))
ans_list=[0]*(n-1)
for i in range(1,n):
for j in range(i+1,n+1):
ans_list[min_route_count(i,j)-1]+=1
for t in range(n-1):
print(ans_list[t])
| 0 | null | 85,823,647,321,788 | 266 | 187 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.