code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,629B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
R = int(input())
L = 2*R*3.141592
print(L)
| s=input()*3
if s.find(input()) == -1 :
print('No')
else:
print('Yes') | 0 | null | 16,627,821,025,010 | 167 | 64 |
N,K=map(int,input().split())
p=list(map(int,input().split()))
q=[]
q.append(0)
for i in range(len(p)):
q.append(q[-1]+p[i])
maxi=q[K]-q[0]
for i in range(1,N-K+1):
sub=q[K+i]-q[i]
if sub>=maxi:
maxi=sub
print((maxi+K)/2) | n, u, v = map(int, input().split())
tree = [[] for i in range(n+1)]
for i in range(n-1):
a, b = map(int, input().split())
tree[a].append(b)
tree[b].append(a)
dist1 = [100005]*(n+1)
q = []
q.append(v)
dist1[v] = 0
while q:
now = q.pop()
for next in tree[now]:
if dist1[next] == 100005:
q.append(next)
dist1[next] = dist1[now] + 1
dist2 = [100005]*(n+1)
q = []
q.append(u)
dist2[u] = 0
while q:
now = q.pop()
for next in tree[now]:
if dist2[next] == 100005:
q.append(next)
dist2[next] = dist2[now] + 1
for i in range(1, n+1):
if dist1[i] <= dist2[i]:
dist2[i] = -1
for i in range(1, n+1):
if dist2[i] != -1:
dist2[i] = 100005
q = []
q.append(u)
dist2[u] = 0
while q:
now = q.pop()
for next in tree[now]:
if dist2[next] == 100005:
q.append(next)
dist2[next] = dist2[now] + 1
ans = 0
for i in range(1, n+1):
if dist2[i] != -1:
ans = max(ans, dist1[i])
print(ans-1)
| 0 | null | 96,525,587,598,640 | 223 | 259 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
MAX = 2 * 10**6 + 10
MOD = 10**9+7
fac = [1] * MAX
f_inv = [1] * MAX
def prepare(n, mod):
for i in range(1, n+1):
fac[i] = (fac[i-1] * i) % mod
f_inv[n] = pow(fac[n], -1, MOD)
for i in range(n-1, 0, -1):
f_inv[i] = (f_inv[i+1] * (i+1)) % MOD
def modcmb(n, r, mod):
if n < 0 or r < 0:
return 0
if r > n:
return 0
return fac[n] * f_inv[r] * f_inv[n-r] % mod
def main():
K = int(readline())
S = readline().strip()
N = len(S)
prepare(N + K + 5, MOD)
inv26 = pow(26, -1, MOD)
pow26 = pow(26, K, MOD)
pow25 = 1
ans = 0
for i in range(K+1):
ans += (modcmb(N-1+i, i, MOD) * pow25 * pow26) % MOD
ans %= MOD
pow25 *= 25
pow25 %= MOD
pow26 *= inv26
pow26 %= MOD
print(ans)
if __name__ == "__main__":
main()
| m,n=[int(x) for x in input().split()]
if m==n:
print("Yes")
else:
print("No") | 0 | null | 48,334,050,288,352 | 124 | 231 |
import sys
sys.setrecursionlimit(10**5)
def DFS(i,g):
if i not in done:
done.add(i)
circle.add(i)
g_list[i]=g
for f in F[i]:
DFS(f,g)
else:
return
N,M,K=map(int,input().split())
F=[[] for _ in range(N)]
B=[[] for _ in range(N)]
for f in range(M):
f1,f2=map(int,input().split())
F[f1-1].append(f2-1)
F[f2-1].append(f1-1)
for b in range(K):
b1,b2=map(int,input().split())
B[b1-1].append(b2-1)
B[b2-1].append(b1-1)
Group=[]
circle=set()
done=set()
g_list=[0 for _ in range(N)]
g=0
for i in range(N):
if i not in done:
DFS(i,g)
Group.append(circle)
circle=set()
g+=1
ans=[-1 for _ in range(N)]
for i in range(N):
G=g_list[i]
ans[i]+=len(Group[G])
for fr in F[i]:
if fr in Group[G]:
ans[i]-=1
for bl in B[i]:
if bl in Group[G]:
ans[i]-=1
print(*ans) | class UnionFind():
# 要素数を指定して作成 はじめは全ての要素が別グループに属し、親はいない
def __init__(self, n):
self.n = n
self.parents = [-1] * n
# xの根を返す
def find(self, x):
if self.parents[x] < 0: return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
# xとyが属するグループを併合
def union(self, x, y):
x = self.find(x)
y = self.find(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
# xが属するグループの要素数
def size(self, x): return -self.parents[self.find(x)]
# ｘとyが同じグループか否か
def same(self, x, y): return self.find(x) == self.find(y)
# xと同じメンバーの要素
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
# 根の一覧
def roots(self): return [i for i, x in enumerate(self.parents) if x < 0]
# グループ数
def group_count(self): return len(self.roots())
# 可視化 [print(uf)]
def __str__(self): return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M, K = list(map(int,input().split()))
G1 = [[] for _ in range(N)]
for i in range(M):
a, b = map(int, input().split())
G1[a - 1].append(b - 1)
G1[b - 1].append(a - 1)
G2 = [[] for _ in range(N)]
for i in range(K):
a, b = map(int, input().split())
G2[a - 1].append(b - 1)
G2[b - 1].append(a - 1)
uf = UnionFind(N)
for i in range(N):
for j in G1[i]:
uf.union(i, j)
for i in range(N):
ans = uf.size(i) - len(G1[i]) - 1
for j in G2[i]:
if uf.same(i, j): ans -= 1
print(ans) | 1 | 61,755,899,992,530 | null | 209 | 209 |
n,k=map(int,input().split())
p=list(map(int,input().split()))
p_list=sorted(p, reverse=False)
sum=0
for i in range(k):
sum+=p_list[i]
print(sum) | N, K = [int(x) for x in input().split()]
p = [int(x) for x in input().split()]
p.sort()
ans = 0
for i in range(K):
ans += p[i]
print(ans)
| 1 | 11,611,608,953,202 | null | 120 | 120 |
H, W, K = map(int, input().split())
S = [''] * H
for i in range(H):
S[i] = input()
A = [[0] * W] * H
bg = 1
inflg = 0
outcnt = 1
for i in range(H):
if '#' not in S[i]:
if inflg == 0:
outcnt += 1
else:
A[i] = A[i-1]
print(" ".join(str(k) for k in A[i]))
else:
inflg += 1
for j in range(S[i].find('#')):
A[i][j] = bg
for j in range(S[i].find('#'),W):
if S[i][j] == '#':
A[i][j] = bg
bg += 1
else:
A[i][j] = A[i][j-1]
if inflg == 1:
for s in range(outcnt):
print(" ".join(str(k) for k in A[i]))
else:
print(" ".join(str(k) for k in A[i]))
| import sys
uppers = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
lowers = 'abcdefghijklmnopqrstuvwxyz'
s = []
for line in sys.stdin:
s += line
for i in range(26):
print(lowers[i] + ' : ' + str(s.count(uppers[i]) + s.count(lowers[i]))) | 0 | null | 72,918,262,067,170 | 277 | 63 |
i = raw_input().strip().split()
a = int(i[0])
b = int(i[1])
c = int(i[2])
if a < b and b < c:
print "Yes"
else:
print "No" | from sys import stdin
from itertools import permutations
n = int(stdin.readline().strip())
rank = dict([(val, i) for i, val in enumerate(sorted([int(''.join([str(v) for v in l])) for l in permutations(list(range(1, n+1)), n)])[::-1])])
p_rank = rank[int(''.join(stdin.readline().split()))]
q_rank = rank[int(''.join(stdin.readline().split()))]
print(abs(p_rank - q_rank)) | 0 | null | 50,242,371,586,302 | 39 | 246 |
N=int(input())
x=[0]*N
for i in range(N):
x[i]=list(map(int,input().split()))
#print(x)
z=[0]*N
w=[0]*N
for i in range(N):
z[i]=x[i][0]+x[i][1]
w[i]=x[i][0]-x[i][1]
print(max(max(z)-min(z),max(w)-min(w)))
| N, K = [int(a) for a in input().split()]
num_count = (N-N%K)//K
ans = min(abs(N - num_count*K), abs(N - (num_count+1)*K))
if num_count > 0:
ans = min(abs(N - (num_count-1)*K), ans)
print(ans) | 0 | null | 21,255,876,344,290 | 80 | 180 |
x = input()
y = input()
x += x
if y in x:
print("Yes")
else:
print("No")
| # Stable Sort
length = int(input())
cards = input().rstrip().split()
cards1 = [card for card in cards]
cards2 = [card for card in cards]
def value(n):
number = n[1:]
return int(number)
def char(cards):
charSets = [[] for i in range(10)]
for i in range(length):
char = cards[i][:1]
val = value(cards[i])
# print('絵柄: ' + char + ', 数字: ' + str(val))
charSets[val].append(char)
return charSets
def bubble(cards):
for i in range(length):
j = length - 1
while j > i:
if value(cards[j]) < value(cards[j - 1]):
cards[j], cards[j - 1] = cards[j - 1], cards[j]
j -= 1
return cards
def selection(cards):
# count = 0
for i in range(length):
minj = i
for j in range(i, length):
if value(cards[j]) < value(cards[minj]):
minj = j
#if minj != i:
# count += 1
cards[i], cards[minj] = cards[minj], cards[i]
return cards
def stable(cards1, cards2):
if char(cards1) == char(cards2):
return 'Stable'
else:
return 'Not stable'
c = cards
b = bubble(cards1)
s = selection(cards2)
print(' '.join(b))
print(stable(c, b))
print(' '.join(s))
print(stable(c, s))
| 0 | null | 886,760,728,808 | 64 | 16 |
h, w, f = list(map(int, input().split()))
c = [input() for i in range(h)]
count = 0
bit_h = []
for k in range(2**h):
hh = []
for l in range(h):
if((k >> l) & 1):
hh.append(1)
else:
hh.append(0)
bit_h.append(hh)
bit_w = []
for i in range(2**w):
ww = []
for j in range(w):
if((i >> j) & 1):
ww.append(1)
else:
ww.append(0)
bit_w.append(ww)
ans = 0
for i in range(len(bit_h)):
for j in range(len(bit_w)):
count = 0
for k in range(h):
for l in range(w):
if bit_h[i][k] == 1 and bit_w[j][l] == 1 and c[k][l] == "#":
count += 1
if count == f:
ans += 1
print(ans)
| import math
N = int(input())
S = input()
lst0 = [0]*N
lst1 = [0]*N
lst0[0] = 1
lst1[0] = 1
c = S.count('1')
m0 = int(S[-1])
m1 = int(S[-1])
for i in range(1, N):
lst0[i] += (lst0[i-1]*2)%(c+1)
if c == 1:lst1[i] = 0
else: lst1[i] += (lst1[i-1]*2)%(c-1)
m0 += lst0[i] * int(S[N - 1- i])
m0 %= c+1
m1 += (lst1[i] * int(S[N - 1 - i]))
if c == 1: m1 = 0
else: m1 %= c-1
memo = [0]*(N+1)
def calc(a):
global ans, memo
if a == 0: return ans
ans += 1
if memo[a] != 0:
b = memo[a]
else:
b = bin(a).count('1')
memo[a] = b
return calc(a%b)
for i in range(N):
if S[i] == '1':
b = c - 1
if b == 0: a = 0
else: a = max((m1 - lst1[N - 1 - i])%b, (m1 - lst1[N - 1 - i]+ b)%b)
else:
b = c + 1
a = (m0 + lst0[N - 1 - i])%b
if b == 0: print(0)
elif a == 0:print(1)
else:
ans = 1
print(calc(a)) | 0 | null | 8,609,260,053,952 | 110 | 107 |
a,b,c = input()
a = int(a)
b = int(b)
c = int(c)
if a == 7 or b == 7 or c == 7:
print("Yes")
else:
print("No") | N = str(input())
for i in range(3):
if N[i] == '7':
print('Yes')
quit()
print('No') | 1 | 34,221,515,456,208 | null | 172 | 172 |
N = int(input())
S = input()
ans = 0
for i in range(10):
for j in range(10):
for k in range(10):
tmp = 0
for l, value in enumerate(S):
if tmp == 0:
if value == str(i):
tmp = 1
elif tmp == 1:
if value == str(j):
tmp = 2
elif tmp == 2:
if value == str(k):
ans += 1
break
print(ans) | x,y = map(int, input().split())
count = 0
while x > 0:
x = x - y
count += 1
print(count)
| 0 | null | 102,814,650,250,368 | 267 | 225 |
from itertools import combinations
import math
N = int(input())
x = []
y = []
for i in range(N):
_x, _y = map(int, input().split())
x.append(_x)
y.append(_y)
s = 0
for c in combinations(zip(x, y), 2):
s += math.sqrt((c[0][0] - c[1][0]) ** 2 + (c[0][1] - c[1][1]) ** 2)
print(s * 2 / N) | import math
N = int(input())
town = []
for i in range(N):
x, y = map(int, input().split())
town.append((x, y))
def dfs(current, dist, already):
if len(already) == N:
return dist
d = 0
for i in range(N):
if i in already:
continue
d += dfs(i, dist + math.sqrt((town[current][0] - town[i][0]) ** 2 + (town[current][1] - town[i][1]) ** 2), already | set([i]))
return d
answer = 0
for i in range(N):
answer += dfs(i, 0, set([i]))
print(answer / math.factorial(N)) | 1 | 148,764,193,758,762 | null | 280 | 280 |
n,k,*l=map(int,open(0).read().split())
for _ in range(k):
s=[0]*(n+1)
for i in range(n):
s[max(i-l[i],0)]+=1
s[min(i+l[i]+1,n)]-=1
s[0]=min(s[0],n)
for i in range(1,n):
s[i]=min(s[i-1]+s[i],n)
s.pop()
if s==l: break
l=s
print(*l) | n=int(input())
a=list(map(int,input().split()))
d=1
mx=[]
for i in range(n+1):
d-=a[i]
mx.append(d)
d*=2
mx.append(1)
f=mx[n]>=0
d=0
c=0
for i in range(n,-1,-1):
d+=a[i]
c+=d
t=(d+1)//2
if t>mx[i-1]:
f=False
break
d=min(d,mx[i-1])
print(c if f else -1)
| 0 | null | 17,081,060,977,024 | 132 | 141 |
s = '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'
a = list(s.split(','))
n = int(input())
print(a[n-1]) | L = "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"
L = L.split(", ")
k = int(input())
print(L[k-1]) | 1 | 49,886,320,759,828 | null | 195 | 195 |
count = 0
for _ in range(int(input())):
n = int(input())
if n == 2 or pow(2,n-1,n) == 1:
count += 1
print(count)
| print(2**int(input()).bit_length()-1)
| 0 | null | 40,260,454,887,070 | 12 | 228 |
while True:
a = input()
if a == "0":
break
print(sum([int(a[i]) for i in range(len(a))])) | sum_list=[]
while True:
num=input()
if num=='0':
break
num_list=list(num)
for i in range(0,len(num_list)):
num_list[i]=int(num_list[i])
sum_list.append(sum(num_list))
for i in sum_list:
print(i) | 1 | 1,612,881,676,640 | null | 62 | 62 |
def func(K, X):
YEN = 500
ans = 'Yes' if YEN * K >= X else 'No'
return ans
if __name__ == "__main__":
K, X = map(int, input().split())
print(func(K, X))
| #!/usr/bin/python3
# import bisect
# from collections import Counter, deque, OrderedDict, defaultdict
from copy import copy, deepcopy # pythonのみ．copyは1次元，deepcopyは多次元．
# from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
# from functools import reduce
# from heapq import heapify, heappop, heappush
# from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
# import math
# import numpy as np # Pythonのみ！
# from operator import xor
# import re
# from scipy.sparse.csgraph import connected_components # Pythonのみ！
# ↑cf. https://note.nkmk.me/python-scipy-connected-components/
# from scipy.sparse import csr_matrix
# import statistics # Pythonのみ
# import string
import unittest
from io import StringIO
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
n = int(input())
import math
# cf. https://qiita.com/suecharo/items/14137fb74c26e2388f1f
def make_prime_list_2(num):
if num < 2:
return []
# 0のものは素数じゃないとする
prime_list = [i for i in range(num + 1)]
prime_list[1] = 0 # 1は素数ではない
num_sqrt = math.sqrt(num)
for prime in prime_list:
if prime == 0:
continue
if prime > num_sqrt:
break
for non_prime in range(2 * prime, num, prime):
prime_list[non_prime] = 0
return [prime for prime in prime_list if prime != 0]
def prime_factorization_2(num):
"""numの素因数分解
素因数をkeyに乗数をvalueに格納した辞書型dict_counterを返す"""
if num <= 1:
return False
else:
num_sqrt = math.floor(math.sqrt(num))
prime_list = make_prime_list_2(num_sqrt)
dict_counter = {} # 何度もこの関数を呼び出して辞書を更新したい時はこれを引数にして
# cf. https://atcoder.jp/contests/arc034/submissions/12251452
for prime in prime_list:
while num % prime == 0:
if prime in dict_counter:
dict_counter[prime] += 1
else:
dict_counter[prime] = 1
num //= prime
if num != 1:
if num in dict_counter:
dict_counter[num] += 1
else:
dict_counter[num] = 1
return dict_counter
def divisor_count(num):
"""numの約数の個数を求める"""
if num < 0:
return None
elif num == 1:
return 1
else:
divisor_num = 1
dict_fact = prime_factorization_2(num)
for value in dict_fact.values():
divisor_num *= (value + 1)
return divisor_num
ans = divisor_count(n-1)
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i: # 平方数の場合n**0.5を1つだけにしてる
divisors.append(n//i)
# divisors.sort() # ソートしたけりゃして
return divisors
l = make_divisors(n)
def main():
cnt = 0
for i in l:
if i==1: continue
v = copy(n)
while v % i == 0:
v /= i
v%=i
if v==1: cnt += 1
return cnt
print(ans+main()-1)
resolve() | 0 | null | 69,770,957,589,020 | 244 | 183 |
K, N = map(int, input().split())
A = list(map(int, input().split()))
A3 = A + [K+a for a in A]
dist = [A3[i+N-1] - A[i] for i in range(N)]
print(min(dist))
| K, N = map(int,input().split())
L = list(map(int,input().split()))
d = [L[i+1]-L[i] for i in range(N-1)]
d.append(L[0] - (L[-1]-K))
m = max(d)
ans = sum(d) - m
print(ans) | 1 | 43,563,912,762,890 | null | 186 | 186 |
from math import *
K=int(input())
ans=0
for a in range(1,K+1):
for b in range(1,K+1):
for c in range(1,K+1):
ans+=gcd(gcd(a,b),c)
print(ans) | from math import gcd
n = int(input())
ans = 0
for i in range(1,n+1):
for j in range(1,n+1):
x = gcd(i,j)
for k in range(1,n+1):
ans += gcd(x,k)
print(ans)
| 1 | 35,669,683,063,908 | null | 174 | 174 |
s = input()
if s.count('A') == 0 or s.count('B') == 0:
print('No')
else:
print('Yes') | l=list(input())
if(l[0]==l[1]==l[2]):
print("No")
else:
print("Yes") | 1 | 54,822,718,235,730 | null | 201 | 201 |
s=input()
count=0
for i in s:
count+=1
print('x'*count) | N,K = map(int,input().split())
sunuke = [0]*(N+1)
for i in range(K):
okashi_category = input()
#print (okashi_category)
if okashi_category ==1:
sunuke[input()]=1
else:
sunukelist = list(map(int,input().split()))
for j in range(len(sunukelist)):
#print(sunukelist[j])
sunuke[sunukelist[j]]=1
print (N-sum(sunuke)) | 0 | null | 48,500,683,571,298 | 221 | 154 |
s = input()
stack = []
n = len(s)
ans = 0
prev = 0
each = []
for i in range(n):
if s[i] == '\\':
stack.append(i)
elif s[i] == '_':
pass
else:
if len(stack) != 0:
idx = stack.pop()
ans += (i - idx)
if len(stack) == 0:
each.append(ans - prev)
prev = ans
each2 = []
stack2 = []
ans2 = 0
prev2 = 0
if len(stack) >= 1:
for i in range(n-1,stack[0],-1):
if s[i] == '/':
stack2.append(i)
elif s[i] == '_':
pass
else:
if len(stack2) != 0:
idx = stack2.pop()
ans2 += (idx - i)
if len(stack2) == 0:
each2.append(ans2 - prev2)
prev2 = ans2
each2.reverse()
each.extend(each2)
print(ans)
if len(each) == 0:
print(len(each))
else:
print(len(each),end=" ")
print(*each)
| 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
def shellSort(A, n):
global cnt
G = []
g = 1
while g <= n:
G.append(g)
g = 3 * g + 1
G = G[::-1]
m = len(G)
for i in range(m):
insertionSort(A, n, G[i])
return m, G, cnt, A
n = int(input())
A = []
for _ in range(n):
A.append(int(input()))
cnt = 0
m, G, cnt, A = shellSort(A, n)
print(m)
for i in range(m):
if i == m - 1:
print(G[i])
else:
print(G[i], end=' ')
print(cnt)
for i in range(n):
print(A[i])
| 0 | null | 45,366,532,860 | 21 | 17 |
from sys import stdin
import math
import fileinput
for line in fileinput.input():
a, b = [int(n) for n in line.split()]
print(math.floor(math.log10(a + b) + 1))
# x1, y1, x2, y2, x3, y3, xp, yp = [float(r) for r in line]
# print(x1, y1, x2, y2, x3, y3, xp, yp) | N, K = map(int, input().split())
portals = [0] + list(map(int, input().split()))
visitTowns = list()
visitTimes = [0 for _ in range(N + 1)]
curTown = 1
timeBackTo = 0
curTime = 0
while True:
if visitTimes[curTown] > 0:
timeBackTo = visitTimes[curTown]
break
visitTowns.append(curTown)
visitTimes[curTown] = curTime
# teleport
curTown = portals[curTown]
curTime += 1
nonLoopCount = timeBackTo
loopSpan = len(visitTowns) - nonLoopCount
if K <= nonLoopCount:
print(visitTowns[K])
exit()
rem = (K - nonLoopCount) % loopSpan
print(visitTowns[nonLoopCount + rem])
| 0 | null | 11,319,458,227,360 | 3 | 150 |
n = int(input())
a = list(map(int, input().split()))
i = 1
if 0 in a:
i = 0
else:
for j in range(n):
if i >= 0:
i = i * a[j]
if i > 10 ** 18:
i = -1
print(int(i)) | n=int(input())
array=list(map(int,input().split()))
ans=1
if 0 in array:
ans=0
else:
for i in range(n):
if ans>10**18:
break
else:
ans=ans*array[i]
if ans>10**18:
print(-1)
else:
print(ans) | 1 | 16,176,095,144,988 | null | 134 | 134 |
import bisect
n=int(input())
a=list(map(int,input().split()))
suma=[]
sumans=0
for i in range(n):
sumans += a[i]
suma.append(sumans)
u=bisect.bisect_right(suma, sumans//2)
print(min(abs(2*suma[u-1]-sumans), abs(2*suma[u]-sumans))) | a, b = input().split()
print(sorted([a*int(b), b*int(a)])[0])
| 0 | null | 113,280,747,551,120 | 276 | 232 |
n=int(input())
H=[]
T=[]
for i in range (n):
a=list(map(str, input().split()))
if a[0]>a[1] :
H.append(3)
elif a[0]<a[1] :
T.append(3)
else :
H.append(1)
T.append(1)
print(sum(H), sum(T))
| a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if a < b:
if a + v * t >= b + w * t:
print("YES")
else:
print("NO")
else:
if a - v * t <= b - w * t:
print("YES")
else:
print("NO")
| 0 | null | 8,618,466,876,142 | 67 | 131 |
n=int(input())
vec=[0 for _ in range(10050)]
for x in range(1,105):
for y in range (1,105):
for z in range (1 , 105):
sum= x*x + y*y + z*z + x*y +y*z + z*x
if sum<10050:
vec[sum]+=1
for i in range(1,n+1):
print(vec[i]) | N = int(input())
ans=[0]*N
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
F=x**2 + y**2 + z**2 + x*y + y*z + z*x
if(N>=F):
ans[F-1] += 1
for i in ans:
print(i) | 1 | 7,902,119,955,050 | null | 106 | 106 |
a = list(map(int,input().split()))
print("bust" if sum(a) >= 22 else "win") | import sys
a,b,c = map(int,input().split())
d = a+b+c
if(d > 21):
print("bust")
else:
print("win")
| 1 | 118,908,222,180,142 | null | 260 | 260 |
import itertools
import math
n=int(input())
d=list(map(int,input().split()))
ans=0
for v in itertools.combinations(d, 2):
x=v[0]*v[1]
ans+=x
print(ans) | while True:
(H, W) = [int(i) for i in input().split()]
if H == W == 0:
break
print ("\n".join(["".join(["#" if i == 0 or i == W - 1 or j == 0 or j == H - 1 else "." for i in range(W)]) for j in range(H)]))
print() | 0 | null | 84,552,502,908,162 | 292 | 50 |
import math
h,w=map(int,input().split())
if h==1 or w==1:
print(1)
elif (h*w)%2==0:
print(int((h*w)/2))
else:
print(math.ceil((h*w)/2))
| n,u,v = map(int,input().split())
u -= 1
v -= 1
peer = [[] for _ in range(n)]
for _ in range(n-1):
a,b = map(int,input().split())
a -= 1
b -= 1
peer[a].append(b)
peer[b].append(a)
rank = [10**6 for _ in range(n)]
seen = [0 for _ in range(n)]
pre = [10**6 for _ in range(n)]
pst = [[] for _ in range(n)]
seen[v] = 1
rank[v] = 0
now = [v]
while now:
last = now
now = []
for x in last:
for y in peer[x]:
if seen[y] == 0:
seen[y] += 1
rank[y] = rank[x] + 1
now.append(y)
pre[y] = x
pst[x].append(y)
#print(rank)
back = (rank[u]-1) // 2
tar = u
for _ in range(back):
tar = pre[tar]
depth = -1
now = [tar]
while now:
depth += 1
last = now
now = []
for x in last:
now += pst[x]
#print(tar,depth,last)
if rank[u] % 2 == 1:
print(back + depth)
else:
print(back + depth + 1) | 0 | null | 84,320,535,892,010 | 196 | 259 |
import sys
def Ii():return int(sys.stdin.buffer.read())
def Mi():return map(int,sys.stdin.buffer.readline().split())
def Li():return list(map(int,sys.stdin.buffer.readline().split()))
x = Ii()
for i in range(121):
for j in range(-119,120):
if x == i**5 - j**5:
print(i,j)
exit(0) | import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
A, B, K = map(int, readline().split())
if A>=K:
A -= K
else:
B = max(B-(K-A),0)
A = 0
print(A, B)
if __name__ == '__main__':
main()
| 0 | null | 64,524,822,123,004 | 156 | 249 |
H,W=[int(i) for i in input().split()]
if H==1 or W==1:
print(1)
else:
print(int(H*W/2)+(H*W)%2)
| H, W = map(int, input().split())
ans = 0
x = H * W
if H == 1 or W == 1:
ans = 1
elif x % 2 == 0:
ans = x // 2
else:
ans = (x // 2) + 1
print(ans) | 1 | 51,084,219,088,100 | null | 196 | 196 |
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(input())
X = input()
cnt_init = X.count("1")
x_init = int(X, 2)
a = x_init % (cnt_init + 1)
if cnt_init - 1 != 0:
b = x_init % (cnt_init - 1)
for i in range(n):
if X[i] == "0":
cnt = cnt_init + 1
x = (a + pow(2, (n - i - 1), cnt)) % cnt
res = 1
else:
cnt = cnt_init - 1
if cnt != 0:
x = (b - pow(2, (n - i - 1), cnt)) % cnt
res = 1
else:
x = 0
res = 0
while x:
cnt = bin(x).count("1")
x %= cnt
res += 1
print(res)
if __name__ == '__main__':
resolve()
| a,b,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
x=[list(map(int,input().split())) for _ in range(m)]
ans=min(a)+min(b)
for i in range(m):
ans=min(ans,(a[x[i][0]-1]+b[x[i][1]-1]-x[i][2]))
print(ans)
| 0 | null | 31,137,241,740,732 | 107 | 200 |
if __name__ == "__main__":
A,B = map(int,input().split())
for i in range(1,1251):
A_tmp,B_tmp = int(i*0.08),int(i*0.10)
if A is A_tmp and B is B_tmp:
print(i)
exit()
print(-1) | import math
a, b = map(int, input().split())
for i in range(1, 10**5):
if math.floor(i*0.08) == a and math.floor(i*0.1) == b:
print(i)
exit()
print(-1) | 1 | 56,211,141,648,992 | null | 203 | 203 |
import sys
readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def solve():
print('Yes' if ni() >= 30 else 'No')
return
solve()
| A_int_list = list(map(int, input().split()))
if 22 <= sum(A_int_list):
print('bust')
else:
print('win')
| 0 | null | 62,010,560,330,690 | 95 | 260 |
import sys
import math
#from queue import *
import random
#sys.setrecursionlimit(int(1e6))
input = sys.stdin.readline
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input()))
def inara():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############
n=inp()
print("ACL"*n)
| class SwappingTwoNumbers:
def output(self, n):
n.sort()
print "%d %d" % (n[0], n[1])
if __name__ == "__main__":
stn = SwappingTwoNumbers();
while True:
n = map(int, raw_input().split())
if n[0] == 0 and n[1] == 0:
break
stn.output(n) | 0 | null | 1,370,553,661,208 | 69 | 43 |
N=int(input())
print(-N%1000)
| h,w = map(int,input().split())
s = h*w
if h == 1 or w == 1:
print(1)
elif s%2 == 1:
print((s//2)+1)
else:
print(s//2) | 0 | null | 29,626,452,974,480 | 108 | 196 |
K = int(input())
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]
if K <= len(a) and K >= 1:
print(a[K-1]) | while True:
string = list(input())
#1文字ずつ配列に入ってる
if "-" in string:
break
shuffle = int(input())
for i in range(shuffle):
h = int(input())
for j in range(h):
string.append(string[0])
del string[0]
for i in range(len(string)):
if i != len(string)-1:
print(string[i],end="")
else:
print(string[i])
| 0 | null | 26,115,889,924,000 | 195 | 66 |
from collections import deque
slope = input()
down_slope = deque()
total_slopes = deque()
for i in range(len(slope)):
if slope[i] == '\\':
down_slope.append(i)
elif slope[i] == '/':
area = 0
if len(down_slope) > 0:
while len(total_slopes) > 0 and total_slopes[-1][0] > down_slope[-1]:
area += total_slopes[-1][1]
total_slopes.pop()
area += i-down_slope[-1]
total_slopes.append([down_slope[-1],area])
down_slope.pop()
if len(total_slopes) > 0:
total_slopes = [i[1] for i in total_slopes]
print(sum(total_slopes))
print(len(total_slopes),end=' ')
print(' '.join(map(str,total_slopes)))
else:
print(0)
print(0)
| s = input()
depth_list = [0]*len(s)
max_depth = [0]*len(s)
d = 0
for i, c in enumerate(s):
if c == "\\":
d -= 1
elif c == "/":
d += 1
depth_list[i] = d
m_d = d
for i in range(len(s)-1, -1, -1):
if s[i] == "\\":
d += 1
elif s[i] == "/":
d -= 1
max_depth[i] = m_d
m_d = max(m_d, d)
d = 0
m_d = 0
water = 0
puddles = [0]
for i, n in enumerate(depth_list):
up = min(m_d, max_depth[i])
if d < up and d != n or d == up and d > n:
water += 0.5
if d < n:
d = n
water += max(0, up - d)
d = n
m_d = max(m_d, d)
if d == up and sum(puddles) < int(water):
m_d = d
puddles.append(int(water - sum(puddles)))
print(int(water))
print(str(len(puddles)-1)+(" "if len(puddles)>1 else "")+" ".join([str(n) for n in puddles[1:]])) | 1 | 61,387,701,020 | null | 21 | 21 |
n = int(input())
a = list(map(int, input().split()))
iseven=(n%2==0)
if n==2:
print(max(a))
exit()
dp = [[-float("inf") for _ in range(3)] for _ in range(n)]
dp[0][0]=a[0]
dp[1][1]=a[1]
if n>2:
dp[2][2]=a[2]
for i in range(n):
for k in range(3):
if i+2<n:
dp[i+2][k] = max(dp[i+2][k], dp[i][k] + a[i+2])
if k<=1 and i+3<n:
dp[i+3][k+1] = max(dp[i+3][k+1], dp[i][k] + a[i+3])
if not iseven and k==0 and i+4<n:
dp[i+4][k+2] = max(dp[i+4][k+2], dp[i][k] + a[i+4])
if iseven:
ans=max([dp[-1][0],dp[-1][1]])
else:
ans=max([dp[-3][0],dp[-2][1],dp[-1][2]])
print(ans) | input()
aa = list(map(int, input().split()))
state = {(0,False)}
skipmax = len(aa)%2 + 1
state_all = {(i, True) for i in range(skipmax+1)}.union({(j, False) for j in range(skipmax+1)})
dp_0 = {a:None for a in state_all }
dp_0[(0,False)] = 0
skipcount = 0
def getmax(a, b):
if a is None:
return b
if b is None:
return a
return max(a,b)
for i,a in enumerate(aa):
dp_1 = {}
for s in state_all:
if s[1] & (dp_0[(s[0], False)] is not None):
dp_1[s] = dp_0[(s[0], False)] + a
continue
dp_1[s] = getmax(dp_0[(s[0], True)], dp_0.get((s[0]-1, False), None))
dp_0 = dp_1.copy()
if len(aa)%2:
print(getmax(dp_0[(2,True)], dp_0[(1,False)]))
else:
print(getmax(dp_0[(1,True)], dp_0[(0,False)]))
| 1 | 37,447,342,589,536 | null | 177 | 177 |
d = {}
for _ in range(int(input())):
d[input()] = ""
print(len(d)) | import collections
n=int(input())
box=[]
for i in range(n):
tmp=str(input())
box.append(tmp)
l=len(collections.Counter(box))
print(l) | 1 | 30,241,249,687,088 | null | 165 | 165 |
import sys
import itertools
N, K = map(int, input().split())
a = 0
h = 0
l = 0
for j in range(0,K-1):
h += j
for j in range(N+2-K,N+1):
l += j
for i in range(K,N+2):
h += i-1
l += N+1-i
a += l - h + 1
a %= 10 ** 9 + 7
print(a)
| # import itertools
# import math
# import sys
# sys.setrecursionlimit(500*500)
import numpy as np
# import heapq
# from collections import deque
# N = int(input())
# S = input()
# n, *a = map(int, open(0))
N, K = map(int, input().split())
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
# S = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 1)
# def factorization(n):
# arr = []
# temp = n
# for i in range(2, int(-(-n**0.5//1))+1):
# if temp%i==0:
# cnt=0
# while temp%i==0:
# cnt+=1
# temp //= i
# arr.append([i, cnt])
# if temp!=1:
# arr.append([temp, 1])
# if arr==[]:
# arr.append([n, 1])
# return arr
A = [i for i in range(N + 1)]
A = np.array(A)
cum_A = np.cumsum(A)
cnt = 0
for i in range(K, N + 1):
cnt += (cum_A[N] - cum_A[N - i]) - cum_A[i - 1] + 1
print((cnt + 1) % (10**9 + 7)) | 1 | 32,976,028,256,472 | null | 170 | 170 |
N,M = map(int,input().split())
L = map(int,input().split())
work = 0
for i in L :
work += i
if N >= work :
print ( N - work )
else :
print ("-1") | n, m = input().split()
a = list(map(int, input().split()))
s = 0
for i in a:
s += int(i)
if int(s) <= int(n):
print(int(n) - int(s))
else:
print("-1") | 1 | 31,838,706,946,408 | null | 168 | 168 |
n = int(input())
A = input().split(' ')
count = 0
for i in range(0, n):
minj = i
for j in range(i, n):
if int(A[j]) < int(A[minj]):
minj = j
if i != minj:
(A[i], A[minj]) = (A[minj], A[i])
count += 1
print(" ".join(A))
print(count) | N = int(input())
array = list(map(int, input().split()))
cnt = 0
for i in range(N):
minij = i
for j in range(i, N):
if array[j] < array[minij]:
minij = j
if minij != i:
array[i], array[minij] = array[minij], array[i]
cnt += 1
print(' '.join(map(str, array)))
print( "%d" % (cnt))
| 1 | 21,561,032,860 | null | 15 | 15 |
N, K = map(int, input().split())
if N % K == 0:
print(0)
elif N % K > abs((N%K)-K):
print(abs((N%K)-K))
else:
print(N%K) | def resolve():
D = int(input())
# 各コンテストタイプの満足度の下がりやすさ
c = list(map(int, input().split()))
# 各日程に各コンテストを開催した時の満足度増加量
s = []
for i in range(D):
s.append(list(map(int, input().split())))
# 最後に各コンテストを開催した日
l = [-1] * 26
# 満足度
v = 0
for d in range(D):
# この日に開催されるコンテストタイプ
t = int(input())-1
l[t] = d
# 増加分加算
v += s[d][t]
# 不満足分減算
for i in range(26):
v -= c[i] * (d - l[i])
print(v)
resolve() | 0 | null | 24,694,575,952,202 | 180 | 114 |
n,m=map(int,input().split())
a=list(map(int,input().split()))
ans=0
for i in range(m) :
ans = ans+a[i]
day=n-ans
#if day>=0 :
# print(day)
#else :
# print(-1)
print(day if day >= 0 else "-1") | N, M = map(int, input().split())
A = list(map(int, input().split()))
ans = N-sum(A)
if ans < 0:
ans = -1
print(ans) | 1 | 31,899,856,217,768 | null | 168 | 168 |
def BubbleSort(A):
for i in range(len(A)):
for j in range(len(A)-1,i,-1):
if A[j][1] < A[j-1][1]:
# リストの要素の文字列は2次元配列として記憶される
A[j],A[j-1] = A[j-1],A[j]
return A
def SelectionSort(A):
for i in range(len(A)):
mini = i
for j in range(i,len(A)):
if A[j][1] < A[mini][1]:
mini = j
A[i],A[mini] = A[mini],A[i]
return A
N = int(input())
# example for input to array : H4 C9 S4 D2 C3 (from cards)
array = [i for i in input().split()]
array_cp = list(array)
result_bs = BubbleSort(array)
print(*result_bs)
print('Stable') # Bubble sort is stable
result_ss = SelectionSort(array_cp)
print(*result_ss)
if result_ss == result_bs:
print('Stable')
else:
print('Not stable')
| import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
A = LS()
A_Bub = []
A_Sel = []
for i in range(N):
A_Bub.append([A[i][0], int(A[i][1]), i])
A_Sel.append([A[i][0], int(A[i][1]), i])
#BubleSort(C, N)
def BubleSort(C, N):
for i in range(N):
for j in range(N - 1, i, -1):
if C[j][1] < C[j - 1][1]:
a = C[j]
b = C[j - 1]
C[j] = b
C[j - 1] = a
#SelectionSort(C, N)
def SelectionSort(C, N):
for i in range(N):
minj = i
for j in range(i, N):
if C[j][1] < C[minj][1]:
minj = j
a = C[i]
b = C[minj]
C[i] = b
C[minj] = a
def Check(C, N):
for i in range(1, N):
if C[i][1] == C[i - 1][1]:
if C[i][2] < C[i - 1][2]:
return 'Not stable'
return 'Stable'
BubleSort(A_Bub, N)
ans_Bub = []
for i in range(N):
b = [A_Bub[i][0], A_Bub[i][1]]
ans_Bub.append(''.join(map(str, b)))
print(' '.join(map(str, ans_Bub)))
print(Check(A_Bub, N))
SelectionSort(A_Sel, N)
ans_Sel = []
for i in range(N):
s = [A_Sel[i][0], A_Sel[i][1]]
ans_Sel.append(''.join(map(str, s)))
print(' '.join(map(str, ans_Sel)))
print(Check(A_Sel, N))
| 1 | 25,181,169,004 | null | 16 | 16 |
n = input()
print n*n*n | #!/usr/bin python3
# -*- coding: utf-8 -*-
N, M, K = map(int, input().split())
md = 998244353
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % md )
inverse.append( ( -inverse[md % i] * (md//i) ) % md )
g2.append( (g2[-1] * inverse[-1]) % md )
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] % md
def cnt(k):
ret = pow(M-1, N-1-k, md)
ret *= cmb(N-1,k)
ret %= md
ret *= M
ret %= md
return ret
def main():
rt = 0
for k in range(K+1):
rt += cnt(k)
rt %= md
print(rt)
if __name__ == '__main__':
main()
| 0 | null | 11,645,517,353,300 | 35 | 151 |
n,m = tuple(int(i) for i in input().split())
A = [[int(j) for j in input().split()] for k in range(n)]
b = [int(input()) for p in range(m)]
R = [sum([A[p][q] * b[q] for q in range(m)]) for p in range(n)]
for r in R:
print(str(r))
| N = int(input())
ans = N%1000
if ans == 0:
print(0)
else:
print(1000-ans) | 0 | null | 4,851,864,967,360 | 56 | 108 |
while True:
(n, x) = [int(i) for i in input().split()]
if n == x == 0:
break
count = 0
for a in range(1, n + 1):
if a >= x:
break
for b in range(a + 1, n + 1):
if sum([a,b]) >= x:
break
for c in range(b + 1, n + 1):
if sum([a,b,c]) == x:
count += 1
print(count) | while True:
n, x = map(int, input().split())
if n == 0:
break
count = 0
for n1 in range(1, n+1):
for n2 in range(n1+1, n+1):
for n3 in range(n2+1, n+1):
if n1 + n2 + n3 == x:
count += 1
print(count) | 1 | 1,297,533,415,182 | null | 58 | 58 |
MAXN = 45
fibs = [-1] * MAXN
def fib(n):
"""Returns n-th fibonacci number
>>> fib(3)
3
>>> fib(10)
89
>>> fib(20)
10946
"""
if n == 0:
return 1
elif n == 1:
return 1
elif fibs[n] == -1:
fibs[n] = fib(n-1) + fib(n-2)
return fibs[n]
def run():
n = int(input())
print(fib(n))
if __name__ == '__main__':
run()
| a=[0]*45
def Fib(n):
if n == 0:
a[0]=1
return 1
elif n == 1:
a[1]=1
return 1
else:
if a[n]==0:
a[n]=Fib(n-1)+Fib(n-2)
return a[n]
else:
return a[n]
n=int(input())
print(Fib(n))
| 1 | 2,023,150,180 | null | 7 | 7 |
import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
a = str(readline().rstrip().decode('utf-8'))
print("A" if a.isupper() else "a")
if __name__ == '__main__':
solve()
| a, b, k =map(int, input().split())
if k <= a:
a = a-k
b = b
elif a+b <= k:
a = 0
b = 0
else:
b = a+b-k
a = 0
print(a, b)
| 0 | null | 57,795,409,306,148 | 119 | 249 |
def mul(num1,num2):
print(f"{num1}x{num2}={num1*num2}")
for i in range(1,10):
for j in range(1,10):
mul(i,j)
| #!/usr/bin/env python3
# -*- coding: utf-8 -*-
if __name__ == '__main__':
for i in range(1,10):
for j in range(1,10):
print('{}x{}={}'.format( i, j, i*j )) | 1 | 276,900 | null | 1 | 1 |
N,M=map(int, input().split())
class UnionFind():
def __init__(self, n):
self.n = n # ノード数
self.parents = [-1]*n # 各ノードごとのparent
def find(self, x):
# 自身が根であれば
if self.parents[x]<0:
return x
# そうでなければ、再帰的に繰り返し、自身の根を探索
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
# それぞれの根
x = self.find(x)
y = self.find(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 size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
uf = UnionFind(N)
for _ in range(M):
i, j = map(int, input().split())
i-=1
j-=1
uf.union(i,j)
max_size = 0
for i in range(N):
if uf.parents[i]<0:
size = uf.size(i)
if max_size<size:
max_size = size
print(max_size)
| import sys
n, k = tuple(map(int, input().split()))
lower_p = 0
w_list = []
for _ in range(n):
w = int(sys.stdin.readline())
lower_p = w if w > lower_p else lower_p
w_list.append(w)
def get_possible_n(p):
"""最大積載重量を p としたときに、所与のトラック台数 k で処理可能な荷物の数
所与の荷物数 n のうち、いくつ処理可能かを返す。荷物の重量と順序に依存し、
（弱い）単調増加関数である。これが返す最大値は n である。
"""
pos_n = 0
for _ in range(k):
acc_w = 0
while pos_n < n:
if acc_w + w_list[pos_n] <= p:
acc_w += w_list[pos_n]
pos_n += 1
else:
break
else:
break
return pos_n
# upper_p は、get_possible_n(upper_p) が確実に n を返すことが保証される値。
upper_p = lower_p * n // k + lower_p
def b_search(lower_p, upper_p):
while lower_p < upper_p:
mid_p = (lower_p + upper_p) // 2
if get_possible_n(mid_p) < n:
lower_p = mid_p + 1
else:
upper_p = mid_p
return lower_p
print(b_search(lower_p, upper_p))
| 0 | null | 2,039,253,040,624 | 84 | 24 |
#! python3
# distance.py
import math
x1, y1, x2, y2 = [float(x) for x in input().split(' ')]
print('%.5f'%math.sqrt(pow(x2-x1, 2) + pow(y2-y1, 2)))
| def resolve():
a = int(input())
print(a+a*a+a*a*a)
if '__main__' == __name__:
resolve() | 0 | null | 5,248,153,108,512 | 29 | 115 |
a,b=map(int,input().split())
print('%d %d %.5f\n'%(a//b,a%b,a/b)) | #coding:utf-8
a,b=map(int,input().split())
print(str(a//b)+" "+str(a%b)+" "+"%.6f"%(a/b)) | 1 | 595,801,460,438 | null | 45 | 45 |
n = int(input())
minr = float('inf')
maxd = -float('inf')
for _ in range(n):
r = int(input())
maxd = max(maxd, r - minr)
minr = min(minr, r)
print(maxd)
| n = int(raw_input())
minv = int(raw_input())
maxv = -1*10**9
for j in range( n-1 ):
num = int( raw_input( ) )
diff = num - minv
if maxv < diff:
maxv = diff
if num < minv:
minv = num
print maxv | 1 | 12,998,326,432 | null | 13 | 13 |
n=int(input())
r=input().split()
def BubbleSort(c, n):
for i in range(n):
for j in range(n-1, i, -1):
if int(c[j][-1]) < int(c[j-1][-1]):
c[j], c[j-1]=c[j-1],c[j]
return c
def SelectionSort(c, n):
for i in range(n):
m=i
for j in range(i, n):
if int(c[j][-1]) < int(c[m][-1]):
m=j
c[i],c[m]=c[m],c[i]
return c
l=list(r)
a=BubbleSort(l, n)
print(*a)
print('Stable')
l=list(r)
b=SelectionSort(l, n)
print(*b)
if a==b:
print('Stable')
else:
print('Not stable')
| a = list(map(int,input().split()))
T = a.index(0)
print(T+1)
# | 0 | null | 6,686,603,988,290 | 16 | 126 |
import sys
input = sys.stdin.readline
n = int(input())
a = 0
if n % 2 == 1:
a == 0
else:
n = n // 2
k = 5
while k <= n:
a += n // k
k *= 5
print(a) | #!/usr/bin/env python3
N = int(input())
if N % 2 == 1:
print(0)
else:
ret = 0
for i in range(1, 27):
ret += N // (2*5**i)
print(ret)
| 1 | 116,407,218,988,800 | null | 258 | 258 |
n = int(input())
x = list(input())
def popcount(n):
bin_n = bin(n)[2:]
count = 0
for i in bin_n:
count += int(i)
return count
cnt = 0
for i in range(n):
if x[i] == '1':
cnt += 1
plus = [0 for i in range(n)] # 2^index を cnt+1 で割った時のあまり
minus = [0 for i in range(n)] # 2^index を cnt-1 で割った時のあまり
if cnt == 0:
plus[0] = 0
else:
plus[0] = 1
if cnt != 1:
minus[0] = 1
for i in range(1, n):
plus[i] = (plus[i-1]*2) % (cnt+1)
if cnt != 1:
minus[i] = (minus[i-1]*2) % (cnt-1)
origin = int(''.join(x), base=2)
amariplus = origin % (cnt+1)
if cnt != 1:
amariminus = origin % (cnt-1)
for i in range(n):
if x[i] == '0':
amari = (amariplus + plus[n-i-1]) % (cnt+1)
else:
if cnt != 1:
amari = (amariminus - minus[n-i-1]) % (cnt-1)
else:
print(0)
continue
ans = 1
while amari != 0:
ans += 1
amari = amari % popcount(amari)
print(ans) | N = int(input())
X = input()
val = int(X,2)
C = X.count("1")
if C==1:
for i in range(N):
if X[i]=='1':
print(0)
elif i==N-1:
print(2)
else:
print(1)
exit()
# xをpopcountで割ったあまりに置き換える
def f(x):
if x==0: return 0
return 1 + f(x % bin(x).count("1"))
# 初回のpopcountでの割り方は、(C+1) or (C-1)
Y = val%(C+1)
if C-1 != 0:
Z = val%(C-1)
else:
Z = 0
for i in range(N):
if X[i] == "1":
if Z - 1 == 0:
print(0)
continue
k = (Z - pow(2,N-i-1,C-1)) % (C-1)
else:
k = (Y + pow(2,N-i-1,C+1)) % (C+1)
print(f(k)+1) | 1 | 8,291,489,519,332 | null | 107 | 107 |
N=int(input())
*A,=map(int,input().split())
ans=0
p=A[0]
for i in range(1,N):
if A[i]<p:
ans+=p-A[i]
else:
p=A[i]
print(ans) | #!/usr/bin/env python3
import numpy as np
# def input():
# return sys.stdin.readline().rstrip()
def main():
n, k = map(int, input().split())
warps = list(map(int, input().split()))
warps = [0] + warps
warps = np.array(warps, dtype=int)
dp = np.zeros((k.bit_length() + 1, n + 1), dtype=int)
dp[0, :] = warps
for h in range(1, len(dp)):
# dp[h] = dp[h - 1][dp[h - 1]]
dp[h] = np.take(dp[h - 1], dp[h - 1])
node = 1
# for i in reversed(range(k.bit_length())):
for i in range(k.bit_length(), -1, -1):
if k >> i & 1:
node = dp[i][node]
print(node)
main()
| 0 | null | 13,576,196,396,588 | 88 | 150 |
N,K=map(int,input().split())
m=N//K
print(min(abs(N-m*K),abs(N-(m+1)*K))) | from itertools import permutations as perm
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
comb = list(perm(range(1, N+1)))
def find(x):
for i, n in enumerate(comb):
if x == n:
return i
a = find(P)
b = find(Q)
ans = abs(a - b)
print(ans) | 0 | null | 69,847,978,524,870 | 180 | 246 |
#!/usr/bin/env python3
def next_line():
return input()
def next_int():
return int(input())
def next_int_array_one_line():
return list(map(int, input().split()))
def next_int_array_multi_lines(size):
return [int(input()) for _ in range(size)]
def next_str_array(size):
return [input() for _ in range(size)]
def main():
n = next_int()
ar = list(reversed(sorted(next_int_array_one_line())))
# print(ar)
res = ar[0]
n -= 2
use = 1
while n > 0:
if n >= 2:
res += ar[use] * 2
n -= 2
use += 1
else:
res += ar[use]
n -= 1
print(res)
if __name__ == '__main__':
main()
| import math
n = int(input())
a = list(map(int,input().split()))
s = sorted(a,reverse=True)
max = s[0]
for i in range(3,n+1):
max += s[math.ceil(i/2)-1]
print(max) | 1 | 9,149,551,434,198 | null | 111 | 111 |
def bingo(appear):
for j in range(3):
if appear[0][j] and appear[1][j] and appear[2][j]:
return "Yes"
for i in range(3):
if appear[i][0] and appear[i][1] and appear[i][2]:
return "Yes"
if appear[0][0] and appear[1][1] and appear[2][2]:
return "Yes"
if appear[0][2] and appear[1][1] and appear[2][0]:
return "Yes"
return "No"
card = []
for _ in range(3):
arr = list(map(int, input().split()))
card.append(arr)
appear = [[False for _ in range(3)] for _ in range(3)]
n = int(input())
for _ in range(n):
a = int(input())
for i in range(3):
for j in range(3):
if a == card[i][j]:
appear[i][j] = True
print(bingo(appear)) | n=3
num_list = []
for i in range(n):
num_list.append(list(map(int,input().split())))
N=int(input())
list1=[int(input()) for _ in range(N)]
list2=[]
i=0
while i<=2:
j=0
while j<=2:
list2.append(num_list[i][j])
j=j+1
i=i+1
s=0
for k in list2:
if list1.count(k)==1:
list2[s]=101
s=s+1
else:
s=s+1
continue
if list2[0]+list2[1]+list2[2]==303:
print('Yes')
elif list2[3]+list2[4]+list2[5]==303:
print('Yes')
elif list2[6]+list2[7]+list2[8]==303:
print('Yes')
elif list2[0]+list2[3]+list2[6]==303:
print('Yes')
elif list2[1]+list2[4]+list2[7]==303:
print('Yes')
elif list2[2]+list2[5]+list2[8]==303:
print('Yes')
elif list2[0]+list2[4]+list2[8]==303:
print('Yes')
elif list2[2]+list2[4]+list2[6]==303:
print('Yes')
else:
print('No')
| 1 | 59,764,035,294,532 | null | 207 | 207 |
X=int(input())
x=100
for i in range(10**4):
x += x//100
if X <= x:
print(i+1)
break | from string import ascii_uppercase as au
N = int(input())
S = input()
ans = ''
for s in S:
idx = (au.index(s) + N) % len(au)
ans += au[idx]
print(ans) | 0 | null | 81,126,628,076,754 | 159 | 271 |
from typing import List
class Dice:
def __init__(self, s: List[int]):
self.s = s
def get_s(self) -> int:
return self.s[0]
def invoke_method(self, mkey: str) -> None:
if mkey == 'S':
self.S()
return None
if mkey == 'N':
self.N()
return None
if mkey == 'E':
self.E()
return None
if mkey == 'W':
self.W()
return None
raise ValueError(f'This method does not exist. : {mkey}')
def set_s(self, s0, s1, s2, s3, s4, s5) -> None:
self.s[0] = s0
self.s[1] = s1
self.s[2] = s2
self.s[3] = s3
self.s[4] = s4
self.s[5] = s5
def S(self) -> None:
self.set_s(self.s[4], self.s[0], self.s[2], self.s[3], self.s[5],
self.s[1])
def N(self) -> None:
self.set_s(self.s[1], self.s[5], self.s[2], self.s[3], self.s[0],
self.s[4])
def E(self) -> None:
self.set_s(self.s[3], self.s[1], self.s[0], self.s[5], self.s[4],
self.s[2])
def W(self) -> None:
self.set_s(self.s[2], self.s[1], self.s[5], self.s[0], self.s[4],
self.s[3])
# 提出用
data = [int(i) for i in input().split()]
order = list(input())
# # 動作確認用
# data = [int(i) for i in '1 2 4 8 16 32'.split()]
# order = list('SE')
dice = Dice(data)
for o in order:
dice.invoke_method(o)
print(dice.get_s())
| N=int(input())
A=list(map(int,input().split()))
if N%2==0:
dp=[[-float("inf") for _ in range(2)] for _ in range(N+10)]
if N==2:
print(max(A[0],A[1]))
else:
for i in range(N):
if i==0:
dp[i][0]=A[0]
elif i==1:
dp[i][1]=A[1]
elif i==2:
dp[i][0]=A[0]+A[2]
else:
for j in range(2):
if j==0:
dp[i][0]=max(dp[i][0],dp[i-2][0]+A[i])
elif j==1:
dp[i][1]=max(dp[i][1],dp[i-2][1]+A[i],dp[i-3][0]+A[i])
print(max(dp[N-1]))
else:
#print(A[0],A[1])
dp=[[-float("inf") for _ in range(3)] for _ in range(N+10)]
if N==3:
print(max(A[0],A[1],A[2]))
else:
for i in range(N):
if i<4:
if i==0:
dp[i][0]=A[0]
if i==1:
dp[i][1]=A[1]
if i==2:
dp[i][2]=A[2]
dp[i][0]=A[0]+A[2]
if i==3:
dp[i][1]=max(dp[1][1]+A[3],dp[0][0]+A[3])
else:
for j in range(3):
if j==0:#ここでも2こずつ規則よく飛ばすと決めた
dp[i][0]=max(dp[i][0],dp[i-2][0]+A[i])
elif j==1:#1回だけ無茶した
dp[i][1]=max(dp[i][1],dp[i-2][1]+A[i],dp[i-3][0]+A[i])
else:
dp[i][2]=max(dp[i][2],dp[i-2][2]+A[i],dp[i-3][1]+A[i],dp[i-4][0]+A[i])
print(max(dp[N-1])) | 0 | null | 18,692,724,134,348 | 33 | 177 |
S = input()
S_inv = S[-1::-1]
counter = 0
for i in range(len(S)//2):
if S[i]!=S_inv[i]:
counter +=1
print(counter)
| #coding: utf-8
w = input()
w = w.upper()
s = []
c = 0
while True:
i = input()
if i == "END_OF_TEXT":
break
s.append(i.upper())
for i in s:
for j in i.split(" "):
if j == w:
c += 1
print(c)
| 0 | null | 60,632,287,156,560 | 261 | 65 |
K, N = map(int, input().split())
A = tuple(map(int, input().split()))
maxd = K - A[-1] + A[0]
for i in range(1, N):
d = A[i] - A[i-1]
maxd = max(maxd, d)
ans = K - maxd
print(ans) | n = int(input())
a = list(map(int, input().split()))
dict_diffs1 = dict()
dict_diffs2 = dict()
for i in range(1, n+1):
dict_diffs1[i+a[i-1]] = dict_diffs1.get(i+a[i-1], 0) + 1
dict_diffs2[i-a[i-1]] = dict_diffs2.get(i-a[i-1], 0) + 1
total = 0
for j in range(1, n+1):
total += dict_diffs1.get(j-a[j-1], 0)
total += dict_diffs2.get(j+a[j-1], 0)
total = total//2
print(total) | 0 | null | 34,853,571,164,750 | 186 | 157 |
n = int(input())
g = [[]for i in range(n)]
for i in range(n):
v = list(map(int,input().split()))
u = v[0]-1
k = v[1]
for j in range(k):
g[u].append(v[j+2]-1)
time = 1
ans = []
d = [0]*n
f = [0] *n
visited = [0]*n
def dfs(now,last = -1):
global time
visited[now] = 1
d[now] = time
time += 1
for next in g[now]:
if visited[next]:continue
dfs(next,now)
f[now] = time
time +=1
for i in range(n):
if not visited[i]:dfs(i)
for i in range(n):
print(i+1,d[i],f[i])
| N , K ,S =map(int,input().split())
if S != 10**9:
ans = [S]*K + [10**9]*(N-K)
else:
ans = [S]*K + [1]*(N-K)
print(" ".join(map(str,ans))) | 0 | null | 45,321,010,713,900 | 8 | 238 |
raw_input()
list = list(map(int,raw_input().split()))
list.sort()
print list[0],list[len(list) - 1],sum(list) | n = input()
l = [int(i) for i in input().split()]
print(' '.join([str(min(l)),str(max(l)),str(sum(l))])) | 1 | 735,685,190,290 | null | 48 | 48 |
N = int(input())
S = set(input() for _ in range(N))
print(len(S))
| a, b, c = map(int, input().split())
print('%s' % 'Yes' if a < b and b < c else 'No')
| 0 | null | 15,416,855,217,500 | 165 | 39 |
n=input()
a=[int(i) for i in raw_input().split()]
a.sort()
s=a[n-1]
for i in range(n/2,n-1):
s+=a[i]*2
if(n%2==1):
s-=a[n/2]
print s | def main():
N = int(input())
A = list(map(int, input().split()))
ans = 0
h = A[0]
for i in range(1, N):
ans += max(0, h - A[i])
h = max(h, A[i])
print(ans)
if __name__ == '__main__':
main() | 0 | null | 6,832,173,721,780 | 111 | 88 |
N = int(input())
X = list(map(int, input().split()))
MAX = 10 ** 6 + 1
prime = [True] * MAX
counted = set()
for v in X:
if v in counted:
prime[v] = False
continue
for j in range(2 * v, MAX, v):
prime[j] = False
counted.add(v)
ans = 0
for v in X:
ans += int(prime[v])
print(ans)
| import bisect
n=int(input())
a=list(map(int,input().split()))
suma=[]
sumans=0
for i in range(n):
sumans += a[i]
suma.append(sumans)
u=bisect.bisect_right(suma, sumans//2)
print(min(abs(2*suma[u-1]-sumans), abs(2*suma[u]-sumans))) | 0 | null | 78,364,608,835,720 | 129 | 276 |
import sys
from io import StringIO
import unittest
import os
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
class youk_prepare:
def __init__(self, n, mod=pow(10, 9) + 7):
f = 1
factorials = [1]
for m in range(1, n + 1):
f *= m
f %= mod
factorials.append(f)
inv = pow(f, mod - 2, mod)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= mod
invs[m - 1] = inv
self.factorials = factorials
self.invs = invs
self.mod = mod
def cmb(self, n, r):
if len(self.factorials) - 1 < n:
raise ValueError("コンストラクタで指定した要素数を超えているので無理。")
return (self.factorials[n] * self.invs[r] * self.invs[n - r]) % self.mod
def multi_cmb(self, n, r):
if len(self.factorials) - 1 < n:
raise ValueError("コンストラクタで指定した要素数を超えているので無理。")
return (self.factorials[n] * self.invs[r] * self.invs[n - r]) * (
self.factorials[n - 1] * self.invs[r] * self.invs[n - 1 - r]) % self.mod
# 実装を行う関数
def resolve(test_def_name=""):
try:
n, k = map(int, input().split())
a_s = list(map(int, input().split()))
a_s.sort()
youk = youk_prepare(n)
# 最小値の合計を計算
sum_mini = 0
for i in range(n - k + 1):
target = a_s[i]
val = target * youk.cmb(n - i - 1, k - 1)
sum_mini += val
# 最大値の合計を計算
sum_max = 0
for i in range(k - 1, n):
target = a_s[i]
val = target * youk.cmb(i, k - 1)
sum_max += val
ans = (sum_max - sum_mini) % (pow(10, 9) + 7)
print(ans)
except IndexError as err:
print("インデックスエラー:", err.args[0])
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """4 2
1 1 3 4"""
output = """11"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """6 3
10 10 10 -10 -10 -10"""
output = """360"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """3 1
1 1 1"""
output = """0"""
self.assertIO(test_input, output)
def test_input_4(self):
test_input = """10 6
1000000000 1000000000 1000000000 1000000000 1000000000 0 0 0 0 0"""
output = """999998537"""
self.assertIO(test_input, output)
# 自作テストパターン
def test_original(self):
test_input = """4 2
1 2 3 4"""
output = """10"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
| a = []
for i in range(3):
l,m,n = map(int,input().split())
a.append([l,m,n])
n = int(input())
b = []
for i in range(n):
b.append(int(input()))
#print(a)
#print(b)
for i in range(3):
for j in range(3):
for k in range(n):
if a[i][j] == b[k]:
a[i][j] = 0
tmp = 0
for i in range(3):
if a[i][0]+a[i][1]+a[i][2] == 0:
tmp = 1
elif a[0][i]+a[1][i]+a[2][i] == 0:
tmp = 1
if a[0][0]+a[1][1]+a[2][2] ==0:
tmp = 1
elif a[0][2]+a[1][1]+a[2][0] ==0:
tmp = 1
if tmp == 1:
print('Yes')
else:
print('No')
| 0 | null | 78,199,309,202,090 | 242 | 207 |
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
def f(a):
ans = 1
if 0 in a:
return 0
for i in a:
ans *= i
if ans > 1e+18:
return -1
return ans
print(f(a)) | setting = input().split();
package_count = int(setting[0]);
truck_count = int(setting[1]);
packages = [];
for i in range(package_count):
packages.append(int(input()));
def allocation():
max_p = sum(packages);
left = 0;
right = max_p;
while left < right:
mid = (left + right) // 2;
load = calculate_load(mid);
if load >= package_count:
right = mid;
else:
left = mid + 1;
return right;
def calculate_load(p):
i = 0;
j = 0;
current_truck_p = p;
while i < package_count and j < truck_count:
if packages[i] <= current_truck_p:
current_truck_p -= packages[i];
i += 1;
else:
j += 1;
current_truck_p = p;
return i;
print(allocation());
| 0 | null | 8,088,357,138,400 | 134 | 24 |
x = input().split()
a = int(x[0])
b = int(x[1])
if a == b :
print('a == b')
elif a > b :
print('a > b')
else :
print('a < b') | nums = input().split()
a = int(nums[0])
b = int(nums[1])
if a < b:
print('a < b')
elif a > b:
print('a > b')
else:
print('a == b') | 1 | 355,969,857,922 | null | 38 | 38 |
# 30分ぐらい？で溶けた！計算量は直感だよりだったが。
# → エラトステネスの篩 に相当する実装らしい。
# リスト内の倍数・約数関係を判定し、カウントする。
# 二重ループで判定するとTLEになるため、小さい値の可能な倍数を計算して保存するようにした。
# メモを set() ではなく 配列 で実装するテスト
n=int(input())
a=list(map(int,input().split()))
a.sort()
# 小さい側から処理する。a[i]について、10**6 以下のすべての倍数をset()として持つ。
# ただし、set内に存在しない==初出の約数のみ倍数計算をしてカウントする。
# 例えば、2,6,... となった場合、(6の倍数セットは2の倍数セットの下位集合となるため計算不要)
s=[False]*(10**6+1)
cnt=0
for i,aa in enumerate(a):
if s[aa]:
continue
# 同値が複数ある場合、カウントしない。
if i+1 == len(a) or aa != a[i+1]:
cnt+=1
for i in range(1,10**6+1):
ma=aa*i
if ma > 10**6:
break
s[ma]=True
print(cnt)
| import sys
from collections import Counter
import numba as nb
import numpy as np
input = sys.stdin.readline
@nb.njit("i8(i8[:],i8[:])", cache=True)
def solve(keys, values):
MAX_A = 10 ** 6
divisible = [False] * (MAX_A + 1)
ans = 0
for k, v in zip(keys, values):
if v == 1 and not divisible[k]:
ans += 1
for i in range(k, MAX_A + 1, k):
divisible[i] = True
return ans
def main():
N = int(input())
A = list(map(int, input().split()))
A.sort()
c = Counter(A)
keys = np.array(tuple(c.keys()), dtype=np.int64)
values = np.array(tuple(c.values()), dtype=np.int64)
ans = solve(keys, values)
print(ans)
if __name__ == "__main__":
main()
| 1 | 14,495,778,331,240 | null | 129 | 129 |
while True:
card = input()
if card == '-':
break
times = int(input())
while times:
h = int(input())
card = card[h:] + card[:h]
times -= 1
print(card) | x=int(input())
if x>=10000 or x//100*5>=x%100:
print(1)
else:
print(0) | 0 | null | 64,404,273,707,498 | 66 | 266 |
import sys
import itertools
import collections
def search(H, W, S, start):
wall_i = ord(b'#')
used = [[-1 for h in range(W)] for w in range(H)]
qu = collections.deque()
qu.append(start)
used[start[0]][start[1]] = 0
while qu:
h, w = qu.popleft()
cost = used[h][w]
for h0, w0 in ((h - 1, w), (h + 1, w), (h, w - 1), (h, w + 1)):
if not (0 <= h0 < H and 0 <= w0 < W):
continue
if used[h0][w0] != -1:
continue
if S[h0][w0] == wall_i:
continue
used[h0][w0] = cost + 1
qu.append((h0, w0))
return max(cost for costs in used for cost in costs)
def resolve(in_):
H, W = map(int, next(in_).split())
S = tuple(s.strip() for s in itertools.islice(in_, H))
road_i = ord(b'.')
roads = []
for h in range(H):
for w in range(W):
if S[h][w] == road_i:
roads.append((h, w))
ans = max(search(H, W, S, start) for start in roads)
return ans
def main():
answer = resolve(sys.stdin.buffer)
print(answer)
if __name__ == '__main__':
main()
| #木ではない
#非連結成分
#処理済みの判定、辺の距離はすべて1なので一度到達すればよい
from collections import deque
n = int(input())
V = [[] for _ in range(n+1)]
for _ in range(n):
inpt = list(map(int,input().split( )))
if len(inpt)>2:
V[inpt[0]] = inpt[2:]
lrg = 10000
D = [lrg]*(n+1)
End = [0]*(n+1)
D[1] = 0
Deq = deque()
time = 1
Q = [1]
Deq.append(1)
while len(Deq) > 0:
v = Deq.popleft()
for i in V[v]:
D[i] = min(D[i],D[v]+1)
if End[i] == 0:
Deq.append(i)
End[i] = 1
for i in range(1,n+1):
if D[i]<lrg-1:
print(i,D[i])
else:
print(i,-1)
| 0 | null | 47,282,931,374,370 | 241 | 9 |
# -*- 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 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)]
# MOD = int(1e09) + 7
MOD = 998244353
INF = int(1e15)
def divisor(N):
res = []
i = 2
while i * i <= N:
if N % i == 0:
res.append(i)
if i != N // i:
res.append(N // i)
i += 1
if N != 1:
res.append(N)
return res
def solve():
N = Scanner.int()
d0 = divisor(N - 1)
ans = len(d0)
d1 = divisor(N)
for d in d1:
X = N
while X % d == 0:
X //= d
if X % d == 1:
ans += 1
print(ans)
def main():
# sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
if __name__ == "__main__":
main()
| import math
N = int(input())
A = list(map(int,input().split()))
up = [[] for _ in range(N+1)] # 葉から考慮した場合の、最小値
up[N] = [A[N],A[N]]
#print(up)
for i in reversed(range(N)):
Min, Max = up[i+1]
#print(Min,Max)
Min_n = math.ceil(Min/2) + A[i]
Max_n = Max + A[i]
#print(A[i],i)
up[i] = [Min_n, Max_n]
#print(up)
if up[0][0] >= 2:
print(-1)
else:
down = 1
#print(down)
ans = 1
for i in range(1, N+1):
down *= 2
down = min(down,up[i][1]) - A[i]
ans += down + A[i]
print(ans) | 0 | null | 30,151,720,823,950 | 183 | 141 |
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
from math import *
x = A1*T1 + A2*T2 - (B1*T1 + B2*T2)
y = A1*T1 - B1*T1
if(x ==0 or y==0):
print('infinity')
elif(y * x > 0):
print(0)
else:
z = floor(abs(y) / abs(x))
if abs(y) == z * abs(x):
print(floor(abs(y)/abs(x))*2)
else:
print(floor(abs(y)/abs(x))*2+1)
| import sys
# import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
# from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
class Graph():
def __init__(self, v):
from heapq import heappop, heappush
self.v = v
self.graph = [[] for _ in range(v)]
self.INF = 10 ** 9
def addEdge(self, start, end, itr):
self.graph[start].append((end, itr))
self.graph[end].append((start, itr))
def BFS(self, start):
from collections import deque
dist = [-1] * self.v
ret = [0] * (self.v-1)
que = deque()
que.append((start, -1))
dist[start] = 0
while que:
now, _color = que.popleft()
color = 1
if _color == color: color += 1
for to, itr in self.graph[now]:
if dist[to] == -1:
que.append((to, color))
dist[to] = dist[now] + 1
ret[itr] = color
color += 1
if color == _color: color += 1
return ret
def color_types(self):
ret = len(self.graph[0])
for x in self.graph[1:]:
ret = max(ret, len(x))
return ret
def Main():
n = read_int()
g = Graph(n)
for i in range(n - 1):
a, b = read_ints()
g.addEdge(~-a, ~-b, i)
print(g.color_types())
print(*g.BFS(0), sep='\n')
if __name__ == '__main__':
Main() | 0 | null | 133,761,828,814,148 | 269 | 272 |
class Dice:
def __init__(self, faces):
self.faces = tuple(faces)
def roll_north(self):
self.faces = (self.faces[1], self.faces[5], self.faces[2],
self.faces[3], self.faces[0], self.faces[4])
def roll_south(self):
self.faces = (self.faces[4], self.faces[0], self.faces[2],
self.faces[3], self.faces[5], self.faces[1])
def roll_west(self):
self.faces = (self.faces[2], self.faces[1], self.faces[5],
self.faces[0], self.faces[4], self.faces[3])
def roll_east(self):
self.faces = (self.faces[3], self.faces[1], self.faces[0],
self.faces[5], self.faces[4], self.faces[2])
def number(self, face_id):
return self.faces[face_id - 1]
dice = Dice(list(map(int, input().split())))
n = int(input())
for i in range(n):
(face1, face2) = map(int, input().split())
if face2 == dice.number(3) or face2 == dice.number(4):
dice.roll_west()
while dice.number(2) != face2:
dice.roll_north()
while dice.number(1) != face1:
dice.roll_west()
print(dice.number(3)) | class dice:
men = [0] * 7
def __init__(self, li):
self.men = [0] + li
def move0(self, a, b, c, d):
self.men[a], self.men[b], self.men[c], self.men[d] = self.men[b], self.men[c], self.men[d], self.men[a]
def move(self, h):
if h == "N":
self.move0(1, 2, 6, 5)
elif h == "S":
self.move0(1, 5, 6, 2)
elif h == "W":
self.move0(1, 3, 6, 4)
elif h == "E":
self.move0(1, 4, 6, 3)
elif h == "O":
self.men[1], self.men[6], self.men[2], self.men[5] = self.men[6], self.men[1], self.men[5], self.men[2]
elif h == "L":
self.move0(2, 3, 5, 4)
elif h == "R":
self.move0(2, 4, 5, 3)
elif h == "B":
self.men[3], self.men[4], self.men[2], self.men[5] = self.men[4], self.men[3], self.men[5], self.men[2]
def move2(self, a, b):
if self.men[1] != a:
for i, s in [(2, "N"), (3, "W"), (4, "E"), (5, "S"), (6, "O")]:
if self.men[i] == a:
self.move(s)
break
if self.men[2] != b:
if b == self.men[3]:
self.move("L")
elif b == self.men[4]:
self.move("R")
else:
self.move("B")
saikoro = dice(list(map(int, input().split())))
for _ in range(int(input())):
saikoro.move2(*map(int, input().split()))
print(saikoro.men[3])
| 1 | 251,377,716,890 | null | 34 | 34 |
N, M, K = map(int, input().split())
MOD = 998244353
# 階乗 & 逆元計算
factorial = [1]
inverse = [1]
for i in range(1, N+2):
factorial.append(factorial[-1] * i % MOD)
inverse.append(pow(factorial[-1], MOD - 2, MOD))
# 組み合わせ計算
def nCr(n, r):
if n < r or r < 0:
return 0
elif r == 0:
return 1
return factorial[n] * inverse[r] * inverse[n - r] % MOD
ans = 0
for k in range(K + 1):
ans += M * nCr(N - 1, k) * pow(M - 1, N - 1 - k, MOD) % MOD
ans %= MOD
print(ans % MOD)
| n = input()
if len(n) < 3:
print(1000 - int(n))
else:
hasuu = n[len(n) - 3:]
if hasuu == '000':
print('0')
else:
print(1000-int(hasuu)) | 0 | null | 15,837,622,757,408 | 151 | 108 |
N = int(input())
for i in range(N):
sides = list(map(int, input().split()))
longestSide = max(sides)
sides.remove(longestSide)
if (longestSide ** 2) == (sides[0] ** 2 + sides[1] ** 2):
print('YES')
else:
print('NO') |
N = input()
a = []
for i in range(int(N)):
s = input().split()
ss = [int(s[0]), int(s[1]), int(s[2])]
ss.sort()
if ss[2]**2 == ss[0]**2 + ss[1]**2:
print("YES")
else:
print("NO") | 1 | 352,373,476 | null | 4 | 4 |
def func(K, X):
YEN = 500
ans = 'Yes' if YEN * K >= X else 'No'
return ans
if __name__ == "__main__":
K, X = map(int, input().split())
print(func(K, X))
| from math import sqrt
sigma=[]
while True:
total=0
nval=0
n=int(input())
if n==0:
break
score_list=map(float,raw_input().split(" "))
for i in score_list:
total+=i
average=total/n
for i in score_list:
nval+=(average-i)**2
val=nval/n
sigma.append(sqrt(val))
for i in sigma:
print i | 0 | null | 49,360,137,029,276 | 244 | 31 |
if __name__ == '__main__':
l = [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]
k = int(input())
print(l[k - 1]) | #!/usr/bin/env python
# encoding: utf-8
class Solution:
@staticmethod
def selection_sort():
# write your code here
array_length = int(input())
unsorted_array = [int(x) for x in input().split()]
count = 0
for i in range(array_length):
min_j = i
for j in range(i, array_length):
if unsorted_array[j] < unsorted_array[min_j]:
min_j = j
unsorted_array[i], unsorted_array[min_j] = unsorted_array[min_j], unsorted_array[i]
if i != min_j:
count += 1
print(" ".join(map(str, unsorted_array)))
print(str(count))
if __name__ == '__main__':
solution = Solution()
solution.selection_sort() | 0 | null | 25,007,921,258,378 | 195 | 15 |
import math
N = int(input())
P = list(map(int, input().split(" ")))
Q = list(map(int, input().split(" ")))
def find_order(num_list):
if len(num_list) == 1:
return 0
first = num_list[0]
order = sorted(num_list).index(first)
if order == 0:
return find_order(num_list[1:])
else:
return order * math.factorial(len(num_list) - 1) + find_order(num_list[1:])
order_p = find_order(P)
order_q = find_order(Q)
print(abs(order_p - order_q))
| bit=[0]*9
fa=[1]*9
for n in range(1,9):fa[n]=fa[n-1]*n
def up(id):
while id<9:
bit[id]+=1
id+=id&(-id)
def qr(id):
res=0
while id:
res+=bit[id]
id-=id&(-id)
return res
x=int(input())
s=list(map(int,input().split()))
z=list(map(int,input().split()))
v=''
for n in s:
a=qr(n)
vl=n-1-a
v+=str(vl)
up(n)
v=v[::-1]
r1=0
for n in range(len(v)):
r1+=int(v[n])*fa[n]
r2=0
v=''
bit=[0]*9
for n in z:
a=qr(n)
vl=n-1-a
v+=str(vl)
up(n)
v=v[::-1]
for n in range(len(v)):
r2+=int(v[n])*fa[n]
print(abs(r1-r2)) | 1 | 100,581,385,838,170 | null | 246 | 246 |
import collections
N = int(input())
A = [int(_) for _ in input().split()]
C = collections.Counter(A)
d = sum([C[i] * (C[i] - 1) // 2 for i in range(N + 1)])
for a in A:
print(d - C[a] + 1)
| from collections import *
from math import *
N = int(input())
A = list(map(int,input().split()))
C = Counter(A)
S = 0
for k,v in C.items():
S+=comb(v,2)
for a in A:
print(S-(comb(C[a],2)-comb(C[a]-1,2))) | 1 | 47,713,650,495,700 | null | 192 | 192 |
import math
A, B, H, M = list(map(int, input().split()))
rad = ((H / 12) - (M * 11 / 720)) * 2 * math.pi
ans = ((A ** 2) + (B ** 2) - (2 * A * B * math.cos(rad))) ** (1 / 2)
print(ans) | import sys
input = sys.stdin.readline
def main():
H, W, K = map(int, input().split())
stro = []; remain = K
start = H; end = 0
idx = 0
ans = []
for i in range(H):
tmp = list(input()[:-1])
cnt = 0
for j in tmp:
cnt += j == '#'
stro.append(cnt)
remain -= cnt
if cnt > 0:
start = min(start, i)
end = max(end, i)
if cnt == 1:
idx += 1
ans.append([idx]*W)
elif cnt >= 2:
idx += 1
cnttmp = 0
anstmp = []
for j in tmp:
cnttmp += j=='#'
idx += (cnttmp != 1 and j == '#' and cnt > 0)
cnt -= (j == '#' and cnt > 0)*1
anstmp.append(idx)
ans.append(anstmp)
else:
if remain == K:
continue
anstmp = ans[-1].copy()
ans.append(anstmp)
for _ in range(start):
print(*ans[0])
for i in range(len(ans)):
print(*ans[i])
if __name__ == "__main__":
main()
| 0 | null | 81,985,808,039,972 | 144 | 277 |
def north(d):
d[0], d[1], d[5], d[4] = d[1], d[5], d[4], d[0]
def west(d):
d[0], d[2], d[5], d[3] = d[2], d[5], d[3], d[0]
def east(d):
d[0], d[3], d[5], d[2] = d[3], d[5], d[2], d[0]
def south(d):
d[0], d[4], d[5], d[1] = d[4], d[5], d[1], d[0]
F = {'N': north, 'W': west, 'E': east, 'S': south}
d, os = list(map(int, input().split())), input()
for o in os:
F[o](d)
print(d[0]) | bingo=[]
for i in range(3):
a=list(map(int,input().split()))
bingo.append(a)
n=int(input())
for i in range(n):
b=int(input())
for j in range(3):
if b in bingo[j]:
bingo[j][bingo[j].index(b)]=0
def hantei(l):
for i in range(3):
if all([l[i][j]==0 for j in range(3)]):
return 'Yes'
elif all([l[j][i]==0 for j in range(3)]):
return 'Yes'
elif l[0][0]==0 and l[1][1]==0 and l[2][2]==0:
return 'Yes'
elif l[0][2]==0 and l[1][1]==0 and l[2][0]==0:
return 'Yes'
else:
continue
return 'No'
#print(bingo)
print(hantei(bingo)) | 0 | null | 30,131,597,130,166 | 33 | 207 |
#!/usr/bin/env python3
import collections
N = int(input().split()[0])
s_list = []
for _ in range(N):
s = input()
s_list.append(s)
counter = collections.Counter(s_list)
for item in ["AC", "WA", "TLE", "RE"]:
print(f"{item} x {counter[item]}")
|
n = int(input())
s = [str(input()) for i in range(n)]
a = s.count(('AC'))
b = s.count(('WA'))
c = s.count(('TLE'))
d = s.count(('RE'))
print("AC x {}".format(a))
print("WA x {}".format(b))
print("TLE x {}".format(c))
print("RE x {}".format(d))
| 1 | 8,644,070,403,332 | null | 109 | 109 |
# ABC 165 D - Floor Function
a,b,n = map(int, input().split())
def func(i):
return int(i*a/b) - a*int(i/b)
print(func(min(b-1, n))) | import copy
a = [int(c) for c in input().split()]
K = a[0]
N = a[1]
A = [int(c) for c in input().split()]
B = list(map(lambda x: x+K,copy.deepcopy(A)))
A = A+B
l = 0
tmp = 0
cnt = 0
for i in range(N):
tmp = A[i+1]-A[i]
if tmp > l :
cnt = i
l = tmp
print(K-l)
| 0 | null | 35,780,612,134,780 | 161 | 186 |
n,x,t = map(int,input().split())
if n % x ==0:
print(int(n/x*t))
else:
print(int((n//x+1)*t))
|
n = input()
m = map(int,raw_input().split())
a = 0
for i in xrange(n):
a += m[i]
print min(m),max(m),a | 0 | null | 2,464,308,460,020 | 86 | 48 |
a = int(input())
b = input().split()
c = []
for i in range(a * 2):
if i % 2 == 0:
c.append(b[0][i // 2])
else:
c.append(b[1][(i - 1) // 2])
for f in c:
print(f,end="") | N = int(input())
multiplication = []
for x in range(1, 10):
for y in range(1, 10):
multiplication.append(x*y)
if N in multiplication:
print( "Yes" )
else:
print( "No" ) | 0 | null | 136,389,249,111,460 | 255 | 287 |
K = int(input())
S = input()
l = list(S)
if len(l) <= K: print(S)
else:
ans = ''
for i in range(K):
ans += l[i]
ans += '...'
print(ans) | # 数値で入力ではなく, 文字列で入力しlist関数を使う
k = int(input())
s = input()
n = len(s)
list_s = list(s)
# リストのスライス機能を使用
if n > k:
tmp = list_s[0:k]
print(''.join(tmp) + '...')
else: print(''.join(list_s)) | 1 | 19,662,809,834,470 | null | 143 | 143 |
import math
n=int(input())
a=100000
for i in range(n):
a=a+a*0.05
if a%1000==0:
a=a
else:
a=(math.floor(a/1000))
a=a*1000+1000
print(a)
|
n = input()
d = [99999 for i in range(n)]
G = [0 for i in range(n)]
v = [[0 for i in range(n)] for j in range(n)]
def bfs(u):
for i in range(n):
if v[u][i] == 1:
if d[i] > d[u] + 1:
d[i] = d[u] + 1
bfs(i)
else:
continue
def _():
d[0] = 0
for i in range(n):
bfs(i)
for i in range(n):
if d[i] == 99999:
d[i] = -1
for i in range(n):
print '{0} {1}'.format(i+1, d[i])
for i in range(n):
G = map(int, raw_input().split())
for j in range(G[1]):
v[G[0]-1][G[2+j]-1] = 1
_() | 0 | null | 2,669,921,572 | 6 | 9 |
from random import randint
import sys
input = sys.stdin.readline
INF = 9223372036854775808
def calc_score(D, C, S, T):
"""
開催日程Tを受け取ってそこまでのスコアを返す
コンテストi 0-indexed
d 0-indexed
"""
score = 0
last = [0]*26 # コンテストiを前回開催した日
for d, t in enumerate(T):
last[t] = d + 1
for i in range(26):
score -= (d + 1 - last[i]) * C[i]
score += S[d][t]
return score
def update_score(D, C, S, T, score, ct, ci):
"""
ct日目のコンテストをコンテストciに変更する
スコアを差分更新する
ct: change t 変更日 0-indexed
ci: change i 変更コンテスト 0-indexed
"""
last = [0]*26 # コンテストiを前回開催した日
for d in range(ct):
last[T[d]] = d + 1
prei = T[ct] # 変更前に開催する予定だったコンテストi
score -= S[ct][prei]
score += S[ct][ci]
for d in range(ct, D):
if d != ct and T[d] == prei:
break
score += C[prei]*(d + 1 - ct - 1)
score -= C[prei]*(d + 1 - last[prei])
for d in range(ct, D):
if d != ct and T[d] == ci:
break
score += C[ci]*(d + 1 - last[ci])
score -= C[ci]*(d + 1 - ct - 1)
T[ct] = ci
return score, T
def evaluate(D, C, S, T, k):
"""
d日目終了時点での満足度を計算し，
d + k日目終了時点での満足度の減少も考慮する
"""
score = 0
last = [0]*26
for d, t in enumerate(T):
last[t] = d + 1
for i in range(26):
score -= (d + 1 - last[i]) * C[i]
score += S[d][t]
for d in range(len(T), min(len(T) + k, D)):
for i in range(26):
score -= (d + 1 - last[i]) * C[i]
return score
def greedy(D, C, S):
Ts = []
for k in range(5, 10):
T = [] # 0-indexed
max_score = -INF
for d in range(D):
# d+k日目終了時点で満足度が一番高くなるようなコンテストiを開催する
max_score = -INF
best_i = 0
for i in range(26):
T.append(i)
score = evaluate(D, C, S, T, k)
if max_score < score:
max_score = score
best_i = i
T.pop()
T.append(best_i)
Ts.append((max_score, T))
return max(Ts, key=lambda pair: pair[0])
def local_search(D, C, S, score, T):
ct = randint(0, D-1)
ci = randint(0, 25)
for _ in range(400000):
new_score, new_T = update_score(D, C, S, T, score, ct, ci)
if score < new_score:
score = new_score
T = new_T
return T
if __name__ == '__main__':
D = int(input())
C = [int(i) for i in input().split()]
S = [[int(i) for i in input().split()] for j in range(D)]
init_score, T = greedy(D, C, S)
T = local_search(D, C, S, init_score, T)
for t in T:
print(t+1)
| import random
import time
import copy
def down_score(d, c, last_d, score):
sum = 0
for i in range(26):
sum = sum + c[i]*(d-last_d[i])
return int(score - sum)
def main():
D = int(input())
c = list(map(int, input().split()))
s = [list(map(int, input().split())) for i in range(D)]
start = time.time()
last_d = [0 for i in range(26)]
ans = []
score1 = 0
for i in range(D):
max = 0
idx = 0
for j in range(26):
if max < (s[i][j] + c[j] * (i-last_d[j])*(i-last_d[j]+1)/2) and c[j] != 0:
max = s[i][j] + c[j] * (i-last_d[j])*(i-last_d[j]+1)/2
idx = j
elif max == (s[i][j] + c[j] * (i-last_d[j])*(i-last_d[j]+1)/2) and c[j] * (i-last_d[j])*(i-last_d[j]+1)/2 > c[idx]* (i-last_d[idx])*(i-last_d[idx]+1)/2 and c[j] != 0:
idx = j
last_d[idx] = i+1
score1 += s[i][idx]
score1 = down_score(i+1,c,last_d,score1)
ans.append(idx)
while time.time() - start < 1.9:
cp = ans.copy()
last_d = [0 for i in range(26)]
score2 = 0
idx1 = random.randint(0,25)
idx2 = random.randint(0,25)
idx3 = random.randint(0,25)
if random.randint(0,1):
d1 = random.randint(0,D-1)
d2 = random.randint(0,D-1)
d3 = random.randint(0,D-1)
if idx1 == idx2 or idx1 == idx3 or idx2 == idx3:
continue
if random.randint(0,1):
ans[d1] = idx1
elif random.randint(0,1):
ans[d1] = idx1
ans[d2] = idx2
else:
ans[d1] = idx1
ans[d2] = idx2
ans[d3] = idx3
#2値入れ替え
elif random.randint(0,1):
d1 = random.randint(0,D-8)
d2 = random.randint(d1+1,d1+7)
tmp1 = ans[d1]
tmp2 = ans[d2]
if random.randint(0,1):
ans[d1] = tmp2
ans[d2] = tmp1
#3値入れ替え
else:
d1 = random.randint(0,D-11)
d2 = random.randint(d1+1,d1+5)
d3 = random.randint(d2+1,d2+5)
tmp1 = ans[d1]
tmp2 = ans[d2]
tmp3 = ans[d3]
if random.randint(0,1):
ans[d1] = tmp2
ans[d2] = tmp3
ans[d3] = tmp1
else:
ans[d1] = tmp3
ans[d2] = tmp1
ans[d3] = tmp2
for i in range(D):
score2 += s[i][ans[i]]
last_d[ans[i]] = i+1
score2 = down_score(i+1, c, last_d, score2)
if score1 > score2:
ans = cp.copy()
else:
score1 = score2
for i in range(D):
print(ans[i]+1)
if __name__ == "__main__":
main()
| 1 | 9,671,661,226,792 | null | 113 | 113 |
N,M=map(int, input().split())
SC=[list(map(int, input().split())) for _ in range(M)]
num=[-1]*N
for sc in SC:
s,c=sc[0],sc[1]
if s==1 and c==0 and N>1:
print(-1)
exit()
elif num[s-1]==c or num[s-1]==-1:
num[s-1]=c
else:
print(-1)
exit()
if N==3:
if num[0]==-1:
num[0]=1
if num[1]==-1:
num[1]=0
if num[2]==-1:
num[2]=0
print(num[0]*100+num[1]*10+num[2])
elif N==2:
if num[0]==-1:
num[0]=1
if num[1]==-1:
num[1]=0
print(num[0]*10+num[1])
else:
if num[0]==-1:
num[0]=0
print(num[0]) | N,K = map(int,input().split())
a = sorted(list(map(int,input().split())),reverse=True)
del a[0:K]
print(sum(a)) | 0 | null | 69,981,686,919,810 | 208 | 227 |
X,Y,A,B,C=list(map(int,input().split()))
p=sorted(list(map(int,input().split())),reverse=True)
q=sorted(list(map(int,input().split())),reverse=True)
r=sorted(list(map(int,input().split())),reverse=True)
i=X-1
j=Y-1
k=0
ans=sum(p[:X])+sum(q[:Y])
while k<len(r):
if i>-1 and j>-1:
if p[i]<q[j]:
cmin=p[i]
i-=1
else:
cmin=q[j]
j-=1
if r[k]<=cmin:
break
ans+=r[k]-cmin
k+=1
elif i>-1:
cmin=p[i]
i-=1
if r[k]<=cmin:
break
ans+=r[k]-cmin
k+=1
elif j>-1:
cmin=q[j]
j-=1
if r[k]<=cmin:
break
ans+=r[k]-cmin
k+=1
else:
break
print(ans)
| import itertools
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
A = list(itertools.permutations(range(1, N+1)))
for a in range(len(A)):
if A[a] == P:
p = a
if A[a] == Q:
q = a
print(abs(p - q))
| 0 | null | 73,152,429,115,330 | 188 | 246 |