code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
n, x, m = map(int, input().split())
lis = [x]
flag = [-1 for i in range(m)]
flag[x] = 0
left = -1
right = -1
for i in range(n-1):
x = x**2 % m
if flag[x] >= 0:
left = flag[x]
right = i
break
else:
lis.append(x)
flag[x] = i+1
ans = 0
if left == -1:
ans = sum(lis)
else:
ans += sum(lis[0:left])
length = right - left + 1
ans += sum(lis[left:]) * ((n-left)//length)
ans += sum(lis[left:left+((n-left)%length)])
print(ans) | N, M, X = map(int, input().split())
C = []
A = []
for _ in range(N):
l = list(map(int, input().split()))
C.append(l[0])
A.append(l[1:])
ans = -1
for i in range((1<<N)):
u = [0] * M
p = 0
for j in range(N):
if i & (1 << j):
p += C[j]
for k in range(M):
u[k] += A[j][k]
if min(u) >= X:
if ans == -1 or ans > p:
ans = p
print(ans) | 0 | null | 12,469,799,977,948 | 75 | 149 |
X, K, D=(map(int, input().split()))
X=abs(X)
N=int(X/D)
if N==0:
if K%2==0:
print(X)
else:
print(D-X)
else:
if N>K:
print(X-K*D)
elif (K-N)%2==0:
print(X-N*D)
else:
print((N+1)*D-X) | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
x,k,d = map(int, input().split())
x = abs(x)
if x == 0:
if k % 2 == 0:
print(0)
exit()
else:
print(abs(d))
exit()
bai = x//d
if bai >= k:
print(x-k*d)
exit()
else:
x -= bai*d
if (k-bai)%2==0:
print(x)
exit()
else:
print(abs(x-d))
| 1 | 5,201,489,920,320 | null | 92 | 92 |
S = input()
from collections import defaultdict
d = defaultdict(int)
before = 0
for i in range(1,len(S)+1):
now = (int(S[-i])*pow(10,i,2019)+before) % 2019
d[now] += 1
before = now
d[0] += 1
ans = 0
for i in d.values():
ans += i*(i-1)//2
print(ans) | from collections import deque
data = input()
tmp = deque()
se = list()
ase = list()
lakes = list()
x = 0
#check start - end
for a in data:
if a == '\\':
tmp.append(x)
if a == '/' and len(tmp) > 0 :
s = tmp.pop()
se.append([s,x])
x += 1
se.sort()
# analyse s -e
if len(se) > 0 :
ase.append(se[0])
for i in range(1,len(se)) :
s,e = ase[len(ase)-1]
if e < se[i][0]:
ase.append(se[i])
#calc lakes
for a in ase:
lsize = 0
deep = 0
lx = a[0]
for m in data[a[0]:a[1] + 1] :
if m == '\\':
lsize += 1 + deep
deep += 1
elif m == '/':
deep -= 1
lsize += deep
if lx == a[1]:
lakes.append(lsize)
else: # '_'
lsize += deep
lx += 1
print(sum(lakes))
print(len(lakes),end="")
for lake in lakes:
print(" {}".format(lake),end="")
print()
| 0 | null | 15,483,089,813,378 | 166 | 21 |
n = input()
s, t = map(str, input().split())
for i in range(int(n)): print(s[i]+t[i], end = '') | N = int(input())
S, T = input().split()
answer = []
for s, t in zip(S, T):
answer.append(s)
answer.append(t)
print(*answer, sep='') | 1 | 112,509,155,373,722 | null | 255 | 255 |
x = int(input())
if 30 <= x:
print("Yes")
else:
print("No") | # -*- coding: utf-8 -*-
D = int(input())
c = list(map(int, input().split()))
s = []
t = []
for i in range(D):
s.append(list(map(int, input().split())))
for i in range(D):
t.append(int(input()) - 1)
last = [0] * 26
ans = 0
for i in range(D):
ans = ans + s[i][t[i]]
for j in range(26):
if t[i] != j:
last[j] += 1
ans = ans - (c[j] * last[j])
elif t[i] == j:
last[j] = 0
print(ans) | 0 | null | 7,892,589,796,220 | 95 | 114 |
n = int(input())
a = sorted(map(int, input().split()), reverse=True)
ans, que, cnt = 0, [a[0]], 0
for i in a[1:]:
ans += que[cnt]
que += [i, i]
cnt += 1
print(ans)
| N = int(input())
A = list(map(int, input().split()))
A = sorted(A, reverse = True)
L = len(A) // 2
if len(A) % 2 == 0:
#偶数の時
ans = sum(A[:L]) + sum(A[1:L])
else:
#奇数の時
ans = sum(A[:L]) + sum(A[1:L+1])
print(ans)
| 1 | 9,151,127,306,380 | null | 111 | 111 |
from sys import stdin, stdout
import math
import bisect
import datetime
n = int(stdin.readline().strip())
arr = list(map(int, stdin.readline().strip().split()))
arr.insert(0,0)
d={}
for i in range(len(arr)):
d[i] = arr[i]
arr = sorted(d.items(), key=lambda a: a[1])
dp = [[0 for i in range(2005)] for j in range(2005)]
for i in range(1, n + 1):
dp[i][i]=arr[1][1]*abs(arr[1][0]-i)
for l in range(2, n + 1):
pos, val = arr[l]
for left in range(1, n - l + 2):
right = left + l - 1
dp[left][right] = max(dp[left + 1][right] + val * abs(pos - left), dp[left][right - 1] + val * abs(pos - right))
stdout.writelines(str(dp[1][n]) + '\n') | n = int(input())
a = list(map(int, input().split()))
a = [(a[i], i) for i in range(n)]
a.sort(key=lambda x: -x[0])
dp = [[0 for _ in range(n+1)] for _ in range(n+1)]
for x in range(n+1):
for y in range(n+1):
if x + y > n:
break
active, idx = a[x+y-1]
if x > 0:
dp[x][y] = max(dp[x][y],
dp[x-1][y] + active * abs(idx - (x-1)))
if y > 0:
dp[x][y] = max(dp[x][y],
dp[x][y-1] + active * abs(idx - (n-y)))
ans = 0
for x in range(n+1):
ans = max(ans, dp[x][n-x])
print(ans) | 1 | 33,702,422,612,950 | null | 171 | 171 |
#0926
class UnionFind(): # 0インデックス
def __init__(self, n):
self.n = n
self.parents = [-1] * n
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 test(self):
return self.parents
def test2(self):
return sum(z <0 for z in self.parents)
N, M = map(int, input().split()) # N人、M個の関係
uf = UnionFind(N)
for _ in range(M):
A, B = map(int, input().split())
A -= 1
B -= 1
uf.union(A, B)
print(uf.test2()-1) | import sys
n=input()
house=[[[],[],[]],[[],[],[]],[[],[],[]],[[],[],[]]]
for i in range(4):
for j in range(3):
for k in range(10):
house[i][j].append(0)
for i in range(n):
b,f,r,v=map(int,raw_input().split())
house[b-1][f-1][r-1]+=v
for i in range(4):
for j in range(3):
for k in range(10):
sys.stdout.write(' %d'%house[i][j][k])
print('')
if i!=3:
print('#'*20) | 0 | null | 1,709,054,690,278 | 70 | 55 |
A,B,C,K=map(int,input().split())
if A>=K:
print(K)
exit()
elif A+B>=K:
print(A)
exit()
else:
c=K-A-B
print(A-c) | def resolve():
A, B, C, K = list(map(int, input().split()))
print(min(A, K) - max(0, K-(A+B)))
if '__main__' == __name__:
resolve() | 1 | 21,834,907,473,680 | null | 148 | 148 |
N, K = map(int, input().split())
# NをK進数に変換
digits = ''
while N >= 1:
digits += str(N % K)
N //= K
print(len(digits))
| N, K = map(int, input().split())
for i in range(1000000):
if K ** (i - 1) <= N < K ** i:
print(i)
break
| 1 | 64,719,198,960,962 | null | 212 | 212 |
n, m = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(m)]
ans = [-1]*n
flag = False
for s, c in X:
if ans[s-1] >= 0 and ans[s-1] != c:
flag = True
if n > 1 and s == 1 and c == 0:
flag = True
else:
ans[s-1] = c
if flag:
print(-1)
exit(0)
for i in range(n):
if ans[i] == -1:
if n > 1 and i == 0:
ans[i] = 1
else:
ans[i] = 0
print(*ans, sep="") | n, m = map(int,input().split())
sc = [list(map(int,input().split())) for i in range(m)]
flg = True
for ci in range(0, 10**n):
cis = str(ci)
if len(cis) != n:
continue
for j in range(m):
s, c = sc[j][0]-1, sc[j][1]
if int(cis[s]) != sc[j][1]:
flg = False
break
if j == m-1:
flg = True
if flg == True:
break
print(ci) if flg else print(-1) | 1 | 60,789,789,381,008 | null | 208 | 208 |
X,Y=map(int,input().split())
if Y%2 == 0:
if X*2 <= Y and Y <= X*4:
print("Yes")
else:
print("No")
else:
print("No") | x,y=map(int,input().split())
if ((4*x-y)%2==0 and (-2*x+y)%2==0) and (1<=(4*x-y)//2<=100 and 1<=(-2*x+y)//2<=100):
print('Yes')
elif ((4*x-y)%2==0 and (-2*x+y)%2==0) and (1<=(4*x-y)//2<=100 and (-2*x+y)//2==0):
print('Yes')
elif ((4*x-y)%2==0 and (-2*x+y)%2==0) and ((4*x-y)//2==0 and 1<=(-2*x+y)//2<=100):
print('Yes')
else :
print('No')
| 1 | 13,829,856,497,340 | null | 127 | 127 |
l=int(input(""))
v=l*l*l
d=int(v/27)
print((v%27)/27+d)
| X,N=map(int,input().split())
if N>0:
P=list(map(int,input().split()))
for i in range(N+1):
if X-i not in P:
print(X-i)
break
elif X+i not in P:
print(X+i)
break
else:
print(X) | 0 | null | 30,647,882,450,342 | 191 | 128 |
a,b = [int(x) for x in input().split()]
print(a * b) | def d(x):
dl=[]
for i in range(1, int(x**0.5)+1):
if x%i==0:
dl.append(i)
if i!=x//i:
dl.append(x//i)
return dl
n=int(input())
ans=0
t=d(n)
for i in t:
if i==1:
continue
tn=n
while tn>=i:
if tn%i==0:
tn//=i
else:
tn%=i
if tn==1:
ans+=1
ans+=len(d(n-1))-1
print(ans) | 0 | null | 28,432,550,127,940 | 133 | 183 |
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
H, W = map(int, readline().split())
import math
if H == 1 or W == 1:
print(1)
exit()
total = H * W
ans = (total + 2 - 1) // 2
print(ans) | full = input()
num = 0
for i in full:
if num < 3:
num += 1
print(i, end="") | 0 | null | 32,771,786,685,782 | 196 | 130 |
n = int(input())
a = [int(x) for x in input().split()]
ans = 0
maxa = 0
for aa in a:
maxa = max(maxa, aa)
ans += maxa - aa
print(ans) | S=input()
Q=int(input())
rev = 0
front, back=[],[]
for i in range(Q):
q = input()
if len(q)==1:rev = 1- rev
else:
n,f,c=q.split()
if f=='1' and rev==0:
front.append(c)
elif f=='2' and rev==1:
front.append(c)
elif f=='1' and rev==1:
back.append(c)
elif f=='2' and rev == 0:
back.append(c)
if rev==0:
S = ''.join(front[::-1]) + S + ''.join(back)
else:
S = ''.join(back[::-1]) + S[::-1] + ''.join(front)
print(S) | 0 | null | 30,772,841,213,268 | 88 | 204 |
A, B = input().split(" ")
A = int(A.strip())
B = int(B.strip().replace(".", ""))
print(A * B // 100) | n = int(input())
if n == 1:
print(0)
exit()
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
chk = factorization(n)
ans = 0
for num,k in chk:
now = 1
while True:
if k < now:
break
ans += 1
k -= now
now += 1
print(ans) | 0 | null | 16,798,369,316,132 | 135 | 136 |
n = int(input())
ans = 0
for a in range (1,n):
for b in range(1, n):
if n <= a * b:
break
ans += 1
print(ans) | from math import sqrt
# Function to return count of Ordered pairs
# whose product are less than N
def countOrderedPairs(N):
# Initialize count to 0
count_pairs = int(0)
# count total pairs
p = int(sqrt(N - 1)) + 1
q = N
# q = int(sqrt(N)) + 2
for i in range(1, p, 1):
for j in range(i, q, 1):
if i * j > N-1:
break
# print(i,j)
count_pairs += 1
#print(count_pairs)
# multiply by 2 to get ordered_pairs
count_pairs *= 2
#print(count_pairs)
# subtract redundant pairs (a, b) where a==b.
count_pairs -= int(sqrt(N - 1))
# return answer
return count_pairs
# Driver code
N = int(input())
print(countOrderedPairs(N))
# ans=prime_factorize(N)
# print(ans) | 1 | 2,597,924,157,180 | null | 73 | 73 |
NK = input().split()
n = int(NK[0])
k = int(NK[1])
arr = list(map(int, input().split()))
arr.sort()
print(sum(arr[0:k]))
| N, K = map(int, input().split())
P=list(map(int,input().split()))
list.sort(P)
from itertools import accumulate
ans = list(accumulate(P))
print(ans[K-1]) | 1 | 11,739,006,424,888 | null | 120 | 120 |
a,b,c=map(int,input().split())
print(c,a,b) | a=list(map(int,input().split()))
print(*[a[2],a[0],a[1]],sep=' ') | 1 | 38,038,419,589,202 | null | 178 | 178 |
from collections import Counter
import itertools
n=int(input())
rgb=list(input())
rgb_counter=Counter(rgb)
n_list=[i for i in range(1,n+1)]
count=0
for i,j in itertools.combinations(n_list,2):
k=2*j-i
if k<=n and rgb[j-1]!=rgb[i-1] and rgb[j-1]!=rgb[k-1] and rgb[i-1]!=rgb[k-1]:
count+=1
print(rgb_counter["R"]*rgb_counter["G"]*rgb_counter["B"]-count)
| # collections.deque is implemented using doubly linked list at C level..
from collections import deque
linkedlist = deque()
for _ in range(int(input())):
input_command = input()
if input_command == 'deleteFirst':
linkedlist.popleft()
elif input_command == 'deleteLast':
linkedlist.pop()
else:
com, num = input_command.split()
if com == 'insert':
linkedlist.appendleft(num)
elif com == 'delete':
try:
linkedlist.remove(num)
except:
pass
print(' '.join(linkedlist))
| 0 | null | 18,036,129,250,148 | 175 | 20 |
x = int(input())
t = x // 500
print(1000 * t + 5 * ((x - 500 * t) // 5)) | #!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N = int(input())
C = input()
left = 0
right = N-1
count = 0
while left < right:
if C[left] == 'W' and C[right] == 'R':
count += 1
left += 1
right -= 1
if C[left] == 'R':
left += 1
if C[right] == 'W':
right -= 1
print(count)
| 0 | null | 24,365,560,077,390 | 185 | 98 |
import sys
input = sys.stdin.readline
N, M, L = map(int, input().split())
inf = 10**15
V = [[] for _ in range(N)]
for _ in range(M):
A, B, C = map(int, input().split())
if C>L:continue
V[A-1].append((B-1, C))
V[B-1].append((A-1, C))
dists = []
for i in range(N):
dist = [(inf,inf)] * N
dist[i] = (0, 0)
u = [False] * N
for _ in range(N):
(charged, used), j = min([(dist[i], i) for i in range(N) if not u[i]])
u[j] = True
for k, next_cost in V[j]:
if j==k: continue
c = (charged+1, next_cost) if used+next_cost>L else (charged, used+next_cost)
if dist[k] > c:
dist[k] = c
dists.append(dist)
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
ans = dists[s-1][t-1][0]
print(ans if ans!=inf else -1)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(pow(10, 6))
def main():
n, m, l = map(int, input().split())
d = [[float("inf") for _ in range(n)] for _ in range(n)]
for i in range(n):
d[i][i] = 0
for _ in range(m):
a, b, c = map(int, input().split())
d[a-1][b-1] = c
d[b-1][a-1] = c
for k in range(n):
for i in range(n):
for j in range(n):
if d[i][j] > d[i][k] + d[k][j]:
d[i][j] = d[i][k] + d[k][j]
dl = [[float("inf") for _ in range(n)] for _ in range(n)]
for i in range(n):
d[i][i] = 0
for i in range(n):
for j in range(i+1, n):
if i != j and d[i][j] <= l:
dl[i][j] = 1
dl[j][i] = 1
for k in range(n):
for i in range(n):
for j in range(n):
if dl[i][j] > dl[i][k] + dl[k][j]:
dl[i][j] = dl[i][k] + dl[k][j]
q = int(input())
for _ in range(q):
s, t = map(int, input().split())
if dl[s-1][t-1] == float("inf"):
print(-1)
else:
print(dl[s-1][t-1] - 1)
if __name__ == '__main__':
main()
| 1 | 172,953,982,002,312 | null | 295 | 295 |
from collections import deque
H, W = map(int, input().split())
S = [list(input()) for _ in range(H)]
dir = [(-1, 0), (1, 0), (0, -1), (0, 1)]
dist = [[-1] * W for _ in range(H)]
def BFS(y, x):
"""(y, x)からはじめて、道のマスをBFSで最短距離を探す"""
que = deque()
que.append((y, x))
dist[y][x] = 0
max_dist = 0
while que:
sy, sx = que.popleft() # popleft?
for dy, dx in dir:
ny = sy + dy
nx = sx + dx
if 0 <= ny < H and 0 <= nx < W and S[ny][nx] != "#" and dist[ny][nx] == -1:
que.append((ny, nx))
dist[ny][nx] = dist[sy][sx] + 1
max_dist = max(max_dist, dist[ny][nx])
return max_dist
max_dist = 0
for sy in range(H):
for sx in range(W):
if S[sy][sx] != "#":
dist = [[-1] * W for _ in range(H)]
max_dist = max(max_dist, BFS(sy, sx))
print(max_dist) | class BalancingTree:
def __init__(self, n):
self.N = n
self.root = self.node(1<<n, 1<<n)
def append(self, v):# v を追加（その時点で v はない前提）
v += 1
nd = self.root
while True:
if v == nd.value:
# v がすでに存在する場合に何か処理が必要ならここに書く
return 0
else:
mi, ma = min(v, nd.value), max(v, nd.value)
if mi < nd.pivot:
nd.value = ma
if nd.left:
nd = nd.left
v = mi
else:
p = nd.pivot
nd.left = self.node(mi, p - (p&-p)//2)
break
else:
nd.value = mi
if nd.right:
nd = nd.right
v = ma
else:
p = nd.pivot
nd.right = self.node(ma, p + (p&-p)//2)
break
def leftmost(self, nd):
if nd.left: return self.leftmost(nd.left)
return nd
def rightmost(self, nd):
if nd.right: return self.rightmost(nd.right)
return nd
def find_l(self, v): # vより真に小さいやつの中での最大値（なければ-1）
v += 1
nd = self.root
prev = 0
if nd.value < v: v = nd.value
while True:
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return prev - 1
else:
prev = nd.value
if nd.right:
nd = nd.right
else:
return prev - 1
def find_r(self, v): # vより真に大きいやつの中での最小値（なければRoot）
v += 1
nd = self.root
prev = 0
while True:
if v < nd.value:
prev = nd.value
if nd.left:
nd = nd.left
else:
return prev - 1
else:
if nd.right:
nd = nd.right
else:
return prev - 1
@property
def max(self):
return self.find_l((1<<self.N)-1)
@property
def min(self):
return self.find_r(-1)
def delete(self, v, nd = None, prev = None): # 値がvのノードがあれば削除（なければ何もしない）
v += 1
if not nd: nd = self.root
if not prev: prev = nd
while v != nd.value:
prev = nd
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return
else:
if nd.right:
nd = nd.right
else:
return
if (not nd.left) and (not nd.right):
if nd.value < prev.value:
prev.left = None
else:
prev.right = None
elif not nd.left:
if nd.value < prev.value:
prev.left = nd.right
else:
prev.right = nd.right
elif not nd.right:
if nd.value < prev.value:
prev.left = nd.left
else:
prev.right = nd.left
else:
nd.value = self.leftmost(nd.right).value
self.delete(nd.value - 1, nd.right, nd)
def __contains__(self, v: int) -> bool:
return self.find_r(v - 1) == v
class node:
def __init__(self, v, p):
self.value = v
self.pivot = p
self.left = None
self.right = None
k = (500000+1).bit_length()
dic = {}
for i in range(97, 123):
dic[chr(i)] = BalancingTree(k)
n = int(input())
s = input()
lst = []
for i in range(n):
lst.append(s[i])
dic[s[i]].append(i)
ans = []
q = int(input())
for _ in range(q):
que = input()
if que[0] == '1':
kind, i, c = que.split()
i = int(i) - 1
dic[lst[i]].delete(i)
dic[c].append(i)
lst[i] = c
else:
kind, l, r = map(int, que.split())
l -= 2; r -= 1
temp = 0
for key in dic.keys():
if dic[key].find_r(l) <= r:
temp += 1
ans.append(temp)
for i in ans:
print(i) | 0 | null | 78,215,736,501,462 | 241 | 210 |
import itertools
n = input()
a = list(map(int, input().split()))
q = input()
aset = set()
for i in range(1, len(a) + 1):
aset |= set(sum(combi) for combi in itertools.combinations(a, i))
for m in map(int, input().split()):
print('yes' if m in aset else 'no') | import math
N=int(input())
price=math.ceil(N/1.08)
print(price if math.floor(price*1.08)==N else ":(") | 0 | null | 62,780,139,372,420 | 25 | 265 |
INF = float('inf')
H, W = map(int, input().split())
Sss = ['#'*(W+2)] + ['#'+input()+'#' for _ in range(H)] + ['#'*(W+2)]
def convGrid2Graph(Sss):
dxys = [(-1,0), (1,0), (0,-1), (0,1)]
sizeX, sizeY = len(Sss)-2, len(Sss[0])-2
numV = sizeX * sizeY
adjL = [[] for _ in range(numV)]
for x in range(1, sizeX+1):
for y in range(1, sizeY+1):
if Sss[x][y] != '.': continue
z = (x-1)*sizeY + (y-1)
for dx, dy in dxys:
x2, y2 = x+dx, y+dy
if Sss[x2][y2] != '.': continue
z2 = (x2-1)*sizeY + (y2-1)
adjL[z].append(z2)
return adjL
def WarshallFloyd(adjList, INF):
numV = len(adjList)
D = [[INF]*numV for _ in range(numV)]
for u, adj in enumerate(adjList):
for v in adj:
D[u][v] = 1
D[u][u] = 0
for k in range(numV):
Dk = D[k]
for i in range(numV):
Di = D[i]
Dik = Di[k]
for j in range(numV):
D2 = Dik + Dk[j]
if D2 < Di[j]:
D[i][j] = D2
return D
adjL = convGrid2Graph(Sss)
distss = WarshallFloyd(adjL, INF)
ans = 0
for i in range(H*W):
for j in range(H*W):
if distss[i][j] != INF:
ans = max(ans, distss[i][j])
print(ans)
| def main():
N, M, L = map(int, input().split())
A = tuple(tuple(map(int, input().split())) for _ in range(N))
B = tuple(tuple(map(int, input().split())) for _ in range(M))
cell = 0
row = []
for n in range(N):
for l in range(L):
for m in range(M):
cell += A[n][m] * B[m][l]
row.append(cell)
cell = 0
print(*row, sep=' ')
row = []
main() | 0 | null | 47,981,284,381,340 | 241 | 60 |
#!/usr/bin/python3
# -*- coding:utf-8 -*-
import numpy
def main():
_, _, k = map(int, input().strip().split())
la = numpy.cumsum([0] + list(map(int, input().strip().split())))
lb = numpy.cumsum([0] + list(map(int, input().strip().split())) + [10**9+5])
def bs(x):
s, t = 0, len(lb) - 1
while t > s + 1:
m = (s + t) // 2
if lb[m] == x:
return m
if lb[m] > x:
t = m
else:
s = m
return s
ans = 0
for i, a in enumerate(la):
if k - a >= 0:
ans = max(ans, i + bs((k - a)))
print(ans)
if __name__=='__main__':
main()
| N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
answer = 0
b_ind = 0
for x in range(N-1):
A[x+1] += A[x]
if A[x+1] > K:
A = A[:x+1]
break
for y in range(M-1):
B[y+1] += B[y]
if B[y+1] > K:
B = B[:y+1]
break
A = [0] + A
B = [0] + B
na = len(A)
nb = len(B)
if A[-1] + B[-1] <= K:
answer = len(A) + len(B) - 2
print(answer)
else:
for i in range(na):
for j in range(nb-b_ind-1, -1, -1):
if A[i] + B[j] <= K:
if answer < i+j:
answer = i+j
b_ind = nb-j-1
break
print(answer) | 1 | 10,683,049,970,812 | null | 117 | 117 |
X = int(input())
i = 1
while (360 * i) % X != 0: i += 1
print((360 * i) // X) | X=int(input())
i=1
a=0
while True:
a=a+X
if a%360==0:
print(i)
break
i+=1 | 1 | 13,058,625,159,932 | null | 125 | 125 |
N=int(input())
mod=10**9+7
a = (10**N)%mod
b = (9**N)%mod
c = (8**N)%mod
ans = (a+c-2*b)%mod
print(ans) | n = int(input())
mod = 10**9 + 7
contain_zero = 0
contain_nine = 0
not_contain_zero_and_nine = 0
all_per = pow(10,n,mod)
if n < 2:
print(0)
else:
contain_zero = all_per - pow(9,n,mod)
contain_nine = all_per - pow(9,n,mod)
not_contain_zero_and_nine = pow(8,n,mod)
print((-(all_per - not_contain_zero_and_nine -contain_nine - contain_zero))%mod)
| 1 | 3,124,645,109,278 | null | 78 | 78 |
s = input()
n = len(s) // 2
if "hi"*n == s:
print("Yes")
else:
print("No") | N = int(input())
n = min(N, 10**6)
is_Prime = [True] * (n + 1)
is_Prime[0] = False
is_Prime[1] = False
for i in range(2, int(n**(1/2)+1)):
for j in range(2*i, n+1, i):
if j % i == 0:
is_Prime[j] = False
P = [i for i in range(n+1) if is_Prime[i]]
count = 0
for p in P:
count_p = 0
while N % p == 0:
count_p += 1
N /= p
count += int((-1+(1+8*count_p)**(1/2))/2)
if p == P[-1] and N != 1:
count += 1
print(count) | 0 | null | 35,297,963,708,348 | 199 | 136 |
from math import ceil
n = int(input())
a = [chr(i) for i in range(97, 97+26)]
s = 0
for i in range(1,100):
l = n - s
s += 26**i
if n <= s:
m = i
break #第m群l番目
name = [0] * m
div = [0] * m
rem = [0] * m
rem[-1] = l
for j in range(m):
div[j] = ceil(rem[j-1] / (26**(m-j-1)))
rem[j] = rem[j-1] % (26**(m-j-1))
if rem[j] == 0:
rem[j] == 26**(m-j-1)
name[j] = a[div[j]-1]
print(''.join(name)) | import string
alphabet = list(string.ascii_lowercase)
n = int(input())
ans = []
while n > 0:
o = (n-1) % 26
n = (n-1) // 26
ans.append(alphabet[o])
ans.reverse()
print("".join(ans)) | 1 | 11,933,635,741,600 | null | 121 | 121 |
import sys
from collections import deque
input = sys.stdin.readline
H, W = map(int, input().split())
grid = []
for _ in range(H):
grid.append(list(input().strip()))
q = deque()
# x, y, count, pre color
q.append((0, 0, 1 if grid[0][0] == "#" else 0, grid[0][0]))
visited = [[-1 for _ in range(W)] for _ in range(H)]
ans = float("inf")
while q:
x, y, count, pre = q.popleft()
# print(x, y, count, pre)
v_score = visited[y][x]
if v_score != -1 and v_score <= count:
continue
visited[y][x] = count
for dx, dy in ((1, 0), (0, 1)):
nx = x + dx
ny = y + dy
nc = count
if nx < 0 or W <= nx or ny < 0 or H <= ny:
continue
n_color = grid[ny][nx]
if n_color != pre and n_color == "#":
nc += 1
if nx == W-1 and ny == H-1:
ans = min(ans, nc)
print(ans)
sys.exit()
else:
if visited[ny][nx] != -1 and visited[ny][nx] <= nc:
continue
if count == nc:
q.appendleft((nx, ny, nc, n_color))
else:
q.append((nx, ny, nc, n_color))
# print(visited)
print(ans) | import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
A, B, C = [int(x) for x in input().split()]
K = int(input())
cnt = 0
while A >= B:
cnt += 1
B *= 2
while B >= C:
cnt += 1
C *= 2
if cnt <= K:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| 0 | null | 28,122,062,275,200 | 194 | 101 |
x = int(input())
q, r = divmod(x, 500)
ans = q*1000
ans += (r//5)*5
print(ans)
| N = int(input())
a = N // 500
N -= 500 * a
b = N // 5
print(a * 1000 + b * 5)
| 1 | 42,884,292,947,550 | null | 185 | 185 |
import sys
import math
import cmath
sys.setrecursionlimit(1000000)
def dft_divide(f, l):
if l == 1:
return
ll = l // 2
f0 = [f[2 * i] for i in range(ll)]
f1 = [f[2 * i + 1] for i in range(ll)]
dft_divide(f0, ll)
dft_divide(f1, ll)
dft_solve(f, f0, f1, l)
return
def dft_solve(f, f0, f1, l):
ll = l // 2
for i in range(l):
z = cmath.exp(2j * i * cmath.pi / l)
f[i] = f0[i % ll] + z * f1[i % ll]
return
def idft_divide(f, l):
if l == 1:
return
ll = l // 2
f0 = [f[2 * i] for i in range(ll)]
f1 = [f[2 * i + 1] for i in range(ll)]
idft_divide(f0, ll)
idft_divide(f1, ll)
idft_solve(f, f0, f1, l)
return
def idft_solve(f, f0, f1, l):
ll = l // 2
for i in range(l):
z = cmath.exp(-2j * i * cmath.pi / l)
f[i] = f0[i % ll] + z * f1[i % ll]
return
def multiply(f, g):
lf, lg = len(f), len(g)
m = 2 ** (int(math.log2(lf + lg)) + 1)
for i in range(m - lf):
f.append(0)
for i in range(m - lg):
g.append(0)
dft_divide(f, m)
dft_divide(g, m)
fg = [f[i] * g[i] for i in range(m)]
idft_divide(fg, m)
c = [round(fg[i].real / m) for i in range(m)]
return c, m
n, m = map(int, input().split())
a = list(map(int, input().split()))
ma = max(a)
happiness1 = [0] * (ma + 1)
happiness2 = [0] * (ma + 1)
for i in a:
happiness1[i] += 1
happiness2[i] += 1
c, lc = multiply(happiness1, happiness2)
cnt = 0
ans = 0
for i in range(min(200000, lc - 1), -1, -1):
if c[i] + cnt >= m:
ans += (m - cnt) * i
cnt += (m - cnt)
else:
ans += c[i] * i
cnt += c[i]
if cnt == m:
break
print(ans) | from itertools import accumulate
from bisect import bisect_left
def main():
n,m=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
def count(k):
cnt=0
for a in A:
cnt+=bisect_left(A,k-a)
return cnt
ok=0
ng=2*10**5+1
while ng-ok>1:
mid=(ok+ng)//2
if count(mid)<n**2-m:
ok=mid
else:
ng=mid
border=ok
k=n**2-count(border)
Acc=[0]+list(accumulate(A))
s=Acc[-1]
ans=0
for a in A:
idx=bisect_left(A,border-a)
ans+=a*(n-idx)+(s-Acc[idx])
ans-=border*(k-m)
print(ans)
if __name__=='__main__':
main() | 1 | 108,359,518,421,102 | null | 252 | 252 |
N,P = map(int, input().split())
S = input()
"""
たとえばSが 123456789 だとすると
3456 = (3456789 - 789) // 1000
と表せる。
これがPで割り切れる場合、基本的には 3456789 と 789 がPで割り切れるとよい。
これはPと 10**x が互いに素の場合。
なので、10**x とPが互いに素の場合は、
・S[l:]をPで割った時余りがXXXになるものが何個、という情報を、Sの右端から集めていく。ただし、
・あるindexのlのS[l:]を見ているときに、その部分をPで割って余りがKになるなら、そのlに対してlより右にあるrについて、
S[r:]をPで割った余りがKになるようにrを選んでS[l:r]を作ると、Pで割り切れる数字が得られる。その時点でのmod P = Kの個数に対応する。
ただし、rに何も選ばない場合（lから端までを数字にする場合）もあるので、これも考慮に入れる。
Pが10と互いに素でない場合は、2と5がありうる。
これについて、それぞれ末尾が2の倍数か5の倍数であれば割り切れるので、
Sを左から見ていって、その数字が見つかれば、そのindexをふくむ左の位置で数字を作ればPで割れる数字ができる
"""
ans = 0
if P in [2, 5]:
for i in range(N):
if int(S[i]) % P == 0:
ans += i+1
else:
mod_P = [0] * P
mod_P[0] += 1
# Sを右端から何個かまで見てできる数字をPで割ってできる余り。
# 数字のまま持っておいて、都度mod P をとるとTLEになるので。
# 3543 で 3543 % P = (3000 + 543) % P のような感じで右から左にSを見ていく
curr = 0
for i in range(N):
curr = curr + int(S[N-1-i]) * pow(10, i, P)
curr %= P
ans += mod_P[curr]
mod_P[curr] += 1
print(ans) | import sys
input = sys.stdin.readline
N, K = map(int, input().split())
A = sorted(list(map(int, input().split())))
F = tuple(map(int, input().split()))
def can_eat(t):
F_time = sorted([t // f for f in F])
training = 0
for i in range(N):
training += max(0, A[i] - F_time[i])
return training <= K
# bisect
l, r = -1, 10 ** 12
while r - l > 1:
m = (r + l) // 2
if can_eat(m):
r = m
else:
l = m
print(r)
| 0 | null | 111,770,206,129,728 | 205 | 290 |
s=input()
sss=list(s)
sss.reverse()
if sss[0]=="s":
print(s+"es")
else:
print(s+"s") | n,x,y=map(int,input().split())
l=[]
for i in range(n-1):
for j in range(i+1,n):
d1=j-i
d2=abs((x-1)-i)+abs(j-(y-1))+1
d=min(d1,d2)
l.append(d)
import collections
c=collections.Counter(l)
for kk in range(1,n):
print(c[kk]) | 0 | null | 23,107,485,404,288 | 71 | 187 |
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))
x = int(input())
yokin = 100
for i in range(1, 100000000000):
yokin *= 101
yokin = yokin //100
if (yokin >= x):
print(i)
break
| def main():
x = int(input())
total = 100
for i in range(10**5):
if total >= x:
print(i)
return
total += total//100
if __name__ == "__main__":
main() | 1 | 27,102,142,776,924 | null | 159 | 159 |
n = int(input())
A = [int(x) for x in input().split()]
q = int(input())
M = [int(x) for x in input().split()]
ans = ["no"]*2000
for i in range(1<<n):
a = 0
for j in range(n):
if (i>>j)&1 == 1:
a += A[j]
ans[a] = "yes"
for j in M:
print(ans[j])
| N = int(input())
A = list(map(int, input().split()))
Q = int(input())
M = list(map(int, input().split()))
combinations = {}
def create_combinations(idx, sum):
combinations[sum] = 1
if idx >= N:
return
create_combinations(idx+1, sum)
create_combinations(idx+1, sum+A[idx])
return
create_combinations(0, 0)
for target in M:
if target in combinations.keys():
print("yes")
else:
print("no")
| 1 | 97,730,538,222 | null | 25 | 25 |
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(input())
res = 0
for i in range(1, (n + 1) // 2):
if i != n - i:
res += 1
print(res)
if __name__ == '__main__':
resolve()
| n = int(input())
if n < 2:
print(0)
elif (n % 2) == 0:
print(n //2 - 1)
else:
print(n // 2) | 1 | 153,439,342,562,686 | null | 283 | 283 |
import math
n = int(input())
xy = []
for i in range(n):
XY = list(map(int,input().split()))
xy.append(XY)
total = 0
for i in range(n - 1):
for j in range(i + 1,n):
total += math.sqrt((xy[i][0] - xy[j][0]) ** 2 + (xy[i][1] - xy[j][1]) ** 2)
print(total * 2 / n) | s = input()
flg = False
for i in range(1,6):
if s == 'hi' *i:
flg = True
break
print('Yes' if flg else 'No') | 0 | null | 100,814,297,279,540 | 280 | 199 |
n, d = map(int, input().split())
number = 0
for i in range(n):
x, y = map(int, input().split())
distance = x ** 2 + y ** 2
if distance <= d ** 2:
number += 1
print(number) | import math
n,d = map(int,input().split())
#l = list(map(int, input().split()))
x = [0] * n
y = [0] * n
for i in range(n):
x[i], y[i] = map(int, input().split())
#print(n,d,x,y)
count = 0
for i in range(n):
#print(math.sqrt(x[i]**2 + y[i]**2))
if math.sqrt(x[i]**2 + y[i]**2)<=d:
count += 1
print(count) | 1 | 5,921,772,849,198 | null | 96 | 96 |
n,k = map(int,input().split())
mod = 998244353
dp = [0]*(n+10)
dpsum = [0]*(n+10)
dp[1] = dpsum[1] = 1
L = [0]*k
R = [0]*k
for i in range(k):
l,r = map(int,input().split())
L[i],R[i] = l,r
for i in range(2,n+1):
for j in range(k):
li = i-R[j]
ri = i-L[j]
if ri < 0: continue
li = max(li,1)
dp[i] += dpsum[ri]-dpsum[li-1]
dp[i] %= mod
dpsum[i] = dpsum[i-1]+dp[i]
dpsum[i] %= mod
print(dp[n]) | def resolve():
mod=998244353
n,k=map(int,input().split())
d=[[],[]]
for _ in range(k):
l,r=map(int,input().split())
d[0].append(l)
d[1].append(r)
dp=[0]*(n+1)
a=[0]*(n+2)
a[1]=dp[1]=1
for i in range(2,n+1):
for j in range(k):
if i-d[0][j]>0:
dp[i]=(dp[i]+a[i-d[0][j]]-a[max(i-d[1][j]-1,0)]+mod)%mod
#print(dp[i])
a[i]=(a[i-1]+dp[i])%mod
print(dp[n])
resolve() | 1 | 2,741,181,432,008 | null | 74 | 74 |
# B - Bishop
H,W = map(int,input().split())
if H>1 and W>1:
print((H*W+1)//2)
else:
print(1) | import sys
import math
def I(): return int(sys.stdin.readline().rstrip())
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())
H,W= LI()
if H == 1 or W == 1:
print(1)
else:
ans = (H*W+1)/2
print(int(ans)) | 1 | 50,894,996,862,954 | null | 196 | 196 |
s = []
n = int(input())
for i in range(n):
s.append(input())
print("AC x " + str(s.count("AC")))
print("WA x " + str(s.count("WA")))
print("TLE x " + str(s.count("TLE")))
print("RE x " + str(s.count("RE"))) | from collections import defaultdict
n = int(input())
d = defaultdict(int)
for i in range(n):
d[input()] += 1
for v in ['AC', 'WA', 'TLE', 'RE']:
print(v, 'x', d[v]) | 1 | 8,737,521,916,760 | null | 109 | 109 |
from itertools import product as prod
N,M,X=map(int,input().split())
B=[list(map(int,input().split())) for _ in range(N)]
ans=float('INF')
for v in prod(range(2),repeat=N):
scores=[0]*M
cost=0
for i in range(N):
if v[i]==1:
cost+=B[i][0]
for j in range(M):
scores[j]+=B[i][1+j]
if min(scores)>=X:
ans=min(ans,cost)
print(ans if ans!=float('INF') else -1) | import sys
readline = sys.stdin.readline
S = readline().rstrip()
DIV = 2019
cur = 0
from collections import defaultdict
dic = defaultdict(int)
for i in range(len(S) - 1, -1, -1):
cur += ((int(S[i]) % DIV) * pow(10, (len(S) - 1 - i), DIV)) % DIV
cur %= DIV
dic[cur] += 1
ans = 0
# 0は単独でもよい
for key, val in dic.items():
if key == 0:
ans += val
ans += (val * (val - 1)) // 2
print(ans) | 0 | null | 26,567,626,683,260 | 149 | 166 |
import sys
sys.setrecursionlimit(10 ** 8)
ni = lambda: int(sys.stdin.readline())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
ns = lambda: sys.stdin.readline().rstrip()
MOD = 10 ** 9 + 7
N, K = nm()
def solve():
ans = 0
tbl = [0] * (K + 1)
for i in range(K, 0, -1):
m = K // i
p = pow(m, N, MOD)
j = 2
while j * i <= K:
p += MOD - tbl[j * i] % MOD
p %= MOD
j += 1
tbl[i] = p
ans += i * p % MOD
ans %= MOD
return ans
print(solve())
| n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [int(input()) for _ in range(m)]
for i in a:
c = 0
for j, k in zip(i, b):
c += j * k
print(c)
| 0 | null | 18,994,191,162,640 | 176 | 56 |
n = int(input())
a = list(map(int, input().split()))
def judge(x, y):
if x > y:
return(x-y)
else:
return(0)
ans = 0
for i in range(n - 1):
xy = judge(a[i], a[i+1])
a[i+1] += xy
ans += xy
print(ans) | n = int(input())
a = list(map(int, input().split()))
s = 0
for i in range(0, n - 1):
h = a[i] - a[i+1]
if h > 0:
s += h
a[i+1] += h
# a[i+1] = a[i]
print(str(s))
| 1 | 4,556,705,493,548 | null | 88 | 88 |
i = input()
i_l = i.split()
count = 0
for each in range(int(i_l[0]),int(i_l[1])+1):
if int(i_l[2]) % each == 0:
count += 1
else:
print(count) | n=int(input())
change=1000-n%1000
if change==1000:
print(0)
else:
print(change) | 0 | null | 4,524,948,784,440 | 44 | 108 |
N, K =map(int,input().split())
K = [tuple(map(int,input().split())) for i in range(K)]
M = 998244353
dp = [0] * N
dp[1] = 1
prefix = [1] * N
for i in range(1, N):
cur = 0
for L, R in K:
a = i - R
b = i - L
if b < 0:
continue
cur += prefix[b] - (prefix[a - 1] if a - 1 >= 0 else 0)
dp[i] = cur % M
prefix[i] = prefix[i - 1] + dp[i]
prefix[i] %= M
print(dp[N - 1]) | k=int(input())
a,b= map(int, input().split())
q=0
for i in range(1,1000):
if a<=k*i and k*i<=b:
print('OK')
q=1
break
if q==0:
print('NG') | 0 | null | 14,704,288,042,750 | 74 | 158 |
x, y = map(int, input().split())
print(x*y if x <= 9 and y <= 9 else -1)
| K = int(input())
mod = 7
number = 1
for i in range(K):
if mod % K == 0:
break
number += 1
mod = (mod * 10 + 7) % K
if mod % K == 0:
print(number)
else:
print(-1) | 0 | null | 82,043,553,174,532 | 286 | 97 |
str_in = input()
print(str_in.swapcase())
| #!/usr/bin python3
# -*- coding: utf-8 -*-
# 区間スケジューリング問題
# 区間の集合の中から、重ならないように最大で何個選べるかを問う問題である。
# 区間を「終端が早い順」にソートして、とれる順にとる Greedy で解くことができる。
# XL<-区間の集合
def main():
N = int(input())
XL = [None] * N
for n in range(N):
X, L = map(int,input().split())
XL[n] = (X-L,X+L)
XL.sort(key=lambda x:x[1])
ret = 0
TMP = XL[0][0]
for x in XL:
if TMP <= x[0]:
TMP = x[1]
ret += 1
print(ret)
if __name__ == '__main__':
main() | 0 | null | 45,897,795,095,190 | 61 | 237 |
print(input().replace(*'?D')) | def segfunc(x,y):
return set(x)|set(y)
ide_ele=set()
class SegTree():
def __init__(self,init_val,segfunc,ide_ele):
n=len(init_val)
self.segfunc=segfunc
self.ide_ele=ide_ele
self.num=1<<(n-1).bit_length()
self.tree=[ide_ele]*2*self.num
for i in range(n):
self.tree[self.num+i]=init_val[i]
for i in range(self.num-1,0,-1):
self.tree[i]=self.segfunc(self.tree[2*i], self.tree[2*i+1])
def update(self,k,x):
k+=self.num
self.tree[k]=x
while k>1:
self.tree[k>>1]=self.segfunc(self.tree[k],self.tree[k^1])
k>>=1
def query(self,l,r):
res=self.ide_ele
l+=self.num
r+=self.num
while l<r:
if l&1:
res=self.segfunc(res,self.tree[l])
l+=1
if r&1:
res=self.segfunc(res,self.tree[r-1])
l>>=1
r>>=1
return res
n=int(input())
s=input()
q=int(input())
st=SegTree(s,segfunc,ide_ele)
for _ in range(q):
q,c,r=input().split()
if q=='1':st.update(int(c)-1,r)
else:print(len(st.query(int(c)-1,int(r)))) | 0 | null | 40,285,171,665,580 | 140 | 210 |
from collections import deque
n = int(input())
q = deque()
for i in range(n):
c = input()
if c[0] == 'i':
q.appendleft(c[7:])
elif c[6] == ' ':
try:
q.remove(c[7:])
except:
pass
elif c[6] == 'F':
q.popleft()
else:
q.pop()
print(*q) | from collections import deque
n = int(input())
l = deque()
for _ in range(n):
command = input().split()
if command[0] == "insert":
l.appendleft(command[1])
elif command[0] == "delete":
try:
ind = l.remove(command[1])
except ValueError:
pass
elif command[0] == "deleteFirst":
l.popleft()
elif command[0] == "deleteLast":
l.pop()
print (" ".join(l)) | 1 | 51,923,041,884 | null | 20 | 20 |
import numpy as np
last=[0]*26
D=int(input())
c=list(map(int, (input().split(' '))))
s=[]
a=[0]*D
sat=0
for i in range(D):
s.append(list(map(int, (input().split(' ')))))
for i in range(D):
a[i]=int(input())
last[a[i]-1] = i+1
sat += s[i][a[i]-1] - np.dot(c, list(map(lambda x: i+1-x, last)))
print(sat) | A, B = list(map(int, input().split()))
x = 1
while True:
a = A * x
if a % B == 0:
print(a)
break
x += 1 | 0 | null | 61,971,502,730,420 | 114 | 256 |
def main():
N=10
l = list()
for i in range(N):
l.append(int(input()))
l.sort(reverse=True)
for x in l[:3]:
print(x)
if __name__=='__main__':
main() | n,m=input().split()
print(m+n) | 0 | null | 51,254,997,155,204 | 2 | 248 |
N = int(input())
X = str(input())
X10 = int(X,2)
one_num = X.count("1")
X10_pl = X10%(one_num+1)
if one_num>1:
X10_mi = X10%(one_num-1)
else:
X10_mi = 0
for i in range(N):
target = int(X[i])
if target == 0:
ones = one_num + 1
plus = pow(2,N-i-1,ones)
Xnow = (X10_pl + plus)%ones
else:
if one_num == 1:
print(0)
continue
ones = one_num-1
plus = -pow(2,N-i-1,ones)
Xnow = (X10_mi + plus)%ones
count=1
while Xnow > 0:
Xnow2 = bin(Xnow)
ones = Xnow2.count("1")
Xnow = Xnow%ones
count+=1
print(count)
| #!/usr/bin/env python
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**6)
INF = float("inf")
def popcount(n):
ret = 0
for i in range(18):
if n>>i & 1:
ret += 1
return ret
def main():
N = int(input())
X = input().decode().rstrip()
# X に含まれる "1" の数
x_cnt = X.count("1")
# i 桁目が 0 : x_cnt += 1
# i 桁目が 1 : x_cnt -= 1
# より, X mod x_cnt +1, X mod x_cnt-1 を事前計算しておく
x_mod_pl,x_mod_mi = 0,0
d_pl,d_mi = 1,1
mod_pl,mod_mi = x_cnt+1,max(1,x_cnt-1)
for i in range(N-1,-1,-1):
if X[i]=="1":
x_mod_pl = (x_mod_pl + d_pl) % mod_pl
x_mod_mi = (x_mod_mi + d_mi) % mod_mi
d_pl = (d_pl*2) % mod_pl
d_mi = (d_mi*2) % mod_mi
for i in range(N):
ans = 1
if X[i] == "1":
# 1 -> 0 に変換した結果, １が全く存在しない場合
if x_cnt == 1:
print(0)
continue
a = (x_mod_mi - pow(2,(N-1-i), mod_mi)) % mod_mi
else:
a = (x_mod_pl + pow(2,(N-1-i), mod_pl)) % mod_pl
while a > 0:
pop_cnt = popcount(a)
a %= pop_cnt
ans += 1
print(ans)
if __name__ == "__main__":
main() | 1 | 8,240,552,093,506 | null | 107 | 107 |
def show(nums):
for i in range(len(nums)):
if i != len(nums) - 1:
print(nums[i],end=' ')
else:
print(nums[i])
def bubbleSort(A,N):
flag = 1
count = 0
while flag:
flag = 0
for j in range(N-1,0,-1):
if A[j] < A[j-1]:
tmp = A[j]
A[j] = A[j-1]
A[j-1] = tmp
flag = 1
count += 1
show(A)
print(count)
N = int(input())
A = list(map(int,input().split()))
bubbleSort(A,N)
| n = int(input()) - 1
a = list(map(int, input().split()))
count = 0
flag = 1
while flag:
flag = 0
j = 0
for i in range( n, j, -1 ):
if a[i] < a[i-1]:
t = a[i]
a[i] = a[i-1]
a[i-1] = t
count += 1
flag = 1
j += 1
print(*a)
print(count) | 1 | 16,413,680,852 | null | 14 | 14 |
import sys
N=int(input())
if N==2:
print(1)
sys.exit(0)
answer_set=set()
for i in range(2,int(N**0.5)+1):
N2=N
while N2%i==0:
N2//=i
if N2%i==1:
answer_set.add(i)
#print(answer_set)
for i in range(1,int(N**0.5)+1):
if (N-1)%i==0:
answer_set.add((N-1)//i)
#print(answer_set)
answer_set.add(N)
print(len(answer_set)) | from decimal import Decimal
a, b = map(str, input().split())
a = int(a)
b = Decimal(b)
print(int(a * b)) | 0 | null | 28,955,410,069,938 | 183 | 135 |
m = input()
c = m[-1]
if c == 's':
print(m+'es')
else:
print(m+'s') | s = input()
if s[-1] == 's':
s = s + "es"
else:
s = s + 's'
print(s)
| 1 | 2,361,199,257,690 | null | 71 | 71 |
N = input()
USA = 0
n = 0
h = 0
k = 0
for i in range(0,len(N)):
n += int(N[i])
if n % 9 == 0:
print("Yes")
else:
print("No")
# h += 1
# n += h
# # if n == N+1:
# if n % 9 == 0:
| N = map(int,input().split())
if (sum(N) % 9 == 0 ):
print('Yes')
else:
print('No') | 1 | 4,399,432,786,980 | null | 87 | 87 |
x=str(input())
for i in range(len(x)):
if int(x[i]) == 7:
print('Yes')
exit()
print('No') | a = input()
if(a[0]=='7' or a[1]=='7' or a[2]=='7'):
print("Yes")
else:
print("No") | 1 | 34,275,192,655,008 | null | 172 | 172 |
import sys
sys.setrecursionlimit(1 << 25)
readline = sys.stdin.buffer.readline
read = sys.stdin.readline # 文字列読み込む時はこっち
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def a_int(): return int(readline())
def ints(): return list(map(int, readline().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, readline().split())))
return tuple(map(list, zip(*ret)))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, readline().split())))
return ret
def read_matrix(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(list(map(int, readline().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
class UnionFind:
def __init__(self, N):
self.N = N # ノード数
self.n_groups = N # グループ数
# 親ノードをしめす。負は自身が親ということ。
self.parent = [-1] * N # idxが各ノードに対応。
def root(self, A):
# print(A)
# ノード番号を受け取って一番上の親ノードの番号を帰す
if (self.parent[A] < 0):
return A
self.parent[A] = self.root(self.parent[A]) # 経由したノードすべての親を上書き
return self.parent[A]
def size(self, A):
# ノード番号を受け取って、そのノードが含まれている集合のサイズを返す。
return -self.parent[self.root(A)]
def unite(self, A, B):
# ノード番号を2つ受け取って、そのノード同士をつなげる処理を行う。
# 引数のノードを直接つなぐ代わりに、親同士を連結する処理にする。
A = self.root(A)
B = self.root(B)
# すでにくっついている場合
if (A == B):
return False
# 大きい方に小さい方をくっつけたほうが処理が軽いので大小比較
if (self.size(A) < self.size(B)):
A, B = B, A
# くっつける
self.parent[A] += self.parent[B] # sizeの更新
self.parent[B] = A # self.rootが呼び出されればBにくっついてるノードもすべて親がAだと上書きされる
self.n_groups -= 1
return True
def is_in_same(self, A, B):
return self.root(A) == self.root(B)
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
from math import gcd
def lcm(a, b):
# 最小公倍数
g = gcd(a, b)
return a // g * b
N, M = ints()
uf = UnionFind(N)
for _ in range(M):
a, b = mina(*ints())
uf.unite(a, b)
# あとはなるべく別々になるように
# →サイズを1ずつ引いて1グループ
# いやmaxのsizeか
print(-min(uf.parent))
| natural = list(map(int, input().split()))
natural.sort
x = natural[1]
y = natural[0]
while (y != 0):
x, y = y, x % y
print(x) | 0 | null | 2,006,304,937,380 | 84 | 11 |
N,P = map(int, input().split())
S = input()
"""
たとえばSが 123456789 だとすると
3456 = (3456789 - 789) // 1000
と表せる。
これがPで割り切れる場合、基本的には 3456789 と 789 がPで割り切れるとよい。
これはPと 10**x が互いに素の場合。
なので、10**x とPが互いに素の場合は、
・S[l:]をPで割った時余りがXXXになるものが何個、という情報を、Sの右端から集めていく。ただし、
・あるindexのlのS[l:]を見ているときに、その部分をPで割って余りがKになるなら、そのlに対してlより右にあるrについて、
S[r:]をPで割った余りがKになるようにrを選んでS[l:r]を作ると、Pで割り切れる数字が得られる。その時点でのmod P = Kの個数に対応する。
ただし、rに何も選ばない場合（lから端までを数字にする場合）もあるので、これも考慮に入れる。
Pが10と互いに素でない場合は、2と5がありうる。
これについて、それぞれ末尾が2の倍数か5の倍数であれば割り切れるので、
Sを左から見ていって、その数字が見つかれば、そのindexをふくむ左の位置で数字を作ればPで割れる数字ができる
"""
ans = 0
if P in [2, 5]:
for i in range(N):
if int(S[i]) % P == 0:
ans += i+1
else:
mod_P = [0] * P
mod_P[0] += 1
# Sを右端から何個かまで見てできる数字をPで割ってできる余り。
# 数字のまま持っておいて、都度mod P をとるとTLEになるので。
# 3543 で 3543 % P = (3000 + 543) % P のような感じで右から左にSを見ていく
curr = 0
for i in range(N):
curr = curr + int(S[N-1-i]) * pow(10, i, P)
curr %= P
ans += mod_P[curr]
mod_P[curr] += 1
print(ans) | import itertools
N = int(input())
L = list(map(int,(input().split())))
L.sort()
Combi = itertools.combinations(L, 3)
count = 0
for i, j, k in Combi:
if((i+j)> k and i!=j!=k and i<j <k ):
count+=1
print(count) | 0 | null | 31,531,152,022,396 | 205 | 91 |
import statistics
while True:
n = input()
if n == '0': break
print(statistics.pstdev(map(int, input().split()))) | n, k, s = map(int, input().split())
a = [s] * k + [1 if n < s else s + 1] * (n - k)
print(*a) | 0 | null | 45,633,709,578,662 | 31 | 238 |
N = int(input())
A = list(map(int, input().split()))
if 0 in A:
ans = 0
else:
ans = 1
max_limit = 10 ** 18
for i in range(N):
if ans * A[i] > max_limit:
ans = -1
break
else:
ans *= A[i]
print(str(ans)) |
IN = list(map(int, input().split()))
N, K = IN[0], IN[1]
P = [None] + list(map(int, input().split()))
C = [None] + list(map(int, input().split()))
MAX_N = 45000
#N = 1000
#K = 10**7
#P = [None] + [random.choice(list(itertools.chain(range(1,i), range(i+1,N)))) for i in range(1, N+1)]
#C = [None] + random.choices(range(-10**9, 10**9), k=N)
verbose = False
def cumsum(a):
tmp = [0]*(len(a)+1)
for i in range(1, len(a)+1): tmp[i] = a[i-1] + tmp[i-1]
return tmp[1:]
def find_cycle(p, pos):
cnt = 0
steps = [0] * (MAX_N+1)
path = [False] * (MAX_N+1)
while True:
steps[cnt] = pos
path[pos] = True
cnt += 1
pos = p[pos]
if path[pos]: break # found closure
st = steps.index(pos) # start of closure
return [steps[:st], steps[st:cnt]]
def score(steps, c):
ret = [0]*len(steps)
for i in range(len(steps)): ret[i] = c[steps[i]]
return ret
maxsc = -10**9-1
done = [False] * (N+1)
for i in range(1, N+1):
if verbose: print('entering', i)
if done[i]: continue
[preclosure_path, closure_path] = find_cycle(P, i)
if verbose: print('closure found:', closure_path)
closure_scores = score(closure_path, C)
preclosure_scores = score(preclosure_path, C)
closure_score = sum(closure_scores)
preclosure_len, closure_len = len(preclosure_path), len(closure_path)
cycles = (K-preclosure_len)//closure_len
resid = (K-preclosure_len)%closure_len
if cycles>=1: cycles -= 1
abbrev = closure_score * cycles
trail = preclosure_scores + closure_scores * 3
path = preclosure_path + closure_path*3
if verbose: print('score trail:', trail)
if verbose: print('path:', preclosure_path + closure_path*3)
if verbose: print('mark:', mark)
mark = min(K, len(preclosure_path+closure_path)+resid)
localmax = max(cumsum(trail[0:mark])) + max(0, closure_score*cycles)
if verbose: print('localmax:', localmax, 'cycles:', cycles)
maxsc = max(localmax, maxsc)
if verbose: print('going greedy')
for j in range(1, closure_len):
if K<=mark+j: break
target = path[j]
if done[target]: continue
localmax = max(cumsum(trail[j:mark+j])) + max(0, closure_score*cycles)
maxsc = max(localmax, maxsc)
done[target] = True
if verbose: print('done:', target, 'with', localmax)
print(maxsc)
| 0 | null | 10,753,314,933,522 | 134 | 93 |
def main():
a, b = (int(i) for i in input().split())
print(str(a * b))
if __name__ == '__main__':
main()
| n = int(input())
s = input()
res = 'Yes' if s[0:n//2] == s[n//2:] else 'No'
print(res) | 0 | null | 81,039,116,481,800 | 133 | 279 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
import numpy as np
def main():
n, *a = map(int, read().split())
p = np.array(a)
minp = np.minimum.accumulate(p)
r = np.count_nonzero(minp >= p)
print(r)
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
import bisect
import collections
from collections import deque
n,d,a= map(int, input().split())
x= [list(map(int, input().split())) for i in range(n)]
x.sort()
y=[]
for i in range(n):
y.append(x[i][0])
x[i][1]=-(-x[i][1]//a)
# どのモンスターまで倒したか管理しながら進める。
# 累積ダメージを管理
qq=deque([])
ans=0
atk=0
for i in range(n):
w=x[i][1]
# iがダメージの有効期限を超過している場合
while len(qq)>0 and i > qq[0][0]:
atk-=qq[0][1]
qq.popleft()
if w-atk>0:
ans+=w-atk
q=bisect.bisect_right(y,x[i][0]+2*d)-1
# 有効期限 ダメージ
qq.append([q,w-atk])
atk += w - atk
print(ans) | 0 | null | 83,975,599,105,230 | 233 | 230 |
N, M = map(int, input().split())
A = list(map(int, input().split()))
total_days = sum(A)
if total_days <= N:
print(N - total_days)
else:
print(-1)
| a = [[[0 for i in range(10)] for j in range(3)] for k in range(4)]
n = int(input())
for i in range(1, n + 1):
b, f, r, v = map(int, input().split())
a[b-1][f-1][r-1] += v
for i in range(4):
for j in range(3):
for k in range(10):
print("", a[i][j][k], end="")
if k == 9:
print()
if j == 2 and i != 3:
print("####################") | 0 | null | 16,408,674,648,800 | 168 | 55 |
print(''.join(map(str, ["ACL" for _ in range(int(input()))]))) | a,b = map(int, raw_input().split())
print '%d %d %.5f'%(a/b, a%b, (1.0)*a/b) | 0 | null | 1,404,071,065,088 | 69 | 45 |
from decimal import Decimal
a,b,c=map(Decimal,input().split())
print('Yes' if a.sqrt()+b.sqrt()<c.sqrt() else 'No') | import math
a,b,c=(int(x) for x in input().split())
x=c-a-b
if x>0:
if x*x-4*a*b>0:
print('Yes')
else:
print('No')
else:
print('No')
| 1 | 51,525,112,533,340 | null | 197 | 197 |
ls = list(map(int,input().split()))
print(str(min(ls))*max(ls)) | a, b = map(int, input().split())
if a > b: a, b = b, a
while True:
if b % a == 0:
print(a)
break
else:
b = b % a
if a > b: a, b = b, a | 0 | null | 42,297,195,414,732 | 232 | 11 |
from sys import stdin
n = int(input())
dict = {}
for i in range(n):
line = stdin.readline()
if line[0:6] == 'insert':
dict[line[7:]] = 1
else:
if line[5:] in dict:
print('yes')
else:
print('no')
| dic = set()
n = int(input())
for i in range(n):
cmd, val = input().split()
if cmd == "insert":
dic.add(val)
elif cmd == "find":
print("yes" if val in dic else "no")
else:
print("wrong command")
| 1 | 79,446,215,848 | null | 23 | 23 |
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() | N=int(input())
a=list(map(int, input().split()))
total=0
for i in range(1,N):
add=abs(a[i]-a[i-1])
total=total+add if a[i]<a[i-1] else total
a[i]=a[i]+add if a[i]<a[i-1] else a[i]
print (total) | 1 | 4,575,428,520,752 | null | 88 | 88 |
from math import *
from collections import *
N, D, A = list(map(int, input().split()))
ans = 0
t = 0
q = deque()
XH = sorted([list(map(int, input().split())) for i in range(N)])
for x, h in XH:
if q:
while q and q[0][0] < (x-D):
_, c = q.popleft()
t -= c
h = h - t * A
if h <= 0: continue
x += D
c = ceil(h/A)
t += c
ans += c
q.append((x, c))
print(ans) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf
# @pysnooper.snoop()
#import pysnooper # debug
import math
#from sortedcontainers import SortedList, SortedDict, SortedSet # no in atcoder
import bisect
class Solver:
def __init__(self, n, a_s):
self.n = n
self.a_s = a_s
self.extra = 1 if self.n % 2 == 0 else 2
self.dp = self.prepare_dp()
def prepare_dp(self):
dp = [None] * (self.n + 1)
for i, _ in enumerate(dp):
dp[i] = [-1 * math.inf] * (1 + self.extra)
dp[0][0] = 0
return dp
def run(self):
extra = 1 + self.n % 2
for i, a in enumerate(self.a_s):
for j in range(self.extra):
self.dp[i + 1][j + 1] = self.dp[i][j]
for j in range(self.extra + 1):
v = self.dp[i][j]
if (i + j) % 2 == 0:
v += a
self.dp[i + 1][j] = max(self.dp[i + 1][j], v)
#print('self.dp') # debug
#print(self.dp) # debug
return self.dp[n][extra]
if __name__ == '__main__':
n = int(input())
a_s = list(map(int, input().split()))
ans = Solver(n, a_s).run()
#print('ans') # debug
print(ans)
#print('\33[32m' + 'end' + '\033[0m') # debug
| 0 | null | 59,622,654,030,240 | 230 | 177 |
n,k = map(int, input().split())
ans = 0
for i in range(k, n + 2):
min = i*(0+i-1)/2
max = i*((n-i)+(n+1))/2
ans += max - min +1
print(int(ans % (10**9 + 7))) | t = int(input())
for i in range(8):
if (400+200*i) <= t <= (599 + 200*i):
print(8-i)
| 0 | null | 19,929,103,605,268 | 170 | 100 |
import sys
readline = sys.stdin.readline
N = int(readline())
S = [readline().rstrip() for _ in range(N)]
def count_cb_ob(s):
st = []
for i, si in enumerate(s):
if si == '(' or len(st) == 0 or st[-1] != '(':
st.append(si)
else:
st.pop()
return st.count(')'), st.count('(')
cb_obs = map(count_cb_ob, S)
f, b, s = [], [], []
for down, up in cb_obs:
(f if down < up else (s if down == up else b)).append((down, up))
f = sorted(f)
b = sorted(b, key=lambda x:x[1], reverse=True)
count = 0
ans = 'Yes'
for down, up in (*f, *s, *b):
count -= down
if count < 0:
ans = 'No'
count += up
if count != 0:
ans = 'No'
print(ans) | N = int(input())
As = list(map(int,input().split()))
Q = int(input())
count_array = [0]*(10**5+1)
for i in range(N):
count_array[As[i]] += 1
sum = 0
for i in range(len(As)):
sum += As[i]
for i in range(Q):
x,y = map(int,input().split())
sum += count_array[x]*(y-x)
print(sum)
count_array[y] += count_array[x]
count_array[x] = 0
| 0 | null | 17,898,083,038,742 | 152 | 122 |
def main():
d, t, s = map(int, input().split())
print("Yes" if d / s <= t else "No")
if __name__ == "__main__":
main() | D,T,S = map(int,input().split())
if D <= T*S:
print("Yes")
else:print("No") | 1 | 3,522,545,834,082 | null | 81 | 81 |
time = int(input())
if time != 0:
h = time // 3600
time = time % 3600
m = time // 60
s = time % 60
print(str(h) + ':' + str(m) + ':' + str(s))
else:
print('0:0:0') | S = input()
T = input()
ans = len(S)
for i in range(len(S)-len(T)+1):
tmp = 0
for j in range(len(T)):
if S[i+j] != T[j]:
tmp += 1
ans = min(ans, tmp)
print(ans) | 0 | null | 2,024,503,002,688 | 37 | 82 |
k = int(input())
score = list(map(int,input().split()))
answer = k - (score[0] % k)
if score[0]%k == 0:
print('OK')
elif answer + score[0] <= score[1]:
print('OK')
else:
print('NG') | def main():
base_distance = int(input().rstrip())
min_distance, max_distance = (int(i) for i in input().rstrip().split(' '))
if (max_distance // base_distance) * base_distance >= min_distance:
print('OK')
else:
print('NG')
if __name__ == '__main__':
main()
| 1 | 26,671,470,831,392 | null | 158 | 158 |
#!/usr/bin/env python3
import sys, math
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans=count=0
n,m=map(int,input().split())
A=list(map(int,input().split()))
dp=[inf]*(n+1)
dp[0]=0
for a in A:
for i in range(a,n+1):
dp[i]=min(dp[i],dp[i-a]+1)
print(dp[n])
| n, m = [int(el) for el in input().split(' ')]
c = [int(el) for el in input().split(' ')]
t = [0] + [float('inf') for _ in range(n)]
for i in range(m):
for j in range(c[i], n+1):
t[j] = min(t[j], t[j-c[i]] + 1)
print(t[n]) | 1 | 141,608,227,530 | null | 28 | 28 |
#!/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() | from itertools import combinations as comb
N = int(input())
L = list(map(int,input().split()))
count = 0
for a, b, c in comb(L, 3):
if a != b and b != c and c != a and a + b > c and b + c > a and c + a > b:
count += 1
print(count) | 0 | null | 2,570,487,709,738 | 15 | 91 |
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
class UnionFind(object):
def __init__(self, n=1):
# 木の親要素を管理するリストparをつくります。
# par[x] == xの場合には、そのノードが根であることを示します。
# 初期状態では一切グループ化されていないので、すべてのノードが根になりますね。
self.par = [i for i in range(n)]
# 木の高さを持っておき、あとで低い方を高い方につなげる。初期状態は0
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
"""
x が属するグループを探索：
ある２つの要素が属する木の根が同じかどうかをチェックすればよい。
つまり、親の親の親の・・・と根にたどり着くまで走査すればよい。
再帰。
"""
# 根ならその番号を返す
if self.par[x] == x:
return x
# 根でないなら、親の要素で再検索
else:
# 一度見た値については根に直接繋いで経路圧縮
# 親を書き換えるということ
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
"""
x と y のグループを結合
"""
# 根を探す
x = self.find(x)
y = self.find(y)
# 小さい木に結合して経路圧縮
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
# 同じ長さの場合rankが1増える
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 低い方の木の根を高い方の根とする
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
"""
x と y が同じグループか否か
"""
return self.find(x) == self.find(y)
def get_size(self, x):
"""
x が属するグループの要素数
"""
x = self.find(x)
return self.size[x]
N,M,K=map(int,input().split())
uf = UnionFind(N) # ノード数Nでクラス継承
friends_cnt=[0]*N
for i in range(M):
# A,Bはノード
A, B = map(int, input().split())
A-=1
B-=1
friends_cnt[A]+=1
friends_cnt[B]+=1
# 連結クエリ union
uf.union(A, B)
blocks=[[] * N for i in range(N)]
for i in range(K):
x, y = map(int, input().split())
x, y = x - 1, y - 1
blocks[x].append(y)
blocks[y].append(x) # 有向ならコメントアウト
for i in range(N):
ans=uf.get_size(i)-friends_cnt[i]-1
for j in blocks[i]:
if uf.is_same(i,j):
ans-=1
print(ans,end=' ')
print()
resolve() |
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
N = read_int()
A = read_ints()
if len(A) == len(set(A)):
return 'YES'
return 'NO'
if __name__ == '__main__':
print(solve())
| 0 | null | 67,917,183,103,210 | 209 | 222 |
import sys
H = int(sys.stdin.readline())
W = int(sys.stdin.readline())
N = int(sys.stdin.readline())
print((N - 1) // max(H, W) + 1) | A, B, C, K = map(int, input().split())
if K<=A:
print(1*K)
elif A<K<=A+B:
print(1*A)
else:
print(1*A-1*(K-A-B)) | 0 | null | 55,654,837,172,868 | 236 | 148 |
import sys
from collections import defaultdict
# https://ikatakos.com/pot/programming_algorithm/data_structure/union_find_tree
class UnionFind:
def __init__(self, n):
# 負 : 根であることを示す。絶対値はランクを示す
# 非負: 根でないことを示す。値は親を示す
self.table = [-1] * n
def _root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self._root(x) == self._root(y)
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
# ランクの取得
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
def friend_candidate(self):
tbl = self.table
n = len(tbl)
candidates = [0] * n
root = [-1] * n
for i, parent in enumerate(tbl):
if parent >= 0:
root[i] = self._root(parent)
candidates[root[i]] += 1
for i in range(n):
if tbl[i] >= 0:
candidates[i] = candidates[root[i]]
return candidates
def main():
input = sys.stdin.buffer.readline
n, m, k = map(int, input().split())
uf = UnionFind(n)
num_friends = [0] * n
for _ in range(m):
a, b = map(lambda x: int(x) - 1, input().split())
uf.union(a, b)
num_friends[a] += 1
num_friends[b] += 1
num_block = [0] * n
for _ in range(k):
c, d = map(lambda x: int(x) - 1, input().split())
if uf.find(c, d):
num_block[c] += 1
num_block[d] += 1
fc = uf.friend_candidate()
ans = [0] * n
for i in range(n):
ans[i] = fc[i] - num_friends[i] - num_block[i]
print(*ans)
if __name__ == "__main__":
main()
| import math
def main():
mod = 1000000007
N = int(input())
A = list(map(int, input().split()))
A_max = sorted(A)[-1]
if A_max == 0:
print(0)
exit()
bit_max = int(math.ceil(math.log2(A_max)))
i = 0
bit = 1
res = 0
while i <= bit_max:
c_zero = 0
c_one = 0
for j in range(N):
if A[j] & bit == 0:
c_zero += 1
else:
c_one += 1
m_bit = bit % mod
res += m_bit*c_zero*c_one
res %= mod
i += 1
bit<<=1
print(res)
if __name__ == "__main__":
main() | 0 | null | 92,487,871,446,558 | 209 | 263 |
def print_puddle(puddle):
n = len(puddle)
if n > 0:
print(n, end=' ')
else:
print(n)
for i in range(n):
if i != n - 1:
print(puddle[i][1], end=' ')
else:
print(puddle[i][1])
def solve(A):
left = []
puddle = []
sum_all = 0
for i, a in enumerate(A):
if a == '\\':
left.append(i)
elif a == '/' and len(left) > 0:
left_i = left.pop()
a = i - left_i
sum_paddle = i - left_i
sum_all += a
while len(puddle) and puddle[-1][0] > left_i:
tmp = puddle.pop()
sum_paddle += tmp[1]
puddle.append((left_i, sum_paddle))
print(sum_all)
print_puddle(puddle)
def main():
A = list(input())
solve(A)
if __name__ == "__main__":
main()
| import collections
import sys
S1 = collections.deque()
S2 = collections.deque()
S3 = collections.deque()
for i, j in enumerate(sys.stdin.readline()):
if j == '\\':
S1.append(i)
elif j == '/':
if S1:
left_edge = S1.pop()
new_puddle = i - left_edge
while True:
if S2:
if S2[-1] > left_edge:
S2.pop()
new_puddle += S3.pop()
else:
break
else:
break
S2.append(left_edge)
S3.append(new_puddle)
else:
pass
print(sum(S3))
print(len(S3), *S3) | 1 | 58,004,552,626 | null | 21 | 21 |
n,m = map(int,input().split())
prb = [[0] for _ in range(n+1)]
for _ in range(m):
sub = input().split()
p, s = int(sub[0]), sub[1]
lst = prb[p]
if lst[-1] == 1:
pass
elif s == "WA":
lst.append(0)
elif s == "AC":
lst.append(1)
prb[p] = lst
ac_prb = [lst for lst in prb if lst[-1] == 1]
ac_num = len(ac_prb)
pe_num = -2*ac_num
for prb in ac_prb:
pe_num += len(prb)
print(ac_num, pe_num) | X,N = map(int,input().split())
p = list(map(int,input().split()))
for i in range(X+1):
for j in [-1,1]:
a = X + i*j
if p.count(a) == 0:
print(a)
exit(0) | 0 | null | 53,804,886,784,012 | 240 | 128 |
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])
| def main():
A, B, C = (int(x) for x in input().split())
K = int(input())
while not A < B < C and K > 0:
if A >= B: B *= 2
else: C *= 2
K -= 1
# print(A, B, C, K)
if A < B < C: print('Yes')
else: print('No')
if __name__ == '__main__':
main() | 0 | null | 72,727,755,680,320 | 274 | 101 |
#C
def gcd(a, b):
while b:
a, b = b, a % b
return a
K = int(input())
ans = 0
for a in range(1,K+1):
for b in range(a,K+1):
for c in range(b,K+1):
if a != b and b != c and a != c:
ans += 6*gcd(gcd(a,b),c)
elif a == b or b == c or a == c:
if a == b and b == c:
ans += gcd(gcd(a,b),c)
else:
ans += 3*gcd(gcd(a,b),c)
print(ans) | import math
def main():
K = int(input())
s = 0
for i in range(K):
for j in range(K):
tmp = math.gcd(i+1, j+1)
for k in range(K):
s += math.gcd(tmp, k+1)
print(s)
if __name__=="__main__":
main()
| 1 | 35,459,533,104,358 | null | 174 | 174 |
from collections import deque
from sys import stdin
input = stdin.readline
N = int(input())
neighborlist = [None for _ in range(N+1)]
for _ in range(1, N+1):
node, _, *L = list(map(int, input().split()))
neighborlist[node] = L
distancelist = [-1]*(N+1)
queue = deque()
queue.append(1)
distancelist[1] = 0
while queue:
node = queue.popleft()
distance = distancelist[node]
for neighbor in neighborlist[node]:
if distancelist[neighbor] == -1:
distancelist[neighbor] = distance + 1
queue.append(neighbor)
for i in range(1, N+1):
print(i, distancelist[i])
| from collections import deque
n = int(input())
u = [[] for i in range(n+1)] #隣接リスト
for i in range(n):
v = list(map(int, input().split()))
u[v[0]] = v[1:] #v = [次数, 頂点...]
d = [-1] * (n+1)
visited = [False] * (n+1)
d[1] = 0
visited[1] = True
que = deque([1])
while len(que) > 0:
c = que.popleft()
for i in range(1, u[c][0]+1):
if not visited[u[c][i]]:
que.append(u[c][i])
visited[u[c][i]] = True
d[u[c][i]] = d[c] + 1
for i in range(1, n+1):
print(i, d[i])
| 1 | 3,691,029,100 | null | 9 | 9 |
k=int(input())
ans=0
import itertools
import math
for seq in itertools.combinations_with_replacement(range(1,k+1),3):
if seq[0]==seq[1] or seq[1]==seq[2]:
if seq[0]!=seq[2]:
ans+=(math.gcd(seq[0],math.gcd(seq[1],seq[2])))*3
else:
ans+=math.gcd(seq[0],math.gcd(seq[1],seq[2]))
else:
ans+=math.gcd(seq[0],math.gcd(seq[1],seq[2]))*6
print(ans) | import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
k = int(input())
def gcd(a, b):
while b: a, b = b, a % b
return a
ans = 0
for i in range(1, k + 1):
for j in range(1, k + 1):
for m in range(1 , k + 1):
ans += gcd(gcd(i, j), m)
print(ans)
| 1 | 35,516,428,427,220 | null | 174 | 174 |
A=["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]
n=int(input())
s=str(input())
t=""
for i in range(len(s)):
for j in range(26):
if s[i]==A[j]:
if j+n<=25:
t+=A[j+n]
break
else:
t+=A[j+n-26]
break
print(t) | N = int(input())
S = input()
ans = ""
for i in range(len(S)):
ord_c = ord(S[i])
# print(chr((ord_c + N - 65) % 26 + 65))
ans += chr((ord_c + N - 65) % 26 + 65)
print(ans)
| 1 | 134,119,193,743,470 | null | 271 | 271 |
a=int(input(""))
if a>=30:
print("Yes")
elif a<30:
print("No") | H,W,M=map(int,input().split())
#二次元リストではなく列行を一個のボムで消してくれるためそれぞれのリストを用意。
sumh = [0] * H
sumw = [0] * W
bomb=[]
for i in range(M):
h,w=map(int,input().split())
sumh[h-1]+=1
sumw[w-1]+=1
bomb.append((h,w))
#爆弾の個数の最大値とその最大値がいくつずつあるか(ch,cw)に保存。最大の列と最大の行のいずれかの組み合わせに置くことで爆破数を最大化できる。
maxh=max(sumh)
maxw=max(sumw)
ch=sumh.count(maxh)
cw=sumw.count(maxw)
#print(maxh,maxw,ch,cw)
#爆弾のある場所がH,Wの座標で両方共で最大個数の場所であった場合その数を加算
count=0
for h,w in bomb:
if sumh[h-1]==maxh and sumw[w-1]==maxw:
count+=1
#print(count)
#破壊できる数は、そのマスに爆破対象があるとき一つ減ってしまう。
if count==ch*cw:
print(maxh+maxw-1)
else:
print(maxh+maxw) | 0 | null | 5,220,732,959,558 | 95 | 89 |
# -*- coding: utf-8 -*-
import math
num = int(raw_input())
for i in range(num):
list = [int(x) for x in raw_input().split(" ")]
list.sort(lambda n1, n2:n2 - n1)
if list[0]**2 == list[1]**2 + list[2]**2:
print("YES")
else:
print("NO") | import string
import sys
import math
#??????????????\????????????ip?????\??????
ip = sys.stdin.readlines()
ip_list = {}
#?????????????????§?????????
for i in range(len(ip)):
ip_list[i] = ip[i].strip("\n").split()
for i in range(1,len(ip)):
for j in range(3):
#?????????????????????
for t in range(3):
for k in range(3):
if int(ip_list[i][t]) > int(ip_list[i][k]):
tmp = ip_list[i][t]
ip_list[i][t] = ip_list[i][k]
ip_list[i][k] = tmp
for i in range(1,len(ip)):
if int(ip_list[i][0])**2 == int(ip_list[i][1])**2 + int(ip_list[i][2])**2:
print("YES")
else:
print("NO") | 1 | 339,637,220 | null | 4 | 4 |
N,X,T = map(int,input().split())
a = N % X
if a == 0:
ans = (N//X)*T
else:
ans = ((N//X)+1)*T
print(ans) | def main():
N=int(input())
A=list(map(int,input().split()))
mod=10**9+7
ans=0
for i in range(60):
c=0
for j in A:
if j>>i&1:
c+=1
ans+=pow(2,i,mod)*c*(N-c)
ans%=mod
print(ans)
if __name__=='__main__':
main() | 0 | null | 63,911,214,485,030 | 86 | 263 |
str_in = input()
print(str_in.swapcase())
| # coding: UTF-8
moji = str(raw_input())
print moji.swapcase()
| 1 | 1,516,672,991,900 | null | 61 | 61 |
H = int(input())
num = 1
ans = 0
while H > 0:
H //= 2
ans += num
num *= 2
print(ans) | n,m = map(int,input().split(" "))
c = tuple(map(int,input().split(" ")))
m = min(c)
dp = [2**60 for _ in range(n+1)]
dp[0] = 0
for i in range(1,n+1):
for v in c:
if i >= v:
dp[i] = min(dp[i],dp[i-v]+1)
print(dp[n])
| 0 | null | 40,000,774,693,302 | 228 | 28 |
A = input()
B = input()
candidate = set(('1', '2', '3'))
exclude = set((A, B))
print((candidate - exclude).pop()) | l=[]
for i in range(2): l.append(int(input()))
for i in range(1, 4):
if i not in l: print(i) | 1 | 110,334,399,068,128 | null | 254 | 254 |
x = int(input())
money = 100
cnt = 0
while x > money:
money += money//100
cnt += 1
print(cnt)
| n,k = map(int,input().split())
P = list(map(int,input().split()))
s=0
for i in range(k):
s += P[i]
ms=s
for i in range(len(P)-k):
s +=(P[i+k]-P[i])
if s>ms :
ms=s
print( (ms+k)/2)
| 0 | null | 50,769,664,044,606 | 159 | 223 |
def resolve():
S = input()
print(S[:3])
resolve()
| x, y, z = [int(i) for i in input().split(" ")]
print(z, x, y) | 0 | null | 26,359,065,042,118 | 130 | 178 |
cnt = 1
def dep(G,s_cnt,f_cnt,np):
global cnt
s_cnt[np] = cnt
cnt += 1
for i in range(n):
if G[np][i] == 1 and s_cnt[i] == 0:
dep(G,s_cnt,f_cnt,i)
f_cnt[np] = cnt
cnt += 1
n = int(input())
G = [[0 for i in range(n)] for j in range(n)]
s_cnt = [0 for i in range(n)]
f_cnt = [0 for i in range(n)]
for i in range(n):
S = list(map(int, input().split()))
tmp_n = S[1]
for j in range(tmp_n):
G[i][S[j+2]-1] = 1
for i in range(n):
if s_cnt[i]==0:
dep(G,s_cnt,f_cnt,i)
for i in range(n):
print(i+1,s_cnt[i],f_cnt[i])
| def dfs(index):
global count
d[index] = count
count += 1
for i in field[index]:
if d[i]:
continue
count = dfs(i)
f[index] = count
return count + 1
n = int(input())
field = [[0,0]]
for _ in range(n):
u, k, *v = map(int, input().split())
field.append(v)
d = [0 for _ in range(n + 1)]
f = [0 for _ in range(n + 1)]
count = 1
for i in range(1, n + 1):
if d[i]:
continue
count = dfs(i)
for i in range(1, n + 1):
print(i, d[i], f[i])
| 1 | 3,090,472,568 | null | 8 | 8 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.