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
|
|---|---|---|---|---|---|---|
import numpy as np
from numba import njit
@njit
def get_div_nums(n):
divs = np.ones(n+1, dtype=np.int64)
for i in range(2, n):
divs[i::i] += 1
return divs
def main():
N = int(input())
divs = get_div_nums(N)
ans = divs[:N].sum()-1
print(ans)
#print(divs[:20])
if __name__ == "__main__":
main() | a,b=map(int,input().split())
print("-1" if a>9 or b>9 else a*b) | 0 | null | 80,257,349,931,940 | 73 | 286 |
n,m,k = map(int,input().split())
A = [[] for i in range(n+1)]
for i in range(m):
a,b = map(int,input().split())
A[a].append(b)
A[b].append(a)
C = [[] for i in range(n+1)]
for i in range(k):
c,d = map(int,input().split())
C[c].append(d)
C[d].append(c)
from collections import deque
reach = [0]*(n+1)
for i in range(1,n+1):
if reach[i] != 0:
pass
else:
reach[i] = i
q = deque([])
q.append(i)
while q:
x = q.popleft()
for s in A[x]:
if reach[s] == 0:
q.append(s)
reach[s] = i
dis_count = [0]*(n+1)
for i,C0 in enumerate(C):
for CC in C0:
if reach[CC] == reach[i]:
dis_count[i] += 1
import collections
D = collections.Counter(reach)
for i in range(1,n+1):
print(D[reach[i]]-len(A[i])-dis_count[i]-1,end="")
print(" ",end="")
print("") | N, K = map(int, input().split())
cnts = [0] * N
for _ in range(K):
di = int(input())
A = list(map(int, input().split()))
for i in range(di):
cnts[A[i]-1] += 1
ans = cnts.count(0)
print(ans) | 0 | null | 42,948,208,688,412 | 209 | 154 |
INF = 10**18
def solve(n, a):
# 現在の位置 x 選んだ個数 x 直前を選んだかどうか
dp = [{j: [-INF, -INF] for j in range(i//2-1, (i+1)//2 + 1)} for i in range(n+1)]
dp[0][0][False] = 0
for i in range(n):
for j in dp[i].keys():
if (j+1) in dp[i+1]:
dp[i+1][j+1][True] = max(dp[i+1][j+1][True], dp[i][j][False] + a[i])
if j in dp[i+1]:
dp[i+1][j][False] = max(dp[i+1][j][False], dp[i][j][False])
dp[i+1][j][False] = max(dp[i+1][j][False], dp[i][j][True])
return max(dp[n][n//2])
n = int(input())
a = list(map(int, input().split()))
print(solve(n, a)) | N, R = map(int, input().split())
if N >= 10: print(R)
else: print(R + 100*(10-N)) | 0 | null | 50,405,286,981,920 | 177 | 211 |
import math
import sys
from collections import deque
import heapq
import copy
import itertools
from itertools import permutations
def mi() : return map(int,sys.stdin.readline().split())
def ii() : return int(sys.stdin.readline().rstrip())
def i() : return sys.stdin.readline().rstrip()
a,b=mi()
print(max(a-b-b,0)) | import itertools
def main():
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
l = [i for i in range(1, N+1)]
p = list(itertools.permutations(l, N))
print(abs(p.index(P) - p.index(Q)))
if __name__ == '__main__':
main() | 0 | null | 133,453,257,467,104 | 291 | 246 |
n = int(input())
l = list(map(int, input().split()))
sum = 0
for i in range(n):
sum += l[i]
print(min(l), max(l), sum)
| n=input()
k=map(int,raw_input().split())
print min(k),max(k),sum(k) | 1 | 727,080,607,540 | null | 48 | 48 |
def count(s1,s2):
cnt = 0
for i in range(len(s2)):
if s1[i] != s2[i]:
cnt += 1
return cnt
S1 = input()
S2 = input()
mmin = len(S2)
for i in range(len(S1)-len(S2)+1):
k = count(S1[i:len(S2)+i],S2)
if k < mmin:
mmin = k
print(mmin)
| s = input()
l = len(s)
ans = 'x' * l
print(ans) | 0 | null | 38,301,424,688,420 | 82 | 221 |
op = "$"
while op != "?":
a, op, c = map(str, raw_input().split())
a = int(a)
c = int(c)
if op == "+":
print u"%d" % (a+c)
elif op == "-":
print u"%d" % (a-c)
elif op == "*":
print u"%d" % (a*c)
elif op == "/":
print u"%d" % (a/c)
else:
break | from scipy.sparse import*
_,*s=open(0)
*g,=eval('[0]*500,'*500)
i=-1
for t in s:
i+=1;j=0
for u in t:k=i*20+j;g[k][k+1]=u>'#'<t[j+1];g[k][k+20]=u>'#'<(s+['#'*20])[i+1][j];j+=1
a=csgraph.johnson(csr_matrix(g),0)
print(int(max(a[a<999]))) | 0 | null | 47,676,481,095,232 | 47 | 241 |
X = int(input())
for k in range(3, 361):
if (k*X)%360==0:
print(k)
exit() | a = int(input())
n = 1
while True:
if a*n % 360 == 0:
break
else:
n += 1
print(n) | 1 | 13,096,366,900,214 | null | 125 | 125 |
S = input()
T = input()
def count_diff(s, t):
N = 0
for i, j in zip(s, t):
if i != j:
N += 1
return N
ns = len(S)
nt = len(T)
res = nt
for i in range(ns - nt + 1):
sub = S[i:i+nt]
a = count_diff(sub, T)
if a < res:
res = a
print(res) | # coding: utf-8
# Your code here!
S = input()
T = input()
ans = 10000000
for i in range(len(T), len(S)+1):
sub_S = S[i-len(T):i]
count = 0
for j in range(len(sub_S)):
if T[j] != sub_S[j]:
count += 1
ans = min(ans, count)
print(ans) | 1 | 3,629,034,029,090 | null | 82 | 82 |
N = int(input())
for i in range(1,int(N**(1/2)) + 1)[::-1]:
if N%i == 0:
print(i + N//i - 2)
exit() | #coding: utf-8
for i in range(9):
for k in range(9):
print str(i+1) + 'x' + str(k+1) + '=' + str((i+1) * (k+1)) | 0 | null | 81,137,749,401,420 | 288 | 1 |
s = sum(int(i) for i in input())
if s % 9 == 0:
print("Yes")
else:
print("No") | n = list(input())
for i in range(len(n)) :
n[i] = int(n[i])
if sum(n)%9==0 :
print("Yes")
else :
print("No") | 1 | 4,419,536,663,900 | null | 87 | 87 |
from collections import deque
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def bfs(field, sx, sy, seen):
queue = deque([(sx, sy)])
seen[sx][sy] += 1
while queue:
x, y = queue.popleft()
for dx, dy in [(-1, 0), (0, 1), (1, 0), (0, -1)]:
nx = x + dx
ny = y + dy
if seen[nx][ny] == -1 and field[nx][ny] != "#":
seen[nx][ny] = seen[x][y] + 1
queue.append((nx, ny))
return seen[x][y]
def main():
H,W = map(int, readline().split())
c = ["#" * (W + 2)]
for _ in range(H):
c.append("#" + readline().strip() + "#")
c.append("#" * (W + 2))
ans = 0
for sx in range(1,H+1):
for sy in range(1,W+1):
if c[sx][sy] == ".":
seen = [[-1] * (W + 2) for i in range(H+2)]
dist = bfs(c, sx, sy, seen)
ans = max(ans, dist)
print(ans)
if __name__ == "__main__":
main()
| from copy import deepcopy
from collections import Counter, defaultdict, deque
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())
def LLI(n): return [list(map(int, input().split())) for _ in range(n)]
def maze_solve(S_1,S_2,maze_list):
d = deque()
dist[S_1][S_2] = 0
d.append([S_1,S_2])
dx = [0,0,1,-1]
dy = [1,-1,0,0]
while d:
v = d.popleft()
x = v[0]
y = v[1]
for i in range(4):
nx = x + dx[i]
ny = y + dy[i]
if nx < 0 or nx >= h or ny < 0 or ny >= w:
continue
if dist[nx][ny] == -1:
dist[nx][ny] = dist[x][y] + 1
d.append([nx,ny])
return max(list(map(lambda x: max(x), dist)))
h,w = MI()
ans = 0
maze = [list(input()) for _ in range(h)]
dist = [[-1]*w for _ in range(h)]
start_list = []
for i in range(h):
for j in range(w):
if maze[i][j] == "#":
dist[i][j] = 0
else:
start_list.append([i,j])
dist_copy = deepcopy(dist)
for k in start_list:
dist = deepcopy(dist_copy)
ans = max(ans,maze_solve(k[0],k[1],maze))
print(ans) | 1 | 94,574,260,423,672 | null | 241 | 241 |
def resolve():
import itertools
N = int(input())
A = []
X = []
ans = [0]
for _ in range(N):
a = int(input())
xx = []
for __ in range(a):
x = list(map(int, input().split()))
xx.append(x)
X.append(xx)
A.append(a)
for i in itertools.product([0, 1], repeat=N):
flag = 0
for p in range(N):
for q in range(A[p]):
if i[p] == 1 and X[p][q][1] != i[X[p][q][0]-1]:
flag = 1
if flag == 0:
ans.append(i.count(1))
print(max(ans))
resolve() | import numpy as np
import numba
from numba import njit, b1, i4, i8, f8
@njit((i8,i8,i8[:],i8[:]), cache=True)
def main(H,N,A,B):
INF = 1<<30
dp = np.full(H+1,INF,np.int64)
dp[0] = 0
for i in range(N):
for h in range(A[i],H):
dp[h] = min(dp[h],dp[h-A[i]]+B[i])
dp[H] = min(dp[H],min(dp[H-A[i]:H]+B[i]))
ans = dp[-1]
return ans
H, N = map(int, input().split())
A = np.zeros(N,np.int64)
B = np.zeros(N,np.int64)
for i in range(N):
A[i],B[i] = map(int, input().split())
print(main(H,N,A,B)) | 0 | null | 100,881,643,143,100 | 262 | 229 |
a=int(input())
b=0
c=list(map(int,input().split()))
for i in range(a):
for k in range(a):
b=b+c[i]*c[k]
for u in range(a):
b=b-c[u]*c[u]
print(int(b/2)) | from itertools import combinations
N = int(input())
takoyaki = list(int(x) for x in input().split())
life = 0
for c in combinations(range(N), 2):
life += takoyaki[c[0]] * takoyaki[c[1]]
print(life)
| 1 | 167,923,011,800,138 | null | 292 | 292 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
k, x = map(int, readline().split())
if 500 * k >= x:
print('Yes')
else:
print('No')
| K, X = map(int,input().split())
price = 500
ans = "No"
if price*K >= X:
ans = "Yes"
print(ans)
| 1 | 98,120,949,335,552 | null | 244 | 244 |
s=input()
for i in range(len(s)):
print('x',end='') |
def main():
S = input()
print("x"*len(S))
if __name__ == "__main__":
main() | 1 | 72,737,008,542,256 | null | 221 | 221 |
x = list(map(int, input().split()))
for i in range(len(x)):
if x[i] == 0:
print(i+1)
break
else:
continue | A = list(map(int, input().split()))
#print(A)
def hantei(list):
for a in range(len(list)):
if list[a] == 0:
return a+1
print(hantei(A)) | 1 | 13,389,266,327,590 | null | 126 | 126 |
all_text = []
while True:
try:
text = input().split()
all_text.extend(text)
except EOFError:
break
text = ''.join(all_text)
count = [0]*32
for letter in text:
i = ord(letter)
if i < 64:
continue
else:
i %= 32
if i:
count[i] += 1
for i in range(26):
print(chr(i+ord('a')), ':', count[i+1])
| n = int(input())
a = list(map(int,input().split()))
count = 0
for i in range(n):
minij =i
for j in range(i,n):
if a[j] < a[minij]:
minij = j
if a[i] > a[minij]:
count+=1
a[i],a[minij] = a[minij],a[i]
print(' '.join(map(str,a)))
print(count)
| 0 | null | 838,563,181,368 | 63 | 15 |
import sys
from collections import deque
#import numpy as np
import math
#sys.setrecursionlimit(10**6)
def S(): return sys.stdin.readline().rstrip()
def SL(): return map(str,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return map(int,sys.stdin.readline().rstrip().split())
def order(l):
flag = [True]*n
ret = 0
for i,item in enumerate(l):
count = 0
for j in range(n):
if item-1==j:
flag[j] = False
break
if not flag[j]:
continue
count += 1
ret += fact[n-i-1]*count
ret += 1
return ret
def solve():
a = order(p)
b = order(q)
print(abs(a-b))
return
if __name__=='__main__':
fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320]
n = I()
p = list(IL())
q = list(IL())
solve() | n ,k = map(int, input().split())
lis = list(map(int, input().split()))
for i in range(k, n):
l = lis[i-k]
r = lis[i]
if r > l:
print('Yes')
else:
print('No') | 0 | null | 53,937,695,146,702 | 246 | 102 |
n = int(input())
d = list(map(int, input().split()))
s = 0
for i in range(n):
for j in range(n):
if i != j:
s += d[i]*d[j]
s //= 2
print(s)
| N,*D = map(int,open(0).read().split())
import itertools
print(sum(a * b for a,b in itertools.combinations(D,2))) | 1 | 168,256,908,695,290 | null | 292 | 292 |
tmp = "abcdefghijklmnopqrstuvwxyz"
alph = list(tmp)
alphcount = [0]*26
while True:
try:
letter = input()
letterarray = list(letter.lower())
# print(letterarray)
except:
break
for x in letterarray:
for i in range(26) :
if (x == alph[i]):
alphcount[i] += 1
else :
continue
for i in range(26):
print(str(alph[i])+" : "+str(alphcount[i]))
| al = 'abcdefghijklmnopqrstuvwxyz'
text = ''
while True:
try:
text += input().lower()
except EOFError:
break
for i in al:
print('{} : {}'.format(i, text.count(i)))
| 1 | 1,677,390,775,350 | null | 63 | 63 |
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N, A = getNM()
w = []
v = []
for i in range(N):
a, b = getNM()
w.append(a)
v.append(b)
# limit回までコストカットできる
def knapsack_6(N, upper, limit, weight, value):
dp = [[[0] * (upper + 1) for i in range(limit + 1)] for j in range(N + 1)]
for i in range(N):
# ボーナスでコスト１にするのを使ったか
for j in range(limit + 1):
for l in range(upper + 1):
# コストカットできる時
if j < limit:
dp[i + 1][j + 1][l] = dp[i][j + 1][l]
if l >= weight[i]:
dp[i + 1][j][l] = max(dp[i][j][l], dp[i][j][l - weight[i]] + value[i])
dp[i + 1][j + 1][l] = max(dp[i][j + 1][l], dp[i][j][l - 1] + value[i])
elif l >= 1:
dp[i + 1][j][l] = max(dp[i + 1][j][l], dp[i][j][l])
dp[i + 1][j + 1][l] = max(dp[i + 1][j + 1][l], dp[i][j][l - 1] + value[i])
else:
dp[i + 1][j][l] = dp[i][j][l]
# できない時
else:
if l >= weight[i]:
dp[i + 1][j][l] = max(dp[i + 1][j][l], dp[i][j][l - weight[i]] + value[i])
return dp[N][limit][upper]
print(knapsack_6(N, A, 1, w, v)) | A, B, C, K = map(int, input().split())
a = min(A, K)
K -= a
b = min(B, K)
K -= b
c = min(C, K)
print(a-c) | 0 | null | 86,433,115,443,090 | 282 | 148 |
import math
X = int(input())
print(int(360 / math.gcd(360, X))) | '''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
mod = 10**9+7
def main():
x = int(ipt())
if x < 600:
print(8)
elif x < 800:
print(7)
elif x < 1000:
print(6)
elif x < 1200:
print(5)
elif x < 1400:
print(4)
elif x < 1600:
print(3)
elif x < 1800:
print(2)
elif x < 2000:
print(1)
else:
pass
return None
if __name__ == '__main__':
main()
| 0 | null | 9,866,902,851,036 | 125 | 100 |
import numpy as np
a,b,x=map(int,input().split())
if x<=a*a*b/2:
y=2*x/(a*b)
print(360/((2*np.pi)/np.arctan(b/y)))
else:
y=2*x/(a**2)-b
print(360/((2*np.pi)/np.arctan((b-y)/a))) | import math
a, b, x = map(float, input().split())
if x < a*a*b/2:
print(math.degrees(math.atan(a*b*b/(2*x))))
else:
print(math.degrees(math.atan(2*((a*a*b-x)/a**3))))
| 1 | 163,521,263,179,440 | null | 289 | 289 |
import numpy as np
N=int(input())
A=np.array(list(map(int,input().split())))
B=np.sum(A)-np.cumsum(np.append(0, A[:len(A)-1]))
v=0
k=0
for i in range(N+1):
if i==0:
if N==0 and A[0]==1:
k=1
elif A[0]==0:
k=1
else:
print(-1)
break
elif i==N:
if B[i]<=2*(k-A[i-1]):
k=B[i]
else:
k=0
print(-1)
break
else:
k=min(2*(k-A[i-1]),B[i])
if k<=0:
print(-1)
break
v+=k
if k>0:
print(v) | # coding: utf-8
def solve(*args: str) -> str:
n = int(args[0])
A = list(map(int, args[1].split()))
rem = sum(A)
cur = 1
ret = 0
for a in A:
cur = min(rem, cur)
rem -= a
ret += cur
cur = 2*(cur-a)
if cur < 0:
ret = -1
break
return str(ret)
if __name__ == "__main__":
print(solve(*(open(0).read().splitlines())))
| 1 | 18,763,867,527,118 | null | 141 | 141 |
def main():
n = int(input())
ans = 0
m = n - 1
num = 1
while num * num <= m:
if m % num == 0:
if num > 1:
ans += 1
if m // num != num:
ans += 1
num += 1
num = 1
while num * num <= n:
if n % num == 0:
tmp = n
while num > 1 and tmp % num == 0:
tmp = tmp // num
if tmp == 1 or tmp % num == 1:
ans += 1
rest = n // num
if rest != num:
tmp = n
while tmp % rest == 0:
tmp = tmp // rest
if tmp == 1 or tmp % num == 1:
ans += 1
num += 1
print(ans)
if __name__ == "__main__":
main()
| from math import sqrt
def div(n):
s = set()
for i in range(1, int(sqrt(n))+2):
if n%i == 0:
s.add(i)
s.add(n//i)
return s
def solve(x, n):
while n % x == 0:
n //= x
if n % x == 1:
return True
return False
def main():
n = int(input())
t = div(n) | div(n-1)
ans = 0
for v in t:
if v != 1 and solve(v, n):
ans += 1
print(ans)
if __name__ == "__main__":
main() | 1 | 41,128,208,346,802 | null | 183 | 183 |
#!usr/bin/env python3
def string_two_numbers_spliter():
a, b = [int(i) for i in input().split()]
return a, b
def main():
a, b = string_two_numbers_spliter()
if a < b:
print('a < b')
elif a > b:
print('a > b')
else:
print('a == b')
if __name__ == '__main__':
main() | import sys
from scipy.sparse.csgraph import csgraph_from_dense
from scipy.sparse.csgraph import floyd_warshall
input = sys.stdin.readline
n, m, energy = map(int, input().split())
edges = [[float('INF')]*n for _ in range(n)]
for i in range(m):
a, b, c = map(int, input().split())
edges[a-1][b-1] = c
edges[b-1][a-1] = c
G = csgraph_from_dense(edges, null_value=float('INF'))
dist = floyd_warshall(G) # dist[i][j] = min_distance between i and j
L_edges = [[0]*n for _ in range(n)]
for i in range(n-1):
for j in range(i, n):
if dist[i][j] <= energy:
L_edges[i][j] = 1
L_edges[j][i] = 1
G = csgraph_from_dense(L_edges, null_value=0)
answers = floyd_warshall(G)
for i in range(n):
for j in range(n):
if answers[i][j] == float('INF'):
answers[i][j] = 0
answers[j][i] = 0
Q = int(input())
for i in range(Q):
s, t = map(int, input().split())
ans = answers[s-1][t-1] - 1
print(int(ans)) | 0 | null | 86,945,281,262,464 | 38 | 295 |
import math
def main():
x1, y1, x2, y2 = map(float, input().split())
b = abs(x2 - x1)
h = abs(y2 - y1)
d = math.sqrt(b ** 2 + h ** 2)
print("{0:.8f}".format(d))
if __name__ == "__main__":
main() | r = list(map(float, input().split()))
print('{0:f}'.format(((r[2] - r[0]) ** 2 + (r[3] - r[1]) ** 2) ** 0.5)) | 1 | 158,013,382,892 | null | 29 | 29 |
N, K = map(int, input().split())
numgcd = [0]*(K+1)
sumgcd = 0
mod = 10**9+7
for i in range(1, K+1)[::-1]:
numgcd[i] = pow(K//i, N, mod)
count = 2
while count*i <= K:
numgcd[i] -= numgcd[count*i]
count += 1
sumgcd += numgcd[i]*i
print(sumgcd%mod) | N = int(input())
A = [tuple(map(int, input().split())) for _ in range(N)]
ans = []
import numpy as np
import itertools
for zyun in itertools.permutations(range(N)):
cnt = 0
for k in range(len(zyun)-1):
cnt += np.sqrt((A[zyun[k+1]][0]-A[zyun[k]][0])**2+(A[zyun[k+1]][1]-A[zyun[k]][1])**2 )
ans.append(cnt)
print(sum(ans) / len(ans)) | 0 | null | 92,246,418,154,430 | 176 | 280 |
N = int(input())
R = []
for _ in range(N):
X, L = map(int, input().split())
R.append([X-L, X+L])
R = sorted(R, key=lambda x: x[1])
ans = 1
p = R[0][1]
for i in range(1, N):
if p <= R[i][0]:
ans += 1
p = R[i][1]
print(ans)
| import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
s = input()
if s[-1]=="s":
s += "es"
else:
s += "s"
print(s) | 0 | null | 46,075,793,248,160 | 237 | 71 |
h,w = list(map(int,input().split()))
h += 2
w += 2
grid = '#'*w
for _ in range(h-2):
grid += '#' + input() + '#'
grid += '#'*w
from collections import deque
ans = 0
for i in range(len(grid)):
INF = 10**9
dist = [INF]*(h*w)
if grid[i]=='#':
continue
dist[i] = 0
q = deque([i])
while q:
v = q.popleft()
dv = dist[v]
for m in (-1,1,w,-w):
move = v + m
if grid[move]=='#':
continue
dmove = dv + 1
if dmove >= dist[move]:
continue
dist[move] = dmove
q.append(move)
# print([dist[i] if dist[i]!=INF else 0 for i in range(len(dist))])
ans = max(ans, max([dist[i] if dist[i]!=INF else 0 for i in range(len(dist))]))
# print(ans)
print(ans) | n=int(input())
a = list(map(int, input().split()))
ans = 0
temp = a[0]
for i in a[1:]:
if temp > i:
ans += (temp - i)
temp = max(temp, i)
print(ans) | 0 | null | 49,289,812,956,608 | 241 | 88 |
import heapq
from sys import stdin
input = stdin.readline
#入力
# s = input()
n = int(input())
# n,m = map(int, input().split())
# a = list(map(int,input().split()))
# a = [int(input()) for i in range()]
st=[]
for i in range(n):
s,t = map(str, input().split())
t = int(t)
st.append((s,t))
x = input()[0:-1]
def main():
ans = 0
flag = False
for i in st:
s,t = i
if flag:
ans+=t
if s == x:
flag = True
print(ans)
if __name__ == '__main__':
main() | N = int(input())
music = []
time = []
for i in range(N):
m,t = input().split()
music.append(m)
time.append(int(t))
S = input()
ans = 0
ans += sum(time[music.index(S)+1:])
print(ans) | 1 | 96,955,451,502,650 | null | 243 | 243 |
from sys import stdin
from collections import defaultdict as dd
from collections import deque as dq
import itertools as it
from math import sqrt, log, log2
from fractions import Fraction
# t = int(stdin.readline())
# for _ in range(t):
# n, m = map(int, stdin.readline().split())
# nums = list(map(int, stdin.readline().split()))
# n = int(input())
# if n%10 in [2, 4, 5, 7, 9]:
# print('hon')
# elif n%10 in [0, 1, 6, 8]:
# print('pon')
# else:
# print('bon')
k = int(input())
s = input()
ans = s[:k] + ('...' if len(s) > k else '')
print(ans) | n=int(input())
stri=[]
time=[]
for _ in range(n):
s,t=input().split()
stri.append(s)
time.append(t)
x=input()
ind=stri.index(x)
ans=0
for i in range(ind+1,n):
ans+=int(time[i])
print(ans) | 0 | null | 58,280,561,053,428 | 143 | 243 |
import sys
import decimal # 10進法に変換，正確な計算
def input():
return sys.stdin.readline().strip()
def main():
n, k = map(int, input().split())
h = list(map(int, input().split()))
count = 0
for i in h:
if i >= k:
count += 1
print(count)
main() | n, k = list(map(int, input().split(' ')))
print(sum([tall >= k for tall in list(map(int, input().split(' ')))])) | 1 | 178,858,059,184,390 | null | 298 | 298 |
import math
ceil = math.ceil
def main(N, A):
A.reverse()
pos = [(A[0], A[0])]
for i in range(len(A)-1):
tmpmin = ceil(pos[-1][0]/2) + A[i+1]
tmpmax = pos[-1][1] + A[i+1]
pos.append((tmpmin, tmpmax))
l,r = pos.pop()
if l > 1:
return -1
ki = [1]
A.reverse()
for j in range(N):
m = (ki[j]-A[j])*2
l, r = pos.pop()
if m < l:
return -1
ki.append(min(r, m))
return sum(ki)
if __name__ == "__main__":
N = int(input())
A = list(map(int, input().split()))
ans = main(N, A)
print(ans)
| from sys import stdin
a=int(stdin.readline())
A=stdin.readline().split()
sum=0
for k in range(0,a+1):
sum+=int(A[k])
sum-=int(A[a])
ver=1
lay=1
K=0
T=0
if a==0:
if A[0]!='1':
print(-1)
K=1
else:
print(1)
K=1
for l in range(0,a):
if lay-int(A[l])<=0:
print(-1)
K=1
break
if (lay-int(A[l]))*2<int(A[a]) and l==(a-1):
print(-1)
K=1
break
if (lay-int(A[l]))*2-sum+int(A[l])<=int(A[a]):
lay=(lay-int(A[l]))*2
ver+=lay
sum-=int(A[l])
T=l
else:
lay-=int(A[l])
sum-=int(A[l])
x=lay-sum-int(A[a])
if x==0:
ver+=lay
elif x>0:
print(-1)
K=1
else:
lay=sum+int(A[a])
ver+=lay
T=l
break
if K==0:
for u in range(T+1,a):
lay -= int(A[u])
sum -= int(A[u])
ver+=lay
if K==0:
print(ver) | 1 | 18,836,036,435,500 | null | 141 | 141 |
n = int(input())
xs = list(enumerate(map(int, input().split())))
xs.sort(key=lambda x: x[1])
xs.reverse()
dp = [[0 for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(1, n + 1):
(j, a) = xs[i - 1]
for x in range(0, i + 1):
y = i - x
if x == 0:
dp[x][y] = dp[x][y - 1] + a * (n - y - j)
elif y == 0:
dp[x][y] = dp[x - 1][y] + a * (j - x + 1)
else:
dp[x][y] = max(dp[x][y - 1] + a * (n - y - j),
dp[x - 1][y] + a * (j - x + 1))
print(max([dp[i][n - i] for i in range(n + 1)])) | N = int(input())
A = list(map(int,input().split()))
# print(A)
RGB = [1,0,0]
M = 1000000007
c = 3
f = False
if A[0] != 0:
f = True
for i in range(1,N):
try:
cnt = RGB.count(A[i])
idx = RGB.index(A[i])
except:
f = True
break
c = (c * cnt)%M
RGB[idx] += 1
# print(RGB)
if f:
print(0)
else:
print(c) | 0 | null | 82,238,877,496,700 | 171 | 268 |
n,m = map(int,input().split())
p=[0]*m
s=[0]*m
for i in range(m):
p[i],s[i]=map(str,input().split())
cor=[0]*n
fal=[0]*n
for i in range(m):
x=int(p[i])
if cor[x-1]==0:
if s[i]=='AC':
cor[x-1]=1
else:
fal[x-1]+=1
ans_cor=0
ans_fal=0
for i in range(n):
if cor[i]==1:
ans_cor+=1
ans_fal+=fal[i]
print(ans_cor,ans_fal) | n = input()
maxv = - 1 * pow(10, 9)
minv = input()
for _ in xrange(1, n):
Rj = input()
maxv = max(maxv, Rj - minv)
minv = min(minv, Rj)
print maxv | 0 | null | 46,963,363,466,938 | 240 | 13 |
from bisect import bisect_left
n = int(input())
l = sorted(list(map(int, input().split())))
ans = 0
# a<b<c として、aとbを固定する
# 残る条件は c<a+b のみ
# aとbの固定方法がO(N^2), cの二分探索がO(logN)、結局O(N^2logN)
# 二分探索は事前にソートが必要
# ex. 2, 4(a), 4, 7(b), | 8, 9, 9 | (ここにa+b=11が挿入される), 12, 14
# cとして適切なのは8,9,9の3通り
# bisect_rightだとa+bが存在した時にバグる
for ai in range(n):
for bi in range(ai + 1, n):
ans += bisect_left(l, l[ai] + l[bi]) - bi - 1
print(ans)
|
def findnumberofTriangles(arr):
n = len(arr)
arr.sort()
count = 0
for i in range(0, n-2):
k = i + 2
for j in range(i + 1, n):
while (k < n and arr[i] + arr[j] > arr[k]):
k += 1
if(k>j):
count += k - j - 1
return count
n = int(input())
arr=[int(x) for x in input().split()]
print(findnumberofTriangles(arr))
| 1 | 172,291,976,652,290 | null | 294 | 294 |
a,b = map(int,input().split())
l = [str(a)*b, str(b)*a]
l.sort()
print(l[0]) | n, m = map(int, input().split())
a = list(map(int, input().split()))
for time in a:
n -= time
if n<0:
n = -1
break
print(n) | 0 | null | 58,300,229,463,648 | 232 | 168 |
a,b,c = map(int,input().split())
if a > b:
b,a = a,b
if b > c:
b,c = c,b
if a > b:
b,a = a,b
else:
if b > c:
b,c = c,b
if a > b:
b,a = a,b
print(f"{a} {b} {c}")
| N=int(input())
X=input()
def calc(n,count):
if n==0:
return count
popcount=bin(n).count("1")
next_n=n%popcount
#print(next_n)
if next_n==0:
return count+1
else:
return calc(next_n, count+1)
popcount=X.count("1")
if popcount==1:
plus=0
for i in range(N):
x=X[i]
if x=="1":
plus+=pow(2,N-i-1,popcount+1)
for i in range(N):
x=X[i]
if x=="1":
print(0)
else:
ans=plus+pow(2,N-i-1,popcount+1)
ans%=(popcount+1)
print(calc(ans,1))
exit()
plus=0
minus=0
for i in range(N):
x=X[i]
if x=="1":
plus+=pow(2,N-i-1,popcount+1)
minus+=pow(2,N-i-1,popcount-1)
plus%=(popcount+1)
minus%=(popcount-1)
for i in range(N):
x=X[i]
if x=="1":
ans=minus-pow(2,N-i-1,popcount-1)
ans%=(popcount-1)
print(calc(ans,1))
else:
ans=plus+pow(2,N-i-1,popcount+1)
ans%=(popcount+1)
print(calc(ans,1))
| 0 | null | 4,334,406,828,500 | 40 | 107 |
from collections import deque
def main():
n, m = map(int, input().split())
adj = [[] for _ in range(n)]
for _ in range(m):
a, b = map(int, input().split())
adj[a - 1].append(b - 1)
adj[b - 1].append(a - 1)
ans = 0
visited = [False] * n
for i in range(n):
if visited[i]:
continue
q = deque()
q.append(i)
cnt = 1
visited[i] = True
while q:
u = q.popleft()
for v in adj[u]:
if not visited[v]:
q.append(v)
cnt += 1
visited[v] = True
ans = max(ans, cnt)
print(ans)
if __name__ == "__main__":
main()
| n = int(input())
def dfs(n, s, idx):
l = len(s)
if n == l:
print(s)
return
alpha = "abcdefghijklmnopqrstuvwxyz"
i = 0
while i < idx + 1:
if i == idx:
dfs(n, s + alpha[i], idx + 1)
else:
dfs(n, s + alpha[i], idx)
i += 1
dfs(n, "", 0)
| 0 | null | 28,152,457,384,138 | 84 | 198 |
s,w = map(int, input().split())
ans = "NG"
# for i in range(a,b+1):
# print(i)
if s<=w:
print("unsafe")
else:
print("safe") | n = int(input())
l =list(map(int,input().split()))
l.reverse()
for i in range(n):
if i != n-1:
print(f"{l[i]} ",end="")
else:
print(f"{l[i]}")
| 0 | null | 15,150,206,970,430 | 163 | 53 |
n = input()
for i in range(n):
s = map(int, raw_input().split())
s.sort()
if s[2]**2 == (s[0]**2) + (s[1]**2): print "YES"
else: print "NO" | n=input()
for i in range(n):
l=map(int,raw_input().split())
l.sort()
if l[0]**2+l[1]**2==l[2]**2:print"YES"
else:print"NO" | 1 | 251,918,080 | null | 4 | 4 |
x,n = map(int,input().split())
if n == 0:
print(x)
exit()
p = list(map(int,input().split()))
ans = []
num = 0
while ans == []:
if x + num in p and x - num in p:
num+=1
else:
if x + num not in p and x - num not in p:
ans = x - num
elif x + num not in p:
ans = x + num
else:
ans = x - num
print(ans) | n = int(input())
L = list(map(int,input().split()))
L.sort()
import bisect
ans = 0
for i in range(1,n):
for j in range(i+1,n):
tmp = L[:i]
v = L[j]-L[i]
idv = bisect.bisect_right(tmp,v)
if idv!=len(tmp):
ans += len(tmp)-idv
print(ans)
| 0 | null | 92,935,142,169,272 | 128 | 294 |
x,y,z = map(int,input().split())
temp = x
x = y
y = temp
temp = x
x = z
z = temp
print(x,y,z) | nums=[int(i) for i in input().split()]
print(nums[2],nums[0],nums[1]) | 1 | 38,070,754,130,120 | null | 178 | 178 |
from collections import deque
a = deque([])
for i in range(int(input())):
c = input().split()
if c[0] == "insert":
a.appendleft(c[1])
elif c[0] == "delete":
try:
a.remove(c[1])
except ValueError:
pass
elif c[0] == "deleteFirst":
a.popleft()
else:
a.pop()
for i,e in enumerate(a):
if i == len(a) - 1:
print(e)
else:
print(e, end=" ")
| x=list(map(int,input().split()))
print(sum([1,2,3,4,5])-sum(x)) | 0 | null | 6,739,705,825,728 | 20 | 126 |
import sys
input = sys.stdin.readline
read = sys.stdin.read
n, t = map(int, input().split())
m = map(int, read().split())
AB = sorted(zip(m, m))
A, B = zip(*AB)
dp = [[0]*t for _ in range(n+1)]
for i, a in enumerate(A[:-1]):
for j in range(t):
if j < a:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j-a]+B[i], dp[i][j])
ans = 0
maxB = [B[-1]]*n
for i in range(n-2, 0, -1):
maxB[i] = max(B[i], maxB[i+1])
for i in range(n-1):
ans = max(ans, dp[i+1][-1] + maxB[i+1])
print(ans) | n = int(input())
A = list(map(int, input().split()))
MOD = 10**9+7
ans = 0
for i in range(60):
cnt = 0
for a in A:
cnt += a>>i&1
ans += cnt*(n-cnt)*2**i
ans %= MOD
print(ans)
| 0 | null | 137,667,249,531,588 | 282 | 263 |
a,b=map(int,input().split())
lst={0:0,1:300000,2:200000,3:100000}
if a>3:
x=0
else:
x=a
if b>3:
y=0
else:
y=b
if x==1 and y==1:
ans=1000000
else :
ans=lst[x]+lst[y]
print(ans) | #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
flush = sys.stdin.flush()
def solve():
x,y = LI()
ans = 0
f = [300000,200000,100000,0]
if x == 1 and y == 1:
print(1000000)
else:
ans = f[min(3,x-1)]+f[min(3,y-1)]
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| 1 | 141,069,172,452,180 | null | 275 | 275 |
# -*-coding:utf-8
#import fileinput
import math
def main():
n = int(input())
for i in range(1, n+1):
x = i
if (x%3 == 0):
print(' %d' % i, end='')
else:
while(x):
if (x%10 == 3):
print(' %d' % i, end='')
break
else:
x = int(x/10)
print('')
if __name__ == '__main__':
main() | def resolve():
D = int(input())
C = [int(x) for x in input().split()]
S = []
for i in range(D):
S.append(list(map(int, input().split())))
t = [int(input()) for _ in range(D)]
last_d = []
score = 0
for d in range(D):
score += S[d][t[d] - 1]
last_d.append(t[d] - 1)
for i in range(len(C)):
if i in last_d:
score -= C[i] * last_d[::-1].index(i)
else:
score -= C[i] * (d + 1)
print(score)
if __name__ == "__main__":
resolve() | 0 | null | 5,457,748,321,532 | 52 | 114 |
INF = float("inf")
n, k, c = map(int, input().split())
s = input()
l, r = [(0, -INF)] + [None] * n, [(0, INF)] + [None] * n
for i, x in enumerate(s):
wn, wd = l[i]
l[i+1] = (wn+1, i) if x == "o" and i-wd > c else l[i]
for i, x in enumerate(s[::-1]):
wn, wd = r[i]
j = n-i-1
r[i+1] = (wn+1, j) if x == "o" and wd-j > c else r[i]
for i in range(n):
ln, ld = l[i]
rn, rd = r[n-i-1]
w = ln + rn
if rd - ld <= c: w -= 1
if w < k: print(i+1)
| number = [i for i in input().split()]
number.sort()
print(' '.join(number))
| 0 | null | 20,692,697,362,100 | 182 | 40 |
def rle(t):
tmp2, count_, ans_ = t[0], 1, []
for i_ in range(1, len(t)):
if tmp2 == t[i_]:
count_ += 1
else:
ans_.append([tmp2, count_])
tmp2 = t[i_]
count_ = 1
ans_.append([tmp2, count_])
return ans_
S = list(input())
l = rle(S)
ans = [0] * (len(S) + 1)
count = 0
for i in range(len(l)):
if l[i][0] == '<':
for j in range(l[i][1] + 1):
ans[count + j] = max(ans[count + j], j)
elif l[i][0] == '>':
for k in range(l[i][1] + 1):
ans[count + k] = max(ans[count + k], l[i][1] - k)
count += l[i][1]
print(sum(ans))
| s=input()
ans=0
up=0
down=0
if(s[0]=='>'):
down+=1
else:
up+=1
for i in range(1,len(s)):
if(s[i]=='>'):
down+=1
else:
if(s[i-1]=='>'):
high=max(up,down)
low=min(up,down)
ans+=(high+1)*(0+high)//2
low-=1
ans+=(low+1)*(0+low)//2
up=1
down=0
else:
up+=1
else:
high=max(up,down)
low=min(up,down)
ans+=(high+1)*(0+high)//2
low-=1
ans+=(low+1)*(0+low)//2
print(ans) | 1 | 156,426,680,426,072 | null | 285 | 285 |
from collections import *
n, p = map(int, input().split())
s = list(map(int, input()))
if 10%p==0:
r = 0
for i in range(n):
if s[i]%p==0:
r += i+1
print(r)
exit()
c = Counter()
c[0] += 1
v = r = 0
k = 1
for i in s[::-1]:
v += int(i)*k
v %= p
r += c[v]
c[v] += 1
k *= 10
k %= p
print(r)
| # -*- coding: utf-8 -*-
import sys
from collections import defaultdict
N,P=map(int, sys.stdin.readline().split())
S=sys.stdin.readline().strip()
if P in (2,5):
ans=0
for i,x in enumerate(S):
if int(x)%P==0:
ans+=i+1
print ans
else:
L=[int(S)%P]
for i,x in enumerate(S):
L.append((L[-1]-int(x)*pow(10,N-1-i,P))%P)
ans=0
D=defaultdict(lambda: 0)
for i in range(N,-1,-1):
x=L[i]
ans+=D[x]
D[x]+=1
print ans
| 1 | 57,979,297,534,858 | null | 205 | 205 |
a , b = list(map(int,input().strip().split()))
print('No' if ((a*500) < b) else 'Yes') | k,x = [int(i) for i in input().split()]
ans=''
if k*500 >= x: ans = 'Yes'
else: ans='No'
print(ans)
| 1 | 97,887,135,942,492 | null | 244 | 244 |
import sys
(n, m, l) = [int(i) for i in sys.stdin.readline().split()]
a = []
for i in range(n):
a.append([int(i) for i in sys.stdin.readline().split()])
b = []
for i in range(m):
b.append([int(j) for j in sys.stdin.readline().split()])
for i in range(n):
row = []
for j in range(l):
c_ij = 0
for k in range(m):
c_ij += a[i][k] * b[k][j]
row.append(str(c_ij))
print(" ".join(row)) | 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() | 0 | null | 31,577,667,632,838 | 60 | 209 |
n = int(input())
min_price = int(input())
max_diff = -1e9
for _ in range(n - 1):
p = int(input())
max_diff = max(p - min_price, max_diff)
min_price = min(p, min_price)
print(max_diff) | from collections import deque
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
score = dict(r=P, s=R, p=S)
ans = 0
q = deque()
for i in range(K):
s = T[i]
ans += score[s]
q.append(s)
for i in range(K, N):
s = T[i]
s_pre_k = q.popleft()
if s == s_pre_k:
q.append('n')
else:
ans += score[s]
q.append(s)
print(ans)
| 0 | null | 53,346,322,203,680 | 13 | 251 |
class Dice:
def __init__(self,numbers):
self.surface=numbers
def roll_E(self):
self.surface[0],self.surface[2],self.surface[3],self.surface[5]=self.surface[3],self.surface[0],self.surface[5],self.surface[2]
def roll_N(self):
self.surface[0],self.surface[1],self.surface[4],self.surface[5]=self.surface[1],self.surface[5],self.surface[0],self.surface[4]
def roll_S(self):
self.surface[0],self.surface[1],self.surface[4],self.surface[5]=self.surface[4],self.surface[0],self.surface[5],self.surface[1]
def roll_W(self):
self.surface[0],self.surface[2],self.surface[3],self.surface[5]=self.surface[2],self.surface[5],self.surface[0],self.surface[3]
def result(self):
return self.surface[0]
dice=Dice(input().split())
orders=input()
for i in orders:
if i=='E':
dice.roll_E()
if i=='N':
dice.roll_N()
if i=='S':
dice.roll_S()
if i=='W':
dice.roll_W()
print(int(dice.result()))
| label = input().split()
rot = input()
dice = {
"top":1,
"front":2,
"right":3,
"left":4,
"back":5,
"bottom":6
}
for r in rot:
if r == 'E':
dice["top"], dice["left"], dice["bottom"], dice["right"] = \
dice["left"], dice["bottom"], dice["right"], dice["top"]
elif r == 'N':
dice["top"], dice["front"], dice["bottom"], dice["back"] = \
dice["front"], dice["bottom"], dice["back"], dice["top"]
elif r == 'S':
dice["top"], dice["back"], dice["bottom"], dice["front"] = \
dice["back"], dice["bottom"], dice["front"], dice["top"]
elif r == 'W':
dice["top"], dice["right"], dice["bottom"], dice["left"] = \
dice["right"], dice["bottom"], dice["left"], dice["top"]
print(label[dice["top"]-1]) | 1 | 236,501,874,528 | null | 33 | 33 |
n=int(input())
a=[0]+list(map(int,input().split()))
cnt={}
ans = 0
for i in range(1,n+1):
if a[i] +i not in cnt:
cnt[a[i] +i] = 0
cnt[a[i] + i] += 1
for i in range(1, n+1):
if i-a[i] in cnt:
ans+= cnt[i-a[i]]
print(ans) | # i>j とする.
# |i-j|=Ai+Aj
# i-j = Ai+Aj
N=int(input())
A=list(map(int,input().split()))
cnt=[0]*300000
ans=0
for i in range(N):
if i-A[i]>=0:
ans=ans+cnt[i-A[i]]
if i+A[i]<len(cnt):
cnt[i+A[i]]=cnt[i+A[i]]+1
print(ans)
| 1 | 25,939,274,177,990 | null | 157 | 157 |
class Dice:
__slots__ = ['n1', 'n2', 'n3', 'n4', 'n5', 'n6']
def __init__(self, n_tup):
self.n1 = n_tup[0]
self.n2 = n_tup[1]
self.n3 = n_tup[2]
self.n4 = n_tup[3]
self.n5 = n_tup[4]
self.n6 = n_tup[5]
def roll(self, direction):
if direction == "N":
self.n1, self.n2, self.n6, self.n5 \
= self.n2, self.n6, self.n5, self.n1
elif direction == "E":
self.n1, self.n3, self.n6, self.n4 \
= self.n4, self.n1, self.n3, self.n6
if direction == "S":
self.n1, self.n2, self.n6, self.n5 \
= self.n5, self.n1, self.n2, self.n6
if direction == "W":
self.n1, self.n3, self.n6, self.n4 \
= self.n3, self.n6, self.n4, self.n1
dice = Dice([int(x) for x in input().split()])
cmd = input()
for i in range(len(cmd)):
dice.roll(cmd[i])
print(dice.n1) | class Dice(object):
def __init__(self):
self.number = [0 for _ in range(6)]
self.before = [0 for _ in range(6)]
def set_number(self, l):
for i in range(6):
self.number[i] = l[i]
def roll(self, loc):
d = {
'N': (1, 5, 2, 3, 0, 4),
'S': (4, 0, 2, 3, 5, 1),
'E': (3, 1, 0, 5, 4, 2),
'W': (2, 1, 5, 0, 4, 3)
}
for i in range(6):
self.before[i] = self.number[i]
for i, j in enumerate(d[loc]):
self.number[i] = self.before[j]
def get_Top(self):
return self.number[0]
if __name__ == '__main__':
l = list(map(int, input().split()))
dice = Dice()
dice.set_number(l)
s = input()
for i in s:
dice.roll(i)
print(dice.get_Top())
| 1 | 237,660,087,200 | null | 33 | 33 |
string = input()
if string[-1] == 's':
out = string + "es"
else:
out = string + "s"
print(out) | s = input()
print(s + "es") if s[-1] == "s" else print(s + "s") | 1 | 2,400,398,640,958 | null | 71 | 71 |
n=int(input())
c=0
a=list(map(int,input().split()))
for i in range(n):
m=i
for j in range(i,n):
if a[m]>a[j]:m=j
if i!=m:a[m],a[i]=a[i],a[m];c+=1
print(*a)
print(c) | s = input()
q = int(input())
for qi in range(q):
command = input().split()
a = int(command[1])
b = int(command[2])
if command[0] == 'print':
print(s[a:b + 1])
elif command[0] == 'reverse':
s = s[:a] + s[a:b + 1][::-1] + s[b + 1:]
else:
p = command[3]
s = s[:a] + p + s[b + 1:] | 0 | null | 1,059,861,675,390 | 15 | 68 |
def resolve():
N,M = map(int,input().split())
if N % 2 == 1:
for i in range(M):
print(str(i+1) + " " + str(N-i))
else:
for i in range((M-1) // 2 + 1):
print(str(i+1) + " " + str(N-i))
for i in range((M-1) // 2 + 1 , M):
print(str(i+1) + " " + str(N-i-1))
resolve() | s = input()
rd = 0
max_rd = 0
for i in range(len(s)):
if s[i] == 'R':
rd += 1
if max_rd < rd:
max_rd = rd
else:
rd = 0
print(max_rd) | 0 | null | 16,789,843,174,752 | 162 | 90 |
N = int(input())
MAX = 10**6
table = [0]*(MAX+1)
for x in map(int,input().split()):
table[x] += 1
for i in range(MAX+1):
if table[i]:
for j in range(2*i if table[i] == 1 else i, MAX+1, i):
table[j] = 0
print(sum(table)) | import sys
A1,A2,A3 = map(int,input().split())
if not ( 1 <= A1 <= 13 and 1 <= A2 <= 13 and 1 <= A3 <= 13 ): sys.exit()
if not ( isinstance(A1,int) and isinstance(A2,int) and isinstance(A3,int) ): sys.exit()
print('bust') if A1 + A2 + A3 >= 22 else print('win') | 0 | null | 66,302,176,654,256 | 129 | 260 |
#
# panasonic2020b d
#
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """1"""
output = """a"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2"""
output = """aa
ab"""
self.assertIO(input, output)
def resolve():
global N
N = int(input())
dfs("a", "a")
def dfs(mw, s):
if len(s) == N:
print(s)
return
for i in range(ord(mw)-ord("a")+2):
mw = max(mw, chr(ord("a")+i))
ns = s + chr(ord("a")+i)
dfs(mw, ns)
if __name__ == "__main__":
# unittest.main()
resolve()
| from copy import copy
n=int(input())
alpha="abcdefghij"
c=[0 for i in range(n)]
m=[0 for i in range(n)]
ans=[]
ans.append(copy(c))
while True:
c[-1]+=1
i=n-1
while i!=0 and c[i]-2==m[i-1]:
c[i]=0
i-=1
c[i]+=1
if i==0:
break
for i in range(1,n):
m[i]=max(m[i-1],c[i])
ans.append(copy(c))
for i in ans:
print("".join(map(lambda x:alpha[x],i))) | 1 | 52,531,221,781,752 | null | 198 | 198 |
while True:
n = int(input())
if n == 0:
break
else:
data_set = [int(i) for i in input().split()]
m = sum(data_set) / n
v = 0
for i in data_set:
diff = i - m
v += diff ** 2
v /= n
print(v ** 0.5) | import math
A,B,C,D = map(int, input().split())
Taka=A/D
Aoki=C/B
if math.ceil(Taka)>=math.ceil(Aoki):
print("Yes")
else:
print("No") | 0 | null | 15,004,993,241,410 | 31 | 164 |
n,k = map(int, input().split())
alist=list(map(int, input().split()))
def is_ok(arg):
cnt=0
for i in alist:
cnt+=(i-1)//arg
return cnt<=k
def nibun(ng, ok):
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(nibun(0 , 10**9 + 1)) | N, K = map(int, input().split())
A = list(map(int, input().split()))
r = max(A)
l = 0
while l+1 < r:
mid = (l+r)//2
cnt = 0
for a in A:
if(a > mid):
if(a%mid == 0):
cnt += (a//mid)-1
else:
cnt += a//mid
if(cnt > K):
l = mid
else:
r = mid
print(r) | 1 | 6,521,887,029,540 | null | 99 | 99 |
N = int(input())
N = N % 10
if N == 2 or N == 4 or N == 5 or N == 7 or N == 9:
print('hon')
elif N == 3:
print('bon')
else:
print('pon') | def solve():
string = list(input())
ans = 0
if string[-1]=="s":
ans = "".join(string)+"es"
print(ans)
return
else:
print("".join(string)+"s")
return
solve() | 0 | null | 10,778,940,974,340 | 142 | 71 |
N = int(input())
if N % 10 in [2, 4, 5, 7, 9]:
print("hon")
elif N % 10 in [0, 1, 6, 8]:
print("pon")
else:
print("bon") | mylist1 = [2,4,5,7,9]
mylist2 = [0,1,6,8]
N = int(input())
X = N % 10
if X in mylist1:
print('hon')
elif X in mylist2:
print('pon')
else:
print('bon') | 1 | 19,232,100,619,420 | null | 142 | 142 |
N = int(input())
S = [input() for _ in range(N)]
D = [[0] * 2 for _ in range(N)]
for i in range(N):
s = S[i]
ma = 0
l = 0
r = 0
for j in s:
if j == ")":
r += 1
else:
l += 1
ma = max(ma, r - l)
D[i] = [l - r, ma, s]
cnt = 0
P = []
M = []
for x, y ,s in D:
if x >= 0:
if y <= 0:
cnt += x
else:
P.append([x, y])
else:
M.append([x, y, s])
P.sort(key = lambda x:x[1])
for x, y in P:
if y > cnt:
print("No")
exit()
cnt += x
if len(M) == 0:
if cnt == 0:
print("Yes")
else:
print("No")
exit()
M.sort(reverse = True)
M.sort(key = lambda x:x[1], reverse = True)
for i in range(len(M)):
x, y, s = M[i]
if x == -y:
g = x
M[i] = [0, 0, ""]
break
else:
print("No")
exit()
for x, y, s in M:
if cnt < y:
print("No")
exit()
cnt += x
if cnt + g == 0:
print("Yes")
else:
print("No")
| def main():
X = int(input())
fifth_power = [x ** 5 for x in range(201)]
for i in range(len(fifth_power)):
p = fifth_power[i]
q1 = abs(X - p)
q2 = abs(X + p)
if q1 in fifth_power:
if p + q1 == X:
print(fifth_power.index(p), -fifth_power.index(q1))
elif p - q1 == X:
print(fifth_power.index(p), fifth_power.index(q1))
return 0
if q2 in fifth_power:
print(fifth_power.index(q2), fifth_power.index(p))
return 0
main() | 0 | null | 24,511,888,495,618 | 152 | 156 |
import math
N = int(input())
result = N
for i in range(1, int(math.sqrt(N))+2):
if N % i == 0:
result = min(result, i - 1 + N//i - 1)
print(result)
| n = int(input())
max_div_num = 1
for i in range(2, int(n**(1/2) + 1)):
if n % i == 0:
max_div_num = max(i, max_div_num)
x = max_div_num
y = n // max_div_num
print(x + y - 2) | 1 | 161,175,964,923,780 | null | 288 | 288 |
x, y = map(int, input().split())
msg = 'No'
for a in range(1, x+1):
if 2*a + 4*(x-a) == y or 4*a + 2*(x-a) == y:
msg = 'Yes'
print(msg) | import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
x,y = map(int,input().split())
for turu in range(x+1):
kame = x-turu
if kame * 4 + turu * 2 == y:
print("Yes")
exit()
print("No") | 1 | 13,695,362,149,492 | null | 127 | 127 |
s = input()
ans = ''
for i in range(len(s)):
ans = ans + 'x'
print(ans) | S = input()
A = ""
for i in range(len(S)) :
A = A + "x"
print(A) | 1 | 72,598,453,667,368 | null | 221 | 221 |
import math
def dis(x, y):
return math.sqrt(x * x + y * y)
N, D = map(int, input().split())
result = 0
for i in range(N):
x, y = map(int, input().split())
if dis(x, y) <= D:
result += 1
print(result)
| #!/usr/bin/env python3
#xy = [map(int, input().split()) for _ in range(5)]
#x, y = zip(*xy)
def main():
nd = list(map(int, input().split()))
ans = 0
for i in range(nd[0]):
xy = list(map(int, input().split()))
if xy[0] * xy[0] + xy[1] * xy[1] <= nd[1] * nd[1]:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 1 | 5,957,069,970,720 | null | 96 | 96 |
N,K = [int(i) for i in input().split()]
mod = 998244353
LR = []
S = []
dp = [0]*(N+1)
dps = [0]*(N+1)
dps[1] = 1
dp[1] = 1
for i in range(K):
LR.append([int(i) for i in input().split()])
for i in range(1,N+1):
for l,r in LR:
l,r = i - r,i - l
#print(l,r)
if r < 1:
continue
l = max(1,l)
dp[i] += dps[r] - dps[l-1]
dp[i] %= mod
#print(dp[i])
dps[i] = dps[i-1] + dp[i]
#print(dp, dps)
print(dp[-1]) | import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
h, w = LI()
if h == 1 or w == 1:
print(1)
else:
if (h * w) % 2 == 0:
print(int(h * w / 2))
else:
print(int(h * w / 2 + 1)) | 0 | null | 26,687,473,390,798 | 74 | 196 |
import itertools
import math
n = int(input())
location = [list(map(int, input().split())) for _ in range(n)]
pmt = list(itertools.permutations(range(0, n)))
dis_sum = 0
for i in pmt:
dis = 0
for j in range(n-1):
x1, y1 = location[i[j]]
x2, y2 = location[i[j+1]]
dis += math.sqrt((x1-x2)**2 + (y1-y2)**2)
dis_sum += dis
print(dis_sum/len(pmt))
| print(-int(input())%1000) | 0 | null | 78,783,850,020,218 | 280 | 108 |
from collections import deque
def bfs(maze, visited, x):
queue = deque([x])
visited[x] = 1
ans_list[x] = 0
while queue:
#queueには訪れた地点が入っている。そこから、移動できるか考え、queueから消す。
y = queue.popleft()#queueに入っていたものを消す。
r = maze[y - 1][2:]
for i in r:
if visited[i] == 0:
if ans_list[i] >= 10 ** 10:
ans_list[i] = ans_list[y] + 1
queue.append(i)
return 0
if __name__ == "__main__":
N = int(input())
A = [0] * N
for i in range(N):
A[i] = list(map(int, input().split()))
visited = [0] * (N + 1)
ans_list = [float("inf")] * (N + 1)
bfs(A, visited, 1)
#print(bfs(A, visited, 1))
for i in range(1, N + 1):
if ans_list[i] >= 10 ** 10:
print(i, -1)
else:
print(i, ans_list[i])
| import collections
def breadth_first_search(g,check,length):
q = collections.deque()
q.append(1)
check[1] = 1
length[1] = 0
while len(q) != 0:
v = q.popleft()
for u in g[v]:
if check[u] == 0:
check[u] = 1
length[u] = length[v]+1
q.append(u)
return length
def main():
N = int(input())
g = []
g.append([])
for i in range(N):
tmp = input().split()
tmp_ls = []
for i in range(int(tmp[1])):
tmp_ls.append(int(tmp[i+2]))
g.append(tmp_ls)
check = [0]*(N+1)
length = [0]*(N+1)
ans = breadth_first_search(g,check,length)
for i in range(N):
node_num = i+1
if ans[node_num] == 0 and i != 0:
ans[node_num] = -1
print(node_num,ans[node_num])
main()
| 1 | 4,390,884,996 | null | 9 | 9 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, K, LR):
M = 998244353
memo = [0] *(N+2)
memo[1] = 1
memo[1+1] = -1
for i in range(1, N+1):
memo[i] += memo[i-1]
memo[i] %= M
for l, r in LR:
ll = min(N+1, i+l)
rr = min(N+1, i+r+1)
memo[ll] += memo[i]
memo[ll] %= M
memo[rr] -= memo[i]
memo[rr] %= M
return memo[N]
def main():
N, K = read_int_n()
LR = [read_int_n() for _ in range(K)]
print(slv(N, K, LR))
if __name__ == '__main__':
main()
| k = int(input())
a, b = map(int, input().split())
if a % k != 0 and a // k == b // k:
print('NG')
else:
print('OK')
| 0 | null | 14,527,689,504,192 | 74 | 158 |
n,k=list(map(int, input("").split()))
d=[]
a=[]
t=[]
for i in range(k):
d.append(int(input()))
a.append(list(map(int, input("").split())))
for i in range(n):
t.append(True)
for i in range(k):
for j in a[i]:
if t[j-1]:
t[j-1]=False
out=0
for i in t:
if i:
out+=1
print(out)
| n, k = map(int, input().split())
l = [0] * n
for i in range(k):
d = int(input())
x = list(map(int, input().split()))
for j in range(d):
l[x[j]-1] += 1
print(l.count(0)) | 1 | 24,603,439,785,640 | null | 154 | 154 |
import sys
sys.setrecursionlimit(10**8)
def line_to_int(): return int(sys.stdin.readline())
def line_to_each_int(): return map(int, sys.stdin.readline().split())
def line_to_list(): return list(map(int, sys.stdin.readline().split()))
def line_to_list_in_iteration(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
# def dp(init, i, j): return [[init]*i for i2 in range(j)]
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
# from itertools import accumulate #A = [0]+list(accumulate(A))
# import bisect #bisect.bisect_left(B, a), bisect.bisect_right(B,a)
x = line_to_list()
print(x.index(0)+1) | X = list(map(int, input().split()))
for i, x in enumerate(X):
if x == 0:
print(i+1)
exit() | 1 | 13,432,173,413,892 | null | 126 | 126 |
x = int(input())
for i in range(1,x+1):
y = i
if y % 3 == 0:
print(" %d" % i, end="")
continue
while True:
if int(y) % 10 == 3:
print(" %d" % i, end="")
break
y /= 10
if int(y) == 0: break
print("") | n = int(input())
for i in range(1, n + 1):
if i % 3 == 0 or str(i).find("3") != -1:
print(" {}".format(i), end = '')
print()
| 1 | 928,820,083,840 | null | 52 | 52 |
N = int(input())
P = list(map(int, input().split()))
min_value = P[0]
cnt = 1
for i in range(1, N):
if P[i] < min_value :
min_value = P[i]
cnt += 1
print(cnt)
| # ALDS1_5_A.
def intinput():
a = input().split()
for i in range(len(a)):
a[i] = int(a[i])
return a
def binary_search(S, k):
a = 0; b = len(S) - 1
if b == 0: return S[0] == k
while b - a > 1:
c = (a + b) // 2
if k <= S[c]: b = c
else: a = c
return S[a] == k or S[b] == k
def show(a):
# 配列aの中身を出力する。
_str = ""
for i in range(len(a) - 1): _str += str(a[i]) + " "
_str += str(a[len(a) - 1])
print(_str)
def main():
n = int(input())
A = intinput()
q = int(input())
m = intinput()
# 配列Aの作る数を調べる。
nCanMake = [0]
for i in range(n):
for k in range(len(nCanMake)):
x = nCanMake[k] + A[i]
if not x in nCanMake: nCanMake.append(x)
# show(nCanMake)
for i in range(q):
if m[i] in nCanMake: print("yes")
else: print("no")
if __name__ == "__main__":
main()
| 0 | null | 42,698,968,645,738 | 233 | 25 |
def main():
n = int(input())
A = list(map(int, input().split()))
for a in A:
if a % 2 == 0:
if not (a % 3 == 0 or a % 5 == 0):
print('DENIED')
return
print('APPROVED')
if __name__ == '__main__':
main()
| a, b = map(int, input().split(" "))
print("%d %d %.5f" %(a/b, a%b, a/b))
| 0 | null | 34,842,052,876,440 | 217 | 45 |
n, p = map(int, input().split())
s = input()
sum_count = 0
if p in {2, 5}:
for right in range(n):
if int(s[right]) % p == 0:
sum_count += (right + 1)
else:
modp_count = [0] * p
modp_count[0] = 1
subs_modp, pow = 0, 1
for si in s[::-1]:
subs_modp += ((int(si)*pow) % p)
subs_modp %= p
modp_count[subs_modp] += 1
pow = (pow*10) % p
for count in modp_count:
sum_count += count*(count - 1) // 2
print(sum_count) | from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
h = I()
w = I()
n = I()
if h < w:
for i in range(1,h+1):
if i * w >= n:
print(i)
exit()
else:
for i in range(1,w+1):
if i*h >= n:
print(i)
exit()
| 0 | null | 73,301,654,774,942 | 205 | 236 |
# coding:utf-8
n = int(input())
count = 0
for i in range(n):
d1, d2 = map(int, input().split())
if d1 == d2:
count += 1
else:
count = 0
if count == 3:
print('Yes')
exit()
print('No')
| N=int(input())
A=[]
for i in range(N):
D=list(map(int,input().split()))
A.append(D)
for i in range(N-2):
if A[i][0]==A[i][1] and A[i+1][0]==A[i+1][1] and A[i+2][0]==A[i+2][1]:
print('Yes')
break
else:
print('No') | 1 | 2,486,183,089,152 | null | 72 | 72 |
N = int(input())
A = list(map(int,input().split()))
A.sort()
ans = 0
for k in range(1, N): ans += A[N-k//2-1]
print(ans) | N=int(input())
a=list(map(int, input().split()))
k=list(map(str,a))
j=' '.join(k)
print(j)
for i in range(1,N):
v=a[i]
j=i-1
while a[j]>v and j>=0:
a[j+1]=a[j]
j -=1
a[j+1]=v
b=list(map(str, a))
c=' '.join(b)
print(c)
| 0 | null | 4,625,958,402,108 | 111 | 10 |
x = int(input())
a = int(x/500) * 1000 + x % 500 - x % 5
print(a) | x=int(input())
n=x//500
m=x%500//5
ans=1000*n+5*m
print(ans)
| 1 | 42,803,539,186,760 | null | 185 | 185 |
def selection_sort(seq):
l = len(seq)
cnt = 0
for i in range(l):
mi = i
for j in range(i+1, l):
if seq[j] < seq[mi]:
mi = j
if i is not mi:
seq[i], seq[mi] = seq[mi], seq[i]
cnt += 1
return seq, cnt
n = int(input())
a = list(map(int, input().split()))
sorted_a, num_swap = selection_sort(a)
print(' '.join(map(str, sorted_a)))
print(num_swap) | def selectionSort(a,n):
count = 0
for i in range(n):
minj = i
for j in range(i, n):
if(a[j] < a[minj]):
minj = j
if(minj != i):
count += 1
a[i], a[minj] = a[minj], a[i]
return [a, count]
n = int(input())
a = list(map(int,input().split(' ')))
sa , c = selectionSort(a, n)
str = " ".join([str(i) for i in sa])
print("{}\n{}".format(str,c))
| 1 | 19,726,612,150 | null | 15 | 15 |
Dict = set()
n = int(input())
for i in range(n):
C = input().split()
if C[0] =="insert":
Dict.add(C[1])
else:
if C[1] in Dict:
print("yes")
else:
print("no") | print('YNeos'[eval(input().replace(' ','!='))::2]) | 0 | null | 41,808,514,453,540 | 23 | 231 |
ri = [int(v) for v in input().split()]
A, B, C, D = ri
f = 1
while A > 0 and C > 0:
if f:
C -= B
else:
A -= D
f ^= 1
print("Yes" if A > C else "No")
| n, m, q = map(int, input().split())
abcd = []
for _ in range(q):
abcd.append(tuple(map(int, input().split())))
ans = 0
from itertools import combinations_with_replacement
for A in combinations_with_replacement(list(range(1, m+1)), n):
suma = 0
for a,b,c,d in abcd:
if A[b-1] - A[a-1] == c:
suma += d
ans = max(ans, suma)
print(ans)
| 0 | null | 28,837,492,463,520 | 164 | 160 |
n = int(input())
fo_x = '0' + str(n) + 'b'
a = [None] * n
x = [None] * n
y = [None] * n
ans = 0
flag = 0
for i in range(n):
a[i] = int(input())
ax = [None] * a[i]
ay = [None] * a[i]
for j in range(a[i]):
ax[j],ay[j] = map(int,input().split())
x[i] = ax
y[i] = ay
for i in range(2 ** n):
b = format(i,fo_x)
for j in range(len(b)):
if b[j] == '0':
continue
for z in range(a[j]):
if str(y[j][z]) != b[x[j][z]-1]:
flag = 1
break
if flag == 1:
break
if flag == 0:
ans = max(ans,b.count('1'))
flag = 0
print(ans) | import sys
N = int(input())
List = [[-1] * N for i in range(N)]
for i in range(N):
A = int(input())
for j in range(A):
x, y = map(int, input().split())
List[i][x - 1] = y
Max = 0
for i in range(2 ** N):
flag = True
Sum = 0
for j in range(N): # このループが一番のポイント
if ((i >> j) & 1): # 順に右にシフトさせ最下位bitのチェックを行う
for k in range(N):
if (List[j][k] != int((i >> k) & 1)) and List[j][k] != -1:
flag = False
Sum += 1
if flag:
#print(i,Sum)
Max = max(Max, Sum)
print(Max)
| 1 | 121,369,300,233,828 | null | 262 | 262 |
pictures = ['S','H','C','D']
card_li = []
for i in range(4):
for j in range(1,14):
card_li.append(pictures[i] + ' ' + str(j))
n = int(input())
for i in range(n): del card_li[card_li.index(input())]
for i in card_li:
print(i) | x, y, z = map(int, input().split())
print(z, ' ', x, ' ', y) | 0 | null | 19,568,727,542,532 | 54 | 178 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools, bisect
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def S(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
alphabets = "abcdefghijklmnopqrstuvwxyz"
sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
# nodeをリストに変換したらクソ遅かった
import pprint
class BalancingTree:
def __init__(self, n):
self.N = n
self.root = self.node(1<<n, 1<<n)
def __str__(self):
def debug_info(nd):
return (nd.value - 1, nd.left.value - 1 if nd.left else None, nd.right.value - 1 if nd.right else None)
def debug_node(nd):
v = debug_info(nd) if nd.value else ()
left = debug_node(nd.left) if nd.left else []
right = debug_node(nd.right) if nd.right else []
return [v, left, right]
return pprint.PrettyPrinter(indent=4).pformat(debug_node(self.root))
__repr__ = __str__
def append(self, v):# v を追加（その時点で v はない前提）
v += 1
nd = self.root
while True:
# v がすでに存在する場合に何か処理が必要ならここに書く
if v == nd.value:
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):
return self.leftmost(nd.left) if nd.left else nd
def rightmost(self, nd):
return self.rightmost(nd.right) if nd.right else nd
def find_l(self, v): # vより真に小さいやつの中での最大値（なければ-1）
v += 1
nd = self.root
prev = nd.value if nd.value < v else 0
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 = nd.value if nd.value > v else 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
def max(self):
return self.find_l((1<<self.N)-1)
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)
# v以下のものの中での最大値
def upper_bound(self, v):
upper = self.find_r(v)
return self.find_l(upper)
def lower_bound(self, v):
lower = self.find_l(v)
return self.find_r(lower)
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
def main():
N = I()
s = S()
Q = I()
query = LR(Q)
trees = {ch: BalancingTree(25) for ch in alphabets}
for i, ch in enumerate(s):
trees[ch].append(i)
for q in query:
if q[0] == "1":
_, i, c = q
i = int(i) - 1
prev = s[i]
trees[prev].delete(i)
s[i] = c
trees[c].append(i)
else:
_, l, r = q
l, r = int(l) - 1, int(r) - 1
count = 0
for _, tree in trees.items():
first = tree.lower_bound(l)
if first != tree.root.value - 1 and first <= r:
count += 1
print(count)
if __name__ == '__main__':
main()
| # simpleバージョン
class BinaryIndexedTree:
def __init__(self,size):
self.N = size
self.bit = [0]*(size+1)
def add(self,x,w): # 0-indexed
x += 1
while x <= self.N:
self.bit[x] += w
x += (x & -x)
def _sum(self,x): # 1-indexed
ret = 0
while x > 0:
ret += self.bit[x]
x -= (x & -x)
return ret
def sum(self,l,r): # [l,r)
return self._sum(r) - self._sum(l)
def __str__(self): # for debug
arr = [self.sum(i,i+1) for i in range(self.N)]
return str(arr)
class BIT:
""" 区間加算BIT(区間加算・区間合計取得) """
def __init__(self, N):
# 添字0が使えないので、内部的には全て1-indexedとして扱う
N += 1
self.N = N
self.data0 = [0] * N
self.data1 = [0] * N
def _add(self, data, k, x):
k += 1
while k < self.N:
data[k] += x
k += k & -k
def _get(self, data, k):
k += 1
s = 0
while k:
s += data[k]
k -= k & -k
return s
def add(self, l, r, x):
""" 区間[l,r)に値xを追加 """
self._add(self.data0, l, -x*(l-1))
self._add(self.data0, r, x*(r-1))
self._add(self.data1, l, x)
self._add(self.data1, r, -x)
def query(self, l, r):
""" 区間[l,r)の和を取得 """
return self._get(self.data1, r-1) * (r-1) + self._get(self.data0, r-1) \
- self._get(self.data1, l-1) * (l-1) - self._get(self.data0, l-1)
def ctoi(c):
return ord(c) - ord('a')
def main():
N = int(input())
S = input()
Q = int(input())
query = [input().split() for i in range(Q)]
bits = [BIT(N) for i in range(26)]
s = []
for i, c in enumerate(S):
bits[ctoi(c)].add(i,i+1,1)
s.append(c)
for a, b, c in query:
if a == '1':
i = int(b) - 1
bits[ctoi(s[i])].add(i,i+1,-1)
bits[ctoi(c)].add(i,i+1,1)
s[i] = c
else:
l = int(b) - 1
r = int(c)
a = 0
for i in range(26):
if bits[i].query(l,r):
a += 1
print(a)
if __name__ == "__main__":
main() | 1 | 62,288,759,535,900 | null | 210 | 210 |
#!/usr/bin/env python3
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n=int(input())
A=list(map(int, input().split()))
counts=[0]*(10**6+5)
for AA in A:
counts[AA]+=1
ans=0
for i in range(1,10**6+5):
if counts[i]>0:
for j in range(i+i,10**6+5,i):
counts[j]=-1
if counts[i]==1:
ans+=1
print(ans)
if __name__ == '__main__':
main()
| if __name__ == '__main__':
n = int(input())
graph = [[0 for i in range(n)] for _ in range(n)]
frist = [0 for _ in range(n)]
end = [0 for _ in range(n)]
visit = [False for _ in range(n)]
# get the group
for i in range(n):
datas = [int(num) for num in input().split(' ')]
if datas[1] > 0:
for j in datas[2:]:
graph[datas[0] - 1][j - 1] = 1
visit[0] = True
frist[0] = s = 1
stack = [0]
while len(stack) != 0:
point = stack.pop(-1)
flag = False
for i in range(n):
if graph[point][i] == 1 and visit[i] is False:
visit[i] = True
flag = True
s += 1
frist[i] = s
stack.append(point)
stack.append(i)
break
if flag is False:
s += 1
end[point] = s
if len(stack) == 0:
for i in range(n):
if visit[i] is False:
visit[i] = True
s += 1
frist[i] = s
stack.append(i)
break
for i in range(n):
print('%d %d %d' % (i+1, frist[i], end[i]))
| 0 | null | 7,189,508,591,888 | 129 | 8 |
import numpy as np
def main():
n = int(input())
x = np.arange(n + 1)
x[x % 3 == 0] = 0
x[x % 5 == 0] = 0
print(x.sum())
if __name__ == '__main__':
main() | X = int(input())
rankArr=[2000,1800,1600,1400,1200,1000,800,600,400]
for i in range(1,len(rankArr)):
if rankArr[i] <= X and X < rankArr[i-1] :
print(i)
exit() | 0 | null | 20,734,220,882,848 | 173 | 100 |
n = int(input())
a = list(map(int, input().split()))
s = sum(a)
k = 1-a[0]
s -= a[0]
ans = 1
for i in range(1,n+1):
if k*2 <= s:
k *= 2
else:
k = s
ans += k
k -= a[i]
s -= a[i]
if k == 0 and s == 0:
print(ans)
else:
print(-1) | l=map(int,raw_input().split())
a=l[0]
b=l[1]
c=l[2]
if a>b:
a,b=b,a
if b>c:
b,c=c,b
if a>b:
a,b=b,a
print a,b,c | 0 | null | 9,696,515,895,920 | 141 | 40 |
n,k=(int(x) for x in input().split())
h=list(int(x) for x in input().split())
c=0
for i in h:
if i>=k:
c+=1
print(c) | import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return map(list, zip(*read_all))
#################
N,K = LI()
A = LI()
ans = []
for i in range(N-K):
if A[i] < A[K+i]:
ans.append('Yes')
else:
ans.append('No')
for a in ans:
print(a) | 0 | null | 92,977,814,157,312 | 298 | 102 |
N = int(input())
A = input().split()
ans = 1
zero_count = A.count("0")
if zero_count != 0:
print(0)
else:
for i in range(N):
ans *= int(A[i])
if ans > 10**18:
ans = -1
break
print(ans) | #10^18こえたら-1
n = int(input())
Arr = list(map(int, input().split( )))
Arr = sorted(Arr)
if Arr[0] == 0:
print(0)
exit()
s = 1
for i in range(n):
s *= Arr[i]
if s > 10**18:
print(-1)
exit()
print(s) | 1 | 16,208,642,652,342 | null | 134 | 134 |
def main():
n = int(input())
s = set()
for _ in range(n):
s.add(input())
print(len(s))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main(R,C,K,rcv):
inf=float('inf')
dp0=[[-inf,-inf,-inf,0] for _ in range(C)]
item=[[0]*C for _ in range(R)]
for r,c,v in rcv:
item[r-1][c-1]=v
# dp0[c][j]:c列目の時点で残りちょうどj個取れる時の最大値
for i in range(R):
# i+1行目に対する操作
# 遷移
for j in range(C):
if j>0:
dp0[j][3]=max(dp0[j])
dp0[j][0]=dp0[j-1][0]
dp0[j][1]=dp0[j-1][1]
dp0[j][2]=dp0[j-1][2]
else:
dp0[0][3]=max(dp0[0])
dp0[0][2]=-inf
dp0[0][1]=-inf
dp0[0][0]=-inf
if item[i][j]>0:
v=item[i][j]
dp0[j][0]=max(dp0[j][0],dp0[j][1]+v)
dp0[j][1]=max(dp0[j][1],dp0[j][2]+v)
dp0[j][2]=max(dp0[j][2],dp0[j][3]+v)
print(max(dp0[-1]))
if __name__=='__main__':
R,C,K=map(int,input().split())
rcv=[list(map(int,input().split())) for _ in range(K)]
main(R,C,K,rcv)
| 0 | null | 17,918,035,057,710 | 165 | 94 |
def i1str():
return input()
def istrs(n=None):
if n is None:
return input().split()
a = []
for _ in range(n):
a.append(istrs())
return a
def i1num():
return int(input())
def inums(n=None):
if n is None:
return list(map(int, input().split()))
a = []
for _ in range(n):
a.append(inums())
return a
def ostrs(l, sp=" "):
print(sp.join(l))
def onums(l, sp=" "):
print(sp.join(map(str, l)))
def solve(n, aii):
dp = [[0 for _ in range(n+1)] for _ in range(n+1)]
for x in range(n+1):
for y in range(n+1-x):
if x == y == 0:
continue
ai, i = aii[n-x-y]
dp[x][y] = max(dp[x-1][y] + ai * (i-x+1) if x > 0 else 0,
dp[x][y-1] + ai * (n-y-i) if y > 0 else 0)
res = 0
for x in range(n+1):
if dp[x][n-x] > res:
res = dp[x][n-x]
return res
if __name__ == "__main__":
n = i1num()
a = inums()
aii = sorted((a[i], i)for i in range(n))
print(solve(n, aii))
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 9
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 998244353
n = I()
A = LI()
S = sorted([(A[k], k + 1) for k in range(n)], reverse=True)
ans = 0
dp = [[0] * (n + 1) for _ in range(n + 1)]
for i in range(n):
for j in range(n):
if i and i <= S[i + j - 1][1]:
dp[i][j] = max(dp[i][j], dp[i - 1][j] + S[i + j - 1][0] * abs(i - S[i + j - 1][1]))
if j and S[i + j - 1][1] <= n - j + 1:
dp[i][j] = max(dp[i][j], dp[i][j - 1] + S[i + j - 1][0] * abs(n - j + 1 - S[i + j - 1][1]))
if i + j == n:
ans = max(ans, dp[i][j])
break
print(ans)
| 1 | 33,733,722,020,292 | null | 171 | 171 |
n, m = map(int,input().split())
a = list(map(int,input().split()))
if n - sum(a) >= 0:
print(n - sum(a))
else:
print('-1') | N = int(input())
D_ls = list(map(int, input().split(' ')))
result = 0
for i in range(N):
for j in range(i+1, N):
result += D_ls[i] * D_ls[j]
print(result) | 0 | null | 100,178,209,394,352 | 168 | 292 |
def count_(n):
cnt = 0
k = 1
while(n-k >= 0):
n = n - k
k = k + 1
cnt = cnt + 1
return cnt
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
if __name__ == '__main__':
n = int(input())
s_li = (factorization(n))
if s_li[0][0] == 1:
print(0)
else:
ans = 0
for s_ in s_li:
ans = ans + count_(s_[1])
print(ans) | def main():
height, width = map(int, input().split())
grid = [list(input()) for _ in range(height)]
dp = [[float("inf") for _ in range(width)] for _ in range(height)]
if grid[0][0] == "#":
dp[0][0] = 1
else:
dp[0][0] = 0
delta = [[0, 1], [1, 0]]
for i in range(height):
for j in range(width):
for dx, dy in delta:
if i + dy >= height or j + dx >= width:
continue
else:
add = 0
if grid[i][j] == "." and grid[i + dy][j + dx] == "#":
add = 1
dp[i + dy][j + dx] = min(dp[i + dy][j + dx], dp[i][j] + add)
print(dp[-1][-1])
if __name__ == '__main__':
main()
| 0 | null | 33,325,707,247,008 | 136 | 194 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.