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
|
|---|---|---|---|---|---|---|
PD = input()
print(PD.replace("?", "D"))
| input_list = map(int, raw_input().split())
ineq = ""
if input_list[0] < input_list[1]:
ineq = "<"
elif input_list[0] > input_list[1]:
ineq = ">"
else:
ineq = "=="
print "a %s b" % (ineq) | 0 | null | 9,345,837,798,648 | 140 | 38 |
N = int(input())
S = input()
cnt = 0
for i in range(N):
if S[i:i+3] == "ABC":
cnt += 1
print(cnt) |
# 最小公倍数(mathは3.5以降) fractions
from functools import reduce
import fractions #(2020-0405 fractions→math)
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y) # 「//」はフロートにせずにintにする
def lcm(*numbers):
return reduce(lcm_base, numbers, 1)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
N,M = (int(x) for x in input().split())
A = list(map(int, input().split()))
lcm =lcm_list(A)
harf_lcm =lcm//2 # 最小公倍数の半分
harf_lcm_num =M//harf_lcm # Mの中の半公倍数の個数
harf_lcm_num =(harf_lcm_num +1)//2 # 偶数を除く
#半公倍数がaiで割り切れるときは✖
import numpy as np
A_np =np.array(A)
if np.any(harf_lcm % A_np ==0):
harf_lcm_num =0
"""
for a in A:
if harf_lcm % a ==0:
harf_lcm_num =0
break
"""
print(harf_lcm_num) | 0 | null | 100,723,435,175,874 | 245 | 247 |
n=int(input())
b=input().split()
s=b[:]
for i in range(n):
for j in range(n-1,i,-1):
if b[j][1]<b[j-1][1]:b[j],b[j-1]=b[j-1],b[j]
m=i
for j in range(i,n):
if s[m][1]>s[j][1]:m=j
s[m],s[i]=s[i],s[m]
print(*b)
print('Stable')
print(*s)
print(['Not stable','Stable'][b==s]) | N = int(input())
C = input().split()
B = C[:]
S = C[:]
# bubble sort
flag = 1
while(flag):
flag = 0
for x in range(1, N):
if B[x][1:] < B[x-1][1:]:
B[x], B[x-1] = B[x-1], B[x]
flag = 1
# sectionSot
for x in range(0,N):
minj = x
for j in range(x,N):
if S[j][1:] < S[minj][1:]:
minj = j
if minj != x:
S[x], S[minj] = S[minj], S[x]
for i in range(1, N):
v = C[i]
j = i - 1
while(j >=0 and C[j][1:] > v[1:]):
C[j+1] = C[j]
j -= 1
C[j+1] = v
if(C == B):
print(" ".join(b for b in B))
print("Stable")
else:
print(" ".join(b for b in B))
print("Not stable")
if(C == S):
print(" ".join(b for b in S))
print("Stable")
else:
print(" ".join(b for b in S))
print("Not stable") | 1 | 24,839,804,110 | null | 16 | 16 |
# get line input split by space
def getLnInput():
return input().split()
# ceil(a / b) for a > b
def ceilDivision(a, b):
return (a - 1) // b + 1
def main():
getLnInput()
nums = list(map(int, getLnInput()))
print(min(nums), max(nums), sum(nums))
return
main() | input()
xs = list(map(int, input().split()))
print(' '.join(map(str,[f(xs) for f in [min,max,sum]]))) | 1 | 723,881,791,590 | null | 48 | 48 |
x=int(input())
if x>=30:
print('Yes')
else:
print('No') | X=input()
X=int(X)
if X >= 30:
print('Yes')
else:
print('No') | 1 | 5,687,415,197,490 | null | 95 | 95 |
from collections import deque
LIM=200004
L=[0]*LIM
def bin_sum(Y):
S=bin(Y)[2:]
count=0
for i in range(len(S)):
count+=int(S[i])
return count
def bin_sum2(Y):
count=0
for i in range(len(Y)):
count+=int(Y[i])
return count
for i in range(1,LIM):
L[i]+=bin_sum(i)
def pop_num(N,b,L):
if N==0:
return 0
v=N%b
return pop_num(v,L[v],L)+1
M=[0]*200005
for i in range(1,200004):
M[i]+=pop_num(i,L[i],L)
X=int(input())
Y=input()
d=bin_sum2(Y)
e=int(Y,2)%(d+1)
f=int(Y,2)%max(1,(d-1))
O=[1]*(X+2)
P=[1]*(X+2)
q=max(d-1,1)
for i in range(1,X+1):
O[i]=O[i-1]*2%q
P[i]=P[i-1]*2%(d+1)
for i in range(X):
if int(Y[i])==1:
b=max(d-1,1)
flag=max(0,d-1)
g=(f-O[X-1-i]+b)%b
else:
b=d+1
flag=1
g=(e+P[X-1-i])%b
if flag==0:
print(0)
elif g==0:
print(1)
else:
print(M[g]+1) | N=int(input())
x=input()
num=0
n=0
def twice(a):
ans=0
while a:
ans+=a%2
a//=2
return ans
ma=5*10**5
dp=[0]*ma
for i in range(1,ma):
dp[i]=dp[i%twice(i)]+1
c=x.count("1")
a=int(x,2)%(c+1)
if c==1:
for i in range(N):
if x[i]=="0":
print(dp[(a+pow(2,N-i-1,2))%2]+1)
else:
print(0)
exit()
b=int(x,2)%(c-1)
for i in range(N):
if x[i]=="0":
print(dp[(a+pow(2,N-i-1,c+1))%(c+1)]+1)
else:
print(dp[(b-pow(2,N-i-1,c-1))%(c-1)]+1) | 1 | 8,286,868,092,412 | null | 107 | 107 |
import collections
n, m = map(int, input().split())
linked = collections.defaultdict(list)
i2group = dict()
gid = n + 1
def get_root(i):
if i not in linked:
return i
j = get_root(linked[i])
linked[i] = j
return j
def get_groups():
return [get_root(i) for i in range(1, n + 1)]
for i in range(m):
a, b = map(int, input().split())
ra, rb = get_root(a), get_root(b)
if ra == rb: continue
linked[ra] = gid
linked[rb] = gid
gid += 1
g = get_groups()
print(len(set(g)) - 1)
exit()
n_connected = 0
n_group = 0
for s in linked.values():
s = s[0]
if s:
n_group += 1
n_connected += len(s)
s.clear()
print((n - n_connected) + (n_group - 1))
| class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
# 検索
def find(self, 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 = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
n,m = map(int,input().split())
u = UnionFind(n)
for _ in range(m):
ai,bi = map(int,input().split())
u.union(ai,bi)
s = [0 for _ in range(n+1)]
for i in range(1,n+1):
s[u.find(i)] = 1
print(sum(s)-1) | 1 | 2,312,632,801,280 | null | 70 | 70 |
r=int(input())
r0=1*1
s1=r*r
s=s1/r0
print('%d'%s) | def resolve():
a,b = map(int,input().split())
if 1<=a<=9 and 1<=b<=9:
print(a*b)
else:
print(-1)
resolve() | 0 | null | 151,615,121,334,260 | 278 | 286 |
from collections import deque
N,M = map(int,input().split())
G = {i:[] for i in range(1,N+1)}
for _ in range(M):
a,b = map(int,input().split())
G[a].append(b)
G[b].append(a)
col = [-1 for _ in range(N+1)]
cnt = 0
for i in range(1,N+1):
if col[i]<0:
col[i]=cnt
que = deque([i])
while que:
x = que.popleft()
for y in G[x]:
if col[y]<0:
col[y] = cnt
que.append(y)
cnt += 1
C = {}
for i in range(1,N+1):
a = col[i]
if a not in C:
C[a] = 0
C[a] += 1
cmax = 0
for a in C:
cmax = max(cmax,C[a])
print(cmax) | # -*- coding: utf-8 -*-
from sys import stdin
class Dice:
def __init__(self,dicelist):
self.dice_list = dicelist
def roll(self, direction):
work = list(self.dice_list)
if (direction == 'N'):
self.dice_list[0] = work[1]
self.dice_list[1] = work[5]
self.dice_list[2] = work[2]
self.dice_list[3] = work[3]
self.dice_list[4] = work[0]
self.dice_list[5] = work[4]
elif (direction == 'E'):
self.dice_list[0] = work[3]
self.dice_list[1] = work[1]
self.dice_list[2] = work[0]
self.dice_list[3] = work[5]
self.dice_list[4] = work[4]
self.dice_list[5] = work[2]
elif (direction == 'S'):
self.dice_list[0] = work[4]
self.dice_list[1] = work[0]
self.dice_list[2] = work[2]
self.dice_list[3] = work[3]
self.dice_list[4] = work[5]
self.dice_list[5] = work[1]
elif (direction == 'W'):
self.dice_list[0] = work[2]
self.dice_list[1] = work[1]
self.dice_list[2] = work[5]
self.dice_list[3] = work[0]
self.dice_list[4] = work[4]
self.dice_list[5] = work[3]
def roll_until_index0top(self,num0):
if self.dice_list[0] == num0:
return
commands = ['E', 'E', 'E', 'N', 'N', 'N']
for c in commands:
self.roll(c)
if self.dice_list[0] == num0:
return
else:
print('error')
def get_index_by_number(self, num):
for i in range(len((self.dice_list))):
if self.dice_list[i] == num:
return i
else:
return -1
def get_index2_number(self, num1):
index1 = self.get_index_by_number(num1)
if index1 == 1:
return self.dice_list[2]
elif (index1 == 2):
return self.dice_list[4]
elif (index1 == 3):
return self.dice_list[1]
elif (index1 == 4):
return self.dice_list[3]
else:
print('error 2')
def getTop(self):
return self.dice_list[0]
dice_list = list(map(int, stdin.readline().rstrip().split()))
q = int(stdin.readline().rstrip())
dice = Dice(dice_list)
for i in range(q):
num0_num1 = list(map(int, stdin.readline().rstrip().split()))
dice.roll_until_index0top(num0_num1[0])
print(dice.get_index2_number(num0_num1[1]))
| 0 | null | 2,084,450,182,880 | 84 | 34 |
x=int(input())
for a in range(-120,121):
for b in range(-120,121):
if x==pow(a,5)-pow(b,5):
print(a,b)
exit() | X = int(input())
# Xの素因数分解をうまくつかう
# A^5 - B^5 =(A-B)(A^4+A^3B+A^2B^2+AB^3+B^4)
# どっちが正負かは決まらない
# AB(A^2+B^2)+(A^2+B^2)^2-A^2B^2
# AB((A-B)^2+2AB)+((A-B)^2+2AB)^2 - A^2B^2
# A-B = P
# AB = Q
# A^5-B^5 = P(Q(P^2+2Q)+(P^2+2Q)^2-Q^2) = P(P^4+5P^2Q+5Q^2) = P(5Q^2+5P^2Q+P^4)
# Qは整数解なので
# 5Q^2+5P^2Q+P^4が整数解を持つ楽な方法は(Q+P)^2の形の時、つまり2P = P^2+2,
# X = PRとする
# R-P^4は5の倍数になる
#Aの上限を求める
# X<10^9
# A-B = 1がAを最大にできる
maxA = 126
maxX = pow(10, 9)
flag = 0
for A in range(-126, 126):
for B in range(-127, A):
result = pow(A, 5) - pow(B, 5)
if result > maxX:
next
if result == X:
print(A, B)
flag = 1
break
if flag == 1:
break | 1 | 25,642,274,307,140 | null | 156 | 156 |
def selection_sort(A, n):
count = 0
for i in range(n-1):
minj = i
for j in range(i, n):
if A[j] < A[minj]:
minj = j
if i != minj:
A[i], A[minj] = A[minj], A[i]
count += 1
print(' '.join(map(str, A)))
print(count)
if __name__ == '__main__':
n = int(input())
A = list(map(int, input().split()))
selection_sort(A, n) | def solve():
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
if A1 < B1 and A2 < B2:
return 0
elif A1 > B1 and A2 > B2:
return 0
C1, C2 = B1-A1, B2-A2
if C1*T1 + C2*T2 == 0:
return 'infinity'
if C1*T1 + C2*T2 < 0:
C1, C2 = -C1, -C2
if abs(C1*T1) > abs(C2*T2):
return 0
x1, x2 = T1, 2*T1+T2
y1, y2 = C1*T1, 2*C1*T1+C2*T2
x = -y1 * (x2-x1) // (y2-y1) + x1
z = x-T1
T = T1+T2
num = z//T
ans = num*2
dist = C1*T1 + (C1*T1 + C2*T2)*num
if dist != 0:
ans += 1
return int(ans)
print(solve())
| 0 | null | 65,763,214,378,640 | 15 | 269 |
# ==================================================-
# 二分探索
# functionを満たす,search_listの最大の要素を出力
# 【注意点】searchリストの初めの方はfunctionを満たし、後ろに行くにつれて満たさなくなるべき
import math
import sys
sys.setrecursionlimit(10 ** 9)
def binary_research(start, end,function):
if start == end:
return start
middle = math.ceil((start + end) / 2)
if function(middle, k, a_sum, b_sum):
start = middle
else:
end = middle - 1
return binary_research(start, end, function)
# ==================================================-
n, m, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
a_sum = [0]
b_sum = [0]
for book in a:
a_sum.append(a_sum[-1] + book)
for book in b:
b_sum.append(b_sum[-1] + book)
def can_read(num, k, a_sum, b_sum):
min_read_time = 1000000000000
for i in range(max(0, num - m), min(num+1,n+1)):
a_num = i
b_num = num - i
min_read_time = min(min_read_time, a_sum[a_num] + b_sum[b_num])
if min_read_time <= k:
return True
return False
start = 0
end = n + m
print(binary_research(start, end, can_read)) | def main():
N, K, S = map(int, input().split())
MaxN = 10 ** 9
if S == MaxN:
A = [S] * K + [1] * (N - K)
else:
A = [S] * K + [S + 1] * (N - K)
print(" ".join(map(str, A)))
if __name__ == "__main__":
main()
| 0 | null | 50,827,024,216,452 | 117 | 238 |
s = input()
left_index = []
puddles = []
for i in range(len(s)):
if s[i] == "\\":
left_index.append(i)
elif s[i] == "/" and len(left_index) > 0:
left = left_index.pop()
puddle = i - left
while len(puddles) > 0 and puddles[-1][0] > left:
puddle += puddles.pop()[1]
puddles.append([left, puddle])
ans = [p[1] for p in puddles]
print(sum(ans))
if len(ans): print(len(ans), " ".join(map(str, ans)))
else : print(len(ans))
| # -*- coding: utf-8 -*-
modelmap = list(input())
S1 = []
S2 = []
A = 0
for i, l in enumerate(modelmap):
if l == "\\":
S1.append(i)
elif l == "/" and len(S1) > 0:
ip = S1.pop()
A += i - ip
L = i - ip
while len(S2) > 0 and S2[-1][0] > ip:
L += S2.pop()[1]
S2.append([ip, L])
print(A)
text2 = "{}".format(len(S2))
for s in S2:
text2 += " " + str(s[1])
print(text2) | 1 | 56,804,690,518 | null | 21 | 21 |
[S,T] = input().split()
print(T+S) | s, t = input().split()
print(f"{t}{s}") | 1 | 103,099,113,240,860 | null | 248 | 248 |
import sys
sys.setrecursionlimit(1000000)
def make_adlist(n):
adlist = [[] for _ in range(n)]
for _ in range(n-1):
a, b = map(lambda x:int(x)-1, input().split())
adlist[a] += [b]
adlist[b] += [a]
return adlist
def dfs(adlist, s, dist, d):
for nxt in adlist[s]:
if dist[nxt] == -1:
dist[nxt] = d
dfs(adlist, nxt, dist, d+1)
def main():
n, u, v = map(int, input().split())
u -= 1
v -= 1
adlist = make_adlist(n)
t_dist = [-1]*n
t_dist[u] = 0
dfs(adlist, u, t_dist, 1)
a_dist = [-1]*n
a_dist[v] = 0
dfs(adlist, v, a_dist, 1)
ans = 0
for i in range(n):
if t_dist[i] < a_dist[i]:
ans = max(ans, a_dist[i]-1)
print(ans)
if __name__ == "__main__":
main() | import sys
from collections import deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: map(int, read().split())
def bfs(N, v0, edge):
search = [-1] * N
search[v0] = 0
q = deque()
q.append(v0)
while q:
v = q.popleft()
for nv in edge[v]:
if search[nv] == -1:
q.append(nv)
search[nv] = search[v] + 1
return search
def bfs2(N, v0, edge, dis):
q = deque()
q.append(v0)
max_dis = dis[v0]
while q:
v = q.popleft()
for nv in edge[v]:
if dis[v] < dis[nv]:
q.append(nv)
max_dis = max(max_dis, dis[nv])
return max_dis
def main():
N, taka, aoki = in_nn()
taka, aoki = taka - 1, aoki - 1
edge = [[] for _ in range(N)]
for i in range(N - 1):
x, y = in_nn()
x, y = x - 1, y - 1
edge[x].append(y)
edge[y].append(x)
dis = bfs(N, aoki, edge)
if dis[taka] > 2:
x = (dis[taka] + 1) // 2 - 1
for _ in range(x):
for v in edge[taka]:
if dis[v] < dis[taka]:
taka = v
break
ans = bfs2(N, taka, edge, dis) - 1
print(ans)
if __name__ == '__main__':
main()
| 1 | 117,487,684,129,228 | null | 259 | 259 |
N = int(input())
A = list(map(int, input().split()))
count = 0
for item in A:
if item % 2 == 0:
if item % 3 == 0 or item % 5 == 0:
count += 1
else:
count += 1
if count == N:
print("APPROVED")
else:
print("DENIED") | import math
import numpy as np
N,M=map(int,input().split())
A=list(map(int,input().split()))
c=1
test=A[0]
l=0
while test%2 == 0:
test=test//2
c*=2
for i in np.arange(N-1):
if A[i+1]%c!=0:
print(0)
l=1
break
elif A[i+1]%(c*2)==0:
print(0)
l=1
break
else:
k=A[i+1]//c
test=test*k//math.gcd(test,k)
if l==0:
k=test*c//2
print(M//k//2+M//k%2) | 0 | null | 85,151,908,240,708 | 217 | 247 |
cards = [[0 for i in range(13)] for j in range(4)]
n = int(input())
for i in range(n):
card = list(input().split())
card[1] = int(card[1])
if card[0] == 'S':
suit = 0
elif card[0] == 'H':
suit = 1
elif card[0] == 'C':
suit = 2
elif card[0] == 'D':
suit = 3
cards[suit][card[1]-1] = 1
for i in range(4):
if i == 0:
suit = 'S'
elif i == 1:
suit = 'H'
elif i == 2:
suit = 'C'
elif i == 3:
suit = 'D'
for j in range(13):
if not(cards[i][j]):
print(suit, j+1) | import itertools
n = int(input())
a = [input() for _ in range(n)]
suits = ['S', 'H', 'C', 'D']
cards = ["%s %d" % (s, r) for s, r in itertools.product(suits, range(1, 14))]
answers = [c for c in cards if c not in a]
for card in answers:
print(card)
| 1 | 1,034,543,487,812 | null | 54 | 54 |
import sys
r=int(input())
print(r*r) | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
r = int(input())
print(r*r)
| 1 | 145,896,369,696,814 | null | 278 | 278 |
import numpy as np
e=input()
num=int(e)
print(num*2*np.pi) | from math import pi
def main():
S = int(input())
print(2 * pi * S)
if __name__ == "__main__":
main()
| 1 | 31,323,182,139,898 | null | 167 | 167 |
N = int(input())
def sum(n):
return (n + 1) * n // 2
print(sum(N) - sum(N // 3) * 3 - sum(N // 5) * 5 + sum(N // 15) * 15)
| n = int(input())
sum = 0
for num in range(1,n+1):
if num%3 !=0 and num%5 != 0:
sum += num
print(sum) | 1 | 34,927,904,960,372 | null | 173 | 173 |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
x1, y1, x2, y2 = map(float, sys.stdin.readline().split())
print(round(((x2-x1)**2 + (y2-y1)**2) ** 0.5, 6))
| x1,y1,x2,y2=map(float,input().split())
import math
s=math.sqrt((x1-x2)**2+(y1-y2)**2)
print(f'{s:.08f}')
| 1 | 162,423,197,400 | null | 29 | 29 |
a,b = input().split()
a=int(a);b=int(b)
if a>b:
s = 'a > b'
elif a<b:
s = 'a < b'
else:
s = 'a == b'
print(s) | #http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_3_A&lang=jp
#????????????
#????????????python???????????????????????????????????????push???pop?????????
#??????????????????????????°????????§??????????§£???????????\??£???
def rpn(formula):
stack = Stack()
for d in formula:
if d == "+":
stack.push(stack.pop() + stack.pop())
elif d == "-":
stack.push(-stack.pop() + stack.pop())
elif d == "*":
stack.push(stack.pop() * stack.pop())
else:
stack.push(int(d))
return stack.pop()
class Stack:
def __init__(self):
self.data = []
def push(self, d):
#print(self.data)
self.data.append(d)
def pop(self):
#print(self.data)
r = self.data[-1]
self.data = self.data[:-1]
return r
def main():
formula = input().split()
print(rpn(formula))
if __name__ == "__main__":
main() | 0 | null | 195,876,052,680 | 38 | 18 |
N, K, C = map(int, input().split())
S = input()
L = [0]*K
R = [0]*K
lpiv = 0
rpiv = N-1
for i in range(K):
while S[lpiv] == 'x':
lpiv += 1
while S[rpiv] == 'x':
rpiv -= 1
L[i] = lpiv
R[i] = rpiv
lpiv += C+1
rpiv -= C+1
ans = 0
for i in range(K):
if L[i]==R[K-i-1]:
print(L[i]+1)
| H=int(input())
W=int(input())
N=int(input())
if N%max(H,W)==0:
print(N//max(H,W))
else:
print(N//max(H,W)+1) | 0 | null | 64,943,399,324,372 | 182 | 236 |
import math
a = math.ceil(int(input())/2)
print(int(a-1)) | n = int(input())
count=0
for i in range(1,n//2+1):
j = n - i
if i != j:
count += 1
print(count) | 1 | 153,347,090,348,508 | null | 283 | 283 |
def II(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
N=II()
A=LI()
cnt=[0]*((10**6)+1)
for elem in A:
cnt[elem]+=1
unique=[]
for i in range((10**6)+1):
if cnt[i]==1:
unique.append(i)
cnt=[0]*((10**6)+1)
A=list(set(A))
for elem in A:
for m in range(elem*2,10**6+1,elem):
cnt[m]=1
ans=0
for i in unique:
if cnt[i]==0:
ans+=1
print(ans) | n = int(input())
a = list(map(int, input().split()))
a.sort()
m = a[-1]
c = [0] * (m + 1)
for ai in a:
for i in range(ai, m + 1, ai):
c[i] += 1
ans = 0
for ai in a:
if c[ai] == 1:
ans += c[ai]
print(ans) | 1 | 14,345,869,476,822 | null | 129 | 129 |
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
x = [0] * (N + 1)
y = [0] * (M + 1)
for i in range(N):
x[i + 1] = x[i] + A[i]
for i in range(M):
y[i + 1] = y[i] + B[i]
j = M
ans = 0
for i in range(N + 1):
if x[i] > K:
continue
while j >= 0 and x[i] + y[j] > K:
j -= 1
ans = max(ans, i + j)
print(ans)
|
def main():
a, b, c = map(int, input().split())
if 4*a*b < pow(c - (a + b), 2):
ans = 'Yes'
else:
ans = 'No'
if c - (a + b) <= 0:
ans = 'No'
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 31,085,323,549,052 | 117 | 197 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(input())
a = list(map(int, input().split()))
aa = [(num,i) for i,num in enumerate(a)]
aa.sort()
write(" ".join(map(str, [item[1]+1 for item in aa]))) | N = int(input())
sum = 0
for i in range(1, N + 1):
if not i % 3 == 0 and not i % 5 == 0:
sum += i
print(sum) | 0 | null | 107,981,497,886,940 | 299 | 173 |
import re
n = int(input())
text = input()
pattern = "ABC"
result = re.findall(pattern, text)
print(len(result)) | n = int(input())
m = n
primes = {}
for i in range(2, int(n**0.5+2)):
while m % i == 0:
m //= i
if i not in primes:
primes[i] = 1
else:
primes[i] += 1
if i > m:
break
if m != 1:
primes[m] = 1
cnt = 0
num = 0
flag = True
while flag == True:
num += 1
flag = False
for i in primes:
if 0 < primes[i] <= num*2:
cnt += 1
primes[i] = 0
elif primes[i] > num*2:
cnt += 1
flag = True
primes[i] -= num
print(cnt) | 0 | null | 58,223,599,096,702 | 245 | 136 |
from collections import deque
n, m, k = map(int, input().split())
#listを組むより早い
friends = [set() for _ in range(n)]
blocks = [set() for _ in range(n)]
for i in range(m):
a, b = map(int, input().split())
friends[a-1].add(b-1)
friends[b-1].add(a-1)
for i in range(k):
c, d = map(int, input().split())
blocks[c-1].add(d-1)
blocks[d-1].add(c-1)
q = deque()
ans = [0] * n
visited = [0] * n
for i in range(n):
if visited[i]:
continue
#集合を構築していく
group = {i}
visited[i] = 1
q.append(i)
while q:
k = q.popleft()
for j in friends[k]:
if not visited[j]:
q.append(j)
group.add(j)
visited[j] = 1
# できた集合内でとりあえず計算
for l in group:
ans[l] = len(group) - len(blocks[l] & group) - len(friends[l] & group) - 1
print(*ans)
#print(*ans,sep="\n") | class UnionFind():
def __init__(self,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)]
N,M,K=map(int,input().split())
uf=UnionFind(N+1)
friends={x:set() for x in range(1,N+1)}
blocks={x:set() for x in range(1,N+1)}
ans=[N-1]*(N+1)
for _ in range(M):
A,B=map(int,input().split())
friends[A].add(B)
friends[B].add(A)
uf.union(A,B)
for _ in range(K):
C,D=map(int,input().split())
if uf.find(C)==uf.find(D):
blocks[C].add(D)
blocks[D].add(C)
for i in range(1,N+1):
if uf.size(i)==-1:
print(0)
continue
print(abs(uf.size(i))-len(friends[i])-len(blocks[i])-1,end=' ') | 1 | 61,632,315,550,530 | null | 209 | 209 |
import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
def solve():
n = ini()
a = inl()
x = 0
for y in a:
x ^= y
b = [x ^ y for i, y in enumerate(a)]
return b
print(*solve())
| N = int(input())
A = list(map(int, input().split()))
x = 0
for a in A:
x ^= a
ans = []
for a in A:
ans.append(a ^ x)
print(" ".join(map(str, ans))) | 1 | 12,556,771,884,448 | null | 123 | 123 |
# -*- coding: utf-8 -*-
import sys
def main():
N,K = list(map(int, sys.stdin.readline().split()))
A_list = list(map(int, sys.stdin.readline().split()))
for i in range(K, len(A_list)):
if A_list[i] > A_list[i-K]:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| from sys import stdin, stdout
import math,sys,heapq
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
from os import path
import bisect as bi
def yes():print('YES')
def no():print('NO')
if (path.exists('input.txt')):
#------------------Sublime--------------------------------------#
sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
def I():return (int(input()))
def In():return(map(int,input().split()))
else:
#------------------PYPY FAst I/o--------------------------------#
def I():return (int(stdin.readline()))
def In():return(map(int,stdin.readline().split()))
def dict(a):
d={}
for x in a:
if d.get(x,-1)!=-1:
d[x]+=1
else:
d[x]=1
return d
def find_gt(a, x):
'Find leftmost value greater than x'
i = bi.bisect_right(a, x)
if i != len(a):
return i
else:
return -1
def main():
try:
n,k=In()
l=list(In())
ans=[]
t=1
last=1
for x in range(k,n):
if l[x-k]>=l[x]:
print('No')
else:
print('Yes')
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
#for _ in range(I()):main()
for _ in range(1):main()
| 1 | 7,098,120,860,118 | null | 102 | 102 |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#solve
def solve():
t1, t2 = LI()
a1, a2 = LI()
b1, b2 = LI()
if t1 * a1 + t2 * a2 == t1 * b1 + t2 * b2:
print("infinity")
return
if t1 * a1 > t1 * b1:
if t1 * a1 + t2 * a2 > t1 * b1 + t2 * b2:
print(0)
return
else:
x = t1 * (a1 - b1) / (-t1 * (a1 - b1) + t2 * (b2 - a2))
if x.is_integer():
print(2 * (t1 * (a1 - b1) // (-t1 * (a1 - b1) + t2 * (b2 - a2))))
else:
print(2 * (t1 * (a1 - b1) // (-t1 * (a1 - b1) + t2 * (b2 - a2))) + 1)
return
elif t1 * a1 < t1 * b1:
if t1 * a1 + t2 * a2 < t1 * b1 + t2 * b2:
print(0)
return
else:
x = t1 * (b1 - a1) / (-t1 * (b1 - a1) + t2 * (a2 - b2))
if x.is_integer():
print(2 * (t1 * (b1 - a1) // (-t1 * (b1 - a1) + t2 * (a2 - b2))))
else:
print(2 * (t1 * (b1 - a1) // (-t1 * (b1 - a1) + t2 * (a2 - b2))) + 1)
return
return
#main
if __name__ == '__main__':
solve()
|
def swap(A, i, j):
tmp = A[i]
A[i] = A[j]
A[j] = tmp
def bubble_sort(A, n):
count = 0
for i in range(0, n):
for j in range(n-1, i, -1):
if A[j] < A[j-1]:
swap(A, j, j-1)
count += 1
return A, count
n = int(input())
A = [int(x) for x in input().split()]
s_A, count = bubble_sort(A, n)
print(" ".join([str(x) for x in s_A]))
print(count)
| 0 | null | 65,625,493,765,108 | 269 | 14 |
N = int(input())
S = input()
T = ''
for i in S:
if (ord(i)-64+N)%26 != 0:
T += chr((ord(i)-64+N)%26 + 64)
else:
T += 'Z'
print(T) | # A - Takahashikun, The Strider
x = int(input())
i = 1
while True:
if 360 * i % x == 0:
print(360 * i // x)
break
else:
i += 1 | 0 | null | 73,546,812,896,878 | 271 | 125 |
input()
A = [i for i in input().split()]
A.reverse()
print(' '.join(A)) | n = int(input())
l = list(map(str, input().split()))
l.reverse()
print(' '.join(l)) | 1 | 968,965,023,180 | null | 53 | 53 |
MOD = 10 ** 9 + 7
INF = 10 ** 20
import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000000)
dy = (-1,0,1,0)
dx = (0,1,0,-1)
def main():
n = int(input())
a = list(map(int,input().split()))
if n%2 == 0:
ans1 = 0
ans2 = 0
for i in range(n):
if i%2 == 0:
ans1 += a[i]
else:
ans2 += a[i]
ans = max(ans1,ans2)
cuml = [0] * (n + 1)
cumr = [0] * (n + 1)
for i in range(n):
if i == 0:
cuml[i + 1] = a[i]
else:
cuml[i + 1] = cuml[i - 1] + a[i]
for i in range(n - 1,-1,-1):
if i == n - 1:
cumr[i] = a[i]
else:
cumr[i] = cumr[i + 2] + a[i]
for i in range(1,n - 2,2):
ans = max(ans,cuml[i] + cumr[i + 2])
else:
cuml = [0] * (n + 1)
cumr = [0] * (n + 1)
cumr2 = [0] * (n + 1)
for i in range(n):
if i == 0:
cuml[i + 1] = a[i]
else:
cuml[i + 1] = cuml[i - 1] + a[i]
for i in range(n - 1,-1,-1):
if i == n - 1:
cumr[i] = a[i]
cumr2[i] = a[i]
else:
cumr[i] = cumr[i + 2] + a[i]
if i%2 == 1:
if i == n - 2:
continue
if i == n - 4:
cumr2[i] = cumr2[i + 3] + a[i]
else:
cumr2[i] = max(cumr2[i + 2],cumr[i + 3]) + a[i]
cumr.append(0)
ans = -INF
for i in range(n):
ans = max(ans,cuml[i] + cumr[i + 2])
if i <= n - 6 and i%2 == 1:
ans = max(ans,cuml[i] + cumr2[i + 2])
if i <= n - 4 and i%2 == 1:
ans = max(ans,cuml[i] + cumr[i + 3])
print(ans)
if __name__ =='__main__':
main()
| from collections import defaultdict
n = int(input())
m = n//2
INF = 10**18
dp = [defaultdict(lambda: -INF)for _ in range(n+2)]
for i, a in enumerate(map(int, input().split()), 2):
for j in range(max(1, i//2-1), -(-i//2)+1):
if j-1 == 0:
dp[i-2][j-1] = 0
dp[i][j] = max(dp[i-1][j], dp[i-2][j-1]+a)
print(dp[n+1][m])
| 1 | 37,454,172,603,382 | null | 177 | 177 |
t, h = 0, 0
for i in range(int(input())):
tc, hc= input().split()
if tc > hc:
t += 3
elif tc < hc:
h += 3
else:
t += 1
h += 1
print('%d %d' % (t, h)) | h=t=0
for _ in range(int(input())):
a,b=input().split()
if a>b:t+=3
elif a<b:h+=3
else:t+=1;h+=1
print(t,h) | 1 | 1,994,842,804,198 | null | 67 | 67 |
n = int(input())
p = []
for i in range(n):
x,y = map(int,input().split())
p.append([x,y])
q = []
r = []
for i in range(n):
q.append(p[i][0]+p[i][1])
r.append(p[i][0]-p[i][1])
q.sort()
r.sort()
ans = max(abs(q[-1]-q[0]),abs(r[-1]-r[0]))
print(ans) | n = int(input())
z = list()
w = list()
for i in range(n):
x,y = list(map(int,input().split()))
z.append(x + y)
w.append(x - y)
ans = max(max(z) - min(z),max(w)-min(w))
print(ans) | 1 | 3,391,672,939,650 | null | 80 | 80 |
import sys
import numba as nb
import numpy as np
input = sys.stdin.readline
@nb.njit("i8(i8,i8[:],i8[:])", cache=True)
def binary_search(K, A, F):
"""Meguru type binary search"""
ng = -1
ok = A[-1] * F[0]
def is_ok(A, F, K, x):
count = 0
for a, f in zip(A, F):
count += max(0, a - x // f)
return count <= K
while (ok - ng) > 1:
mid = (ok + ng) // 2
if is_ok(A, F, K, mid):
ok = mid
else:
ng = mid
return ok
def main():
N, K = map(int, input().split())
A = np.array(input().split(), dtype=np.int64)
F = np.array(input().split(), dtype=np.int64)
A.sort()
F[::-1].sort()
ans = binary_search(K, A, F)
print(ans)
if __name__ == "__main__":
main()
| import sys
table = [0]*26
letters = "abcdefghijklmnopqrstuvwxyz"
input_str = sys.stdin.read()
for A in input_str:
ind = 0
for B in letters:
if A == B or A == B.upper():
table[ind] += 1
break
ind += 1
for i in range(len(letters)):
print("%s : %d"%(letters[i],table[i]))
| 0 | null | 83,152,429,638,372 | 290 | 63 |
x = list(map(int,input().split()))
print(x.index(0)+1)
| n = list(map(int,input().split()))
num = 0
for i,x in enumerate(n):
if (x == 0):
num = i+1
break;
print(num) | 1 | 13,411,711,442,590 | null | 126 | 126 |
def main():
K = int(input())
A,B = map(int,input().split())
for i in range(A,B+1):
if i%K == 0:
return('OK')
return('NG')
print(main())
| K=int(input())
A,B=map(int,input().split())
print("OK" if B//K*K >= A else "NG") | 1 | 26,444,216,257,370 | null | 158 | 158 |
n, k = map(int, input().split())
r, s, p = map(int, input().split())
t = input()
ans = 0
for i in range(n):
if((i - k) < 0):
if(t[i] == 'r'):ans += p
elif(t[i] == 's'):ans += r
else:ans += s
continue
else:
if(t[i-k] == t[i]):t = t[:i] + 'n' + t[i+1:]
else:
if(t[i] == 'r'):ans += p
elif(t[i] == 's'):ans += r
else:ans += s
print(ans)
| from math import *
H = int(input())
print(2**(int(log2(H))+1)-1) | 0 | null | 93,198,745,128,180 | 251 | 228 |
n=int(input())
r=list(map(int,input().split()))
t=0
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if r[i]==r[j] or r[j]==r[k] or r[i]==r[k]:continue
s=[r[i],r[j],r[k]]
s.sort()
if s[0]+s[1]>s[2]:
t+=1
print(t) | x1,y1,x2,y2 = [float(s) for s in input().split(' ')]
print(((x1-x2)**2 + (y1-y2)**2)**0.5) | 0 | null | 2,634,869,260,848 | 91 | 29 |
import itertools
n = int(input())
l = list(map(int,input().split()))
count = 0
for item in itertools.combinations(l, 3):
if len(set(item)) == 3:
if item[0] + item[1] > item[2] and item[1] + item[2] > item[0] and item[2] + item[0] > item[1]:
count += 1
print(count) | import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
n = k()
d=l()
for i in itertools.combinations(d,2):
ans += i[0]*i[1]
print(ans)
| 0 | null | 86,392,685,508,028 | 91 | 292 |
from collections import deque
N = int(input())
C = input()
r = deque()
lr = 0
for i in range(N):
if C[i] == 'R':
lr += 1
r.append(i)
ans = 0
for i in range(N):
if lr == 0:
break
if C[i] == 'W':
if i < r[-1]:
ans += 1
r.pop()
lr -= 1
else:
break
print(ans) | import sys
import functools
def minmaxsum(*t):
(x,y,z),e=t
if x > e:
x=e
if y < e:
y = e
z += e
return (x,y,z)
input()
m,x,s = functools.reduce(minmaxsum,map(int,input().split()),(1000000,-1000000,0\
))
print(m,x,s) | 0 | null | 3,487,650,174,308 | 98 | 48 |
def main():
n = int(input())
xym, xyM, x_ym, x_yM = 10**9, -10**9, 10**9, -10**9
for _ in range(n):
x, y = map(int, input().split())
xy, x_y = x+y, x-y
xym, xyM, x_ym, x_yM = min(xym, xy), max(xyM, xy), min(x_ym, x_y), max(x_yM, x_y)
print(max(xyM-xym, x_yM-x_ym))
if __name__ == "__main__":
main() | from collections import defaultdict
n, k = map(int, input().split())
m = defaultdict(int)
for _ in range(k):
input()
for x in input().split():
m[int(x)] += 1
result = 0
for i in range(1, n+1):
if m[i] == 0:
result += 1
print(result) | 0 | null | 13,967,205,969,922 | 80 | 154 |
def resolve():
s, w = map(int, input().split())
if s <= w:
print("unsafe")
else:
print("safe")
resolve()
| N = int(input())
A = tuple(map(int, input().split()))
S = [0]
for a in reversed(A):
S.append(S[-1] + a)
S.reverse()
lst = [0] * (N + 2)
lst[0] = 1
for i, a in enumerate(A):
if lst[i] < a:
print(-1)
break
lst[i + 1] = min((lst[i] - a) * 2, S[i + 1])
else:
print(sum(lst))
| 0 | null | 24,245,955,527,740 | 163 | 141 |
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def solve():
dp0 = [0] * (w + 1)
dp1 = [0] * (w + 1)
dp2 = [0] * (w + 1)
dp3 = [0] * (w + 1)
for i in range(h):
for j in range(w):
v = vv[i * w + j]
if v:
dp3[j] = max(dp3[j], dp2[j] + v)
dp2[j] = max(dp2[j], dp1[j] + v)
dp1[j] = max(dp1[j], dp0[j] + v)
dp3[j + 1] = max(dp3[j + 1], dp3[j])
dp2[j + 1] = max(dp2[j + 1], dp2[j])
dp1[j + 1] = max(dp1[j + 1], dp1[j])
dp0[j] = max(dp1[j], dp2[j], dp3[j])
print(dp0[-2])
h, w, k = MI()
vv = [0] * h * w
for _ in range(k):
i, j, v = MI()
i, j = i - 1, j - 1
vv[i * w + j] = v
solve()
| sec_input = int(input())
hour = sec_input // (60 * 60)
remain = sec_input % (60 * 60)
min = remain // 60
sec = remain % 60
print('%d:%d:%d' % (hour, min, sec)) | 0 | null | 2,994,410,061,936 | 94 | 37 |
from typing import List
class Info:
def __init__(self, arg_start, arg_end, arg_area):
self.start = arg_start
self.end = arg_end
self.area = arg_area
if __name__ == "__main__":
LOC: List[int] = []
POOL: List[Info] = []
all_symbols = input()
loc = 0
total_area = 0
for symbol in all_symbols:
if symbol == '\\':
LOC.append(loc)
elif symbol == '/':
if len(LOC) == 0:
continue
tmp_start = int(LOC.pop())
tmp_end = loc
tmp_area = tmp_end - tmp_start
total_area += tmp_area
while len(POOL) > 0:
# \ / : (tmp_start, tmp_end)
# \/ : (POOL[-1].start, POOL[-1].end)
if tmp_start < POOL[-1].start and POOL[-1].end < tmp_end:
tmp_area += POOL[-1].area
POOL.pop()
else:
break
POOL.append(Info(tmp_start, tmp_end, tmp_area))
else:
pass
loc += 1
print(f"{total_area}")
print(f"{len(POOL)}", end="")
while len(POOL) > 0:
print(f" {POOL[0].area}", end="")
POOL.pop(0)
print()
|
class Dice:
def __init__(self, faces):
self.t = faces[0]
self.s = faces[1]
self.e = faces[2]
self.w = faces[3]
self.n = faces[4]
self.b = faces[5]
def roll(self, drct):
t_ = self.t
s_ = self.s
e_ = self.e
w_ = self.w
n_ = self.n
b_ = self.b
if drct == 'S':
self.t = n_
self.s = t_
self.n = b_
self.b = s_
elif drct == 'N':
self.t = s_
self.s = b_
self.n = t_
self.b = n_
elif drct == 'E':
self.t = w_
self.e = t_
self.w = b_
self.b = e_
elif drct == 'W':
self.t = e_
self.e = b_
self.w = t_
self.b = w_
else:
return
def set_top(self, face):
if self.t == face:
return
elif self.s == face:
self.roll('N')
elif self.e == face:
self.roll('W')
elif self.w == face:
self.roll('E')
elif self.n == face:
self.roll('S')
else:
self.roll('N')
self.roll('N')
def get_right_face(self, f):
if self.s == f:
return self.e
elif self.e == f:
return self.n
elif self.w == f:
return self.s
else:
return self.w
faces = list(map(int, input().split()))
dice = Dice(faces)
n = int(input())
for i in range(n):
t, f = map(int, input().split())
dice.set_top(t)
print(dice.get_right_face(f))
| 0 | null | 158,542,426,250 | 21 | 34 |
# Triangle
from math import *
triangle = [int(i) for i in input().rstrip().split()]
sides = [triangle[0], triangle[1]]
a = sides[0]
b = sides[1]
angle = triangle[2]
triangleArea = 0.5 * a * b * sin(radians(angle))
print(triangleArea)
otherSideSquare = a ** 2 + b ** 2 - 2 * a * b * cos(radians(angle))
otherSide = otherSideSquare ** 0.5
circumference = a + b + otherSide
print(circumference)
height = triangleArea / 0.5 / a
print(height)
| import math
a, b, c = map(float, input().split())
h = b * math.sin(math.radians(c))
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)))
L = a + b + c
S = 1 / 2 * a * h
print(S)
print(L)
print(h)
| 1 | 173,303,832,900 | null | 30 | 30 |
n = int(input())
ans = 0
deno = 10
if n % 2 == 1:
pass
else:
while n//deno > 0:
ans += n//deno
deno *= 5
print(ans)
| n = int(input())
s = [None] * n
for i in range(n):
s[i] = input()
print(len(list(set(s)))) | 0 | null | 73,192,745,492,122 | 258 | 165 |
from collections import *
n=int(input())
l=[]
for i in range(n):
l.append(input())
c=Counter(l)
m=max(c.values())
d=[]
for i in c:
if(c[i]==m):
d.append(i)
d.sort()
for i in d:
print(i)
| from collections import Counter
n = int(input())
s = [input() for _ in range(n)]
cnt = Counter(s)
li = sorted(cnt.items(), key=lambda x: (-x[1], x[0]))
m = li[0][1]
for i in range(len(li)):
if li[i][1] < m:
break
print(li[i][0])
| 1 | 69,716,905,974,352 | null | 218 | 218 |
n,m,k = map(int,input().split())
import collections
par = []
for i in range(n):
par.append(i) #初期親
rank = [1 for i in range(n)] #初期ランク
flist = [[] for i in range(n)]
blist = [[] for i in range(n)]
cut = []
def find(n): #親検索andランク短縮
global cut
if par[n] == n:
for i in range(len(cut)):
par[cut[i]] = n
cut = []
return n
else:
cut.append(n)
find(par[n])
return find(par[n])
def shorten(n): # ランクを2にする
global cut
if par[n] == n:
for i in range(len(cut)):
par[cut[i]] = n
cut = []
else:
cut.append(n)
shorten(par[n])
def unite(a,b): #グループ併合
x = find(a)
y = find(b) #根っこ同士をくっつける
if x == y:
return #既に同一ユニオンなら何もしない
if rank[x] < rank[y]:
par[x] = y
elif rank[x] == rank[y]:
par[y] = x
rank[x] += 1
else:
par[y] = x
for i in range(m):
a,b = map(int,input().split())
a -= 1
b -= 1
flist[a].append(b)
flist[b].append(a)
unite(a,b)
for i in range(n):
shorten(i)
for i in range(k):
a,b = map(int,input().split())
a -= 1
b -= 1
if par[a] == par[b]:
blist[a].append(b)
blist[b].append(a)
c = collections.Counter(par)
for i in range(n):
ans = c[par[i]] -len(flist[i])-len(blist[i])-1
print(ans,end = ' ') | # -*- coding: utf-8 -*-
N = int(raw_input())
for i in range(N):
a, b, c = map(int, raw_input().split())
if a > c:
a, c = c, a
if b > c:
b, c = c, b
if a*a+b*b == c*c:
print "YES"
else:
print "NO" | 0 | null | 30,873,542,681,824 | 209 | 4 |
a,b = map(str, input().split())
a2 = a*int(b)
b2 = b*int(a)
print(a2) if a2 < b2 else print(b2)
| def main():
n = int(input())
for _ in range(n):
len_list = map(int, input().split())
check_tri(len_list)
def check_tri(len_list):
import itertools
import math
flag = False
for tmp in list(itertools.permutations(len_list)):
if (pow(tmp[0], 2) + pow(tmp[1], 2)) == pow(tmp[2], 2):
flag = True
break
if flag == True:
print('YES')
else:
print('NO')
if __name__ == '__main__':
main() | 0 | null | 42,432,040,931,008 | 232 | 4 |
import math
r = float(raw_input())
print '%.5f %.5f' % (r*r*math.pi, 2*r*math.pi) | import math
r = float(input())
s = '{:.6f}'.format(r * r * math.pi)
l = '{:.6f}'.format(2 * r * math.pi)
print(s,l)
| 1 | 646,199,190,710 | null | 46 | 46 |
while 1:
try:
print(len(str(sum(map(int,input().split())))))
except: break | # -*- utf-8 -*-
while True:
try:
inp = raw_input()
i = map(int, inp.split())
a = i[0]
b = i[1]
s = a + b
except:
break
ans = 0
while s >= 1:
s /= 10
ans += 1
print ans | 1 | 89,497,630 | null | 3 | 3 |
A = int(input())
B = int(input())
if A*B==2:
print(3)
elif A*B==3:
print(2)
else:
print(1) | def resolve():
k = int(input())
a, b = list(map(int, input().split()))
for i in range(a, b + 1):
if i % k == 0:
print('OK')
return
print('NG')
resolve() | 0 | null | 68,757,722,903,400 | 254 | 158 |
cnt = 0
for _ in range(int(input())):
a, b = map(int, input().split())
if a == b:
cnt += 1
else:
cnt = 0
if cnt > 2:
print("Yes")
quit()
print("No") | import sys
n = input()
a = []
flag = {}
for j in range(1, 14):
flag[('S',j)] = 0
flag[('H',j)] = 0
flag[('C',j)] = 0
flag[('D',j)] = 0
for i in range(n):
temp = map(str, raw_input().split())
a.append((temp[0],temp[1]))
#print a[i][0]
#print a[i][1]
card = ['S', 'H', 'C', 'D']
#print card
for egara in card:
for i in range(n):
if(a[i][0] == egara):
for j in range(1,14):
if(int(a[i][1]) == j):
flag[(egara, j)] = 1
for egara in card:
for j in range(1,14):
if(flag[(egara, j)] == 0):
sys.stdout.write(egara)
sys.stdout.write(' ')
sys.stdout.write(str(j))
print
exit(0) | 0 | null | 1,788,577,052,388 | 72 | 54 |
s=input().split()
a=int(s[0])
b=int(s[2])
c=s[1]
while (c!='?'):
if(c=='+'):print(a+b)
elif(c=='-'):print(a-b)
elif(c=='*'):print(a*b)
elif(c=='/'):print(int(a/b))
s=input().split()
a=int(s[0])
b=int(s[2])
c=s[1] | while True:
a,op,b=input().split(" ")
a,b=[int(i) for i in (a,b)]
if op=="+":
print(a+b)
elif op=="-":
print(a-b)
elif op=="*":
print(a*b)
elif op=="/":
print(int(a/b))
else:
break | 1 | 686,300,104,868 | null | 47 | 47 |
s,e,bai = [int(x) for x in input().split()]
count=0
for i in range(s,e+1):
if i%bai == 0:
count +=1
print(count) | #!/usr/bin/env python3
import math
import sys
import itertools
sys.setrecursionlimit(10**7)
MOD = 1000000007 # type: int
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1] # 階乗を求めるためのキャッシュ
self.invModulos = [0, 1] # n^-1のキャッシュ
self.invFactorial_ = [1, 1] # (n^-1)!のキャッシュ
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def choose_k_from_n(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
def pow(a,n,m):
if n == 1:
return a
elif n == 0 or a == 1:
return 1
else:
if n%2 == 0:
r = pow(a,n//2,m)
return r*r%m
else:
r = pow(a,n-1,m)
return a*r%m
def solve(N: int, K: int):
powDict = {}
def powd(a):
if a in powDict:
return powDict[a]
else:
powDict[a] = pow(a,N,MOD)
return powDict[a]
cDict = {}
sum = 0
for p in range(K,0,-1):
c = powd(K//p)
for i in range(2*p,K+1,p):
c = (c-cDict[i])%MOD
cDict[p]=c
sum = (sum + c*p)%MOD
print(sum)
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
solve(N, K)
if __name__ == '__main__':
main()
| 0 | null | 22,130,413,054,814 | 104 | 176 |
import math
(a, b, C) = [float(i) for i in input().split()]
S = 0.5 * a * b * math.sin(math.radians(C))
c = math.sqrt(a * a + b * b - 2 * a * b * math.cos(math.radians(C)))
print("%8f" %(S))
print("%8f" %(a + b + c))
print("%8f" %(S / a * 2)) | N,M=map(int,input().split())
class UnionFind():
def __init__(self,n): #n:要素数
self.n=n
self.parents = [-1]*n
#parents:各要素の親要素番号を格納
#要素が根である場合、-(そのグループの要素数)を格納する
def find(self,x): #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のグループとyのグループを併合する
x = self.find(x)
y = self.find(y)
if x==y:
return
if self.parents[x] > self.parents[y]: #|xのグループ|<|yのグループ|
x,y=y,x
self.parents[x] += self.parents[y]
self.parents[y] = x
#よりグループ数が多い方の根にもう一方のグループを接続
def size(self,x): #xの属するグループのサイズ
return -self.parents[self.find(x)]
uf=UnionFind(N)
for i in range(M):
a,b=map(lambda x:int(x)-1,input().split())
uf.union(a,b)
ans=0
for i in range(N):
if uf.size(i) > ans:
ans=uf.size(i)
print(ans) | 0 | null | 2,035,906,498,684 | 30 | 84 |
A = int(input())
B = int(input())
if A == 1 and B == 2:
print(3)
elif A == 2 and B == 1:
print(3)
elif A == 1 and B == 3:
print(2)
elif A == 3 and B == 1:
print(2)
elif A == 2 and A == 3:
print(1)
else:
print(1) | n = int(input())
arr = [int(x) for x in input().split()]
q = int(input())
dictA = {}
for i in arr:
if dictA.get(i): dictA[i] += 1
else: dictA[i] = 1
summ = sum(arr)
for i in range(q):
b, c = list(map(int, input().split()))
if dictA.get(b):
summ = summ - (dictA[b]*b) + (dictA[b]*c)
if dictA.get(c): dictA[c] += dictA[b]
else: dictA[c] = dictA[b]
del dictA[b]
print(summ)
| 0 | null | 61,465,516,564,518 | 254 | 122 |
N = int(input())
import sys
if N & 1:
print(0)
sys.exit()
ans = 0
N //= 2
while N != 0:
ans += N // 5
N //= 5
print(ans) | input_line = input().split()
a = int(input_line[0])
b = int(input_line[1])
if a > b:
symbol = ">"
elif a < b:
symbol = "<"
else:
symbol = "=="
print("a",symbol,"b") | 0 | null | 58,252,723,620,838 | 258 | 38 |
n = int(raw_input())
a = map(int, raw_input().split())
print "%d %d %d" % (min(a), max(a), sum(a)) | t1, t2 = [ int(v) for v in input().split() ]
a1, a2 = [ int(v) for v in input().split() ]
b1, b2 = [ int(v) for v in input().split() ]
if a1*t1 + a2*t2 == b1*t1 + b2*t2:
ans = -1
else:
if a1*t1 + a2*t2 < b1*t1 + b2*t2:
a1, b1 = b1, a1
a2, b2 = b2, a2
mind = a1*t1 - b1*t1
if mind > 0:
ans = 0
else:
lastd = a1*t1 + a2*t2 - b1*t1 - b2*t2
mind = abs(mind)
if mind % lastd == 0:
ans = 2 * (mind // lastd)
else:
ans = 2 * (mind // lastd) + 1
print(ans if ans != -1 else "infinity") | 0 | null | 66,009,158,300,992 | 48 | 269 |
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import itertools
import functools
import math
import sys
INF = float('inf')
def solve(K: int):
@functools.lru_cache(maxsize=K**3)
def gcd(a: int, b: int) -> int:
return math.gcd(a, b)
return sum([gcd(ab, c+1) for ab in [gcd(a+1, b+1) for a in range(K) for b in range(K)] for c in range(K)])
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
print(f'{solve(K)}')
if __name__ == '__main__':
main()
| import math
import itertools
k = int(input())
l = list(range(1,k+1))
y = list(itertools.combinations_with_replacement(l,3))
n = len(y)
t = 0
for i in range(n):
a = y[i][0]
b = y[i][1]
c = y[i][2]
d = math.gcd(math.gcd(a,b),c)
if a != b != c:
t += d * 6
elif a == b == c:
t += d
else:
t += d * 3
print(t) | 1 | 35,469,532,309,952 | null | 174 | 174 |
n,t = map(int,input().split())
l = []
for i in range(n):
a,b = map(int,input().split())
l.append([a,b])
l.sort(key=lambda x:x[0])
dp = [[0 for i in range(t)] for i in range(n+1)]
al = []
for i in range(n):
a,b = l[i]
for j in range(t):
if dp[i][j] == 0:
if j == 0:
if j + a < t:
dp[i+1][j+a] = max(dp[i][j+a],b)
else:
al.append(b)
else:
if j + a < t:
dp[i+1][j+a] = max(dp[i][j+a],dp[i][j]+b)
else:
al.append(dp[i][j]+b)
dp[i+1][j] = max(dp[i+1][j],dp[i][j])
if len(al) > 0:
print(max(max(dp[n]),max(al)))
else:
print(max(dp[n])) | while True:
a, op, b = input().split()
a = int(a)
b = int(b)
if op == '?':
break
if op == '+':
ans = a+b
elif op == '-':
ans = a-b
elif op == '*':
ans = a*b
else:
ans = a/b
print('%d' %(ans))
| 0 | null | 75,977,129,648,640 | 282 | 47 |
# -*-coding:utf-8-*-
def get_input():
while True:
try:
yield "".join(input())
except EOFError:
break
if __name__=="__main__":
array = list(get_input())
for i in range(len(array)):
temp = array[i].split()
a = int(temp[0])
b = int(temp[1])
ans = a + b
print(len(str(ans))) | def f(c):
"""
入力に対する勝ち手を出力
"""
if c=="r":
return "p"
elif c=="s":
return "r"
else:
return "s"
def main():
"""
まずは全て勝つ組み合わせを作って、合計ポイントを求める。
iを0からN-Kまで変化させ、T(i)=T(k+i)となる時、
T(k+i)をT(i)、T(i+2K)と異なる手に変更する。
※T(i)を変更すると、T(i)=T(i+k)=T(i+2K)=...=と連続した時に、
全て変更されてスコアが最大にならない。
T(k+i)は勝ちから"あいこまたは負け"に変化するので、合計ポイントから差っ引く。
"""
#input
N,K=map(int,input().strip().split())
R,S,P=map(int,input().strip().split())
T=list(input())
win_T=list(map(lambda x:f(x),T))
point={"r":R,"s":S,"p":P}
score=sum([point[win_T[n]] for n in range(N)])
for i in range(N-K):
l=["r","s","p"]
if win_T[i]==win_T[i+K]:
score-=point[win_T[i+K]]
l.remove(win_T[i])
if i<=N-2*K-1 and win_T[i]!=win_T[i+2*K]:
l.remove(win_T[i+2*K])
win_T[i+K]=l[0]
return score
if __name__=="__main__":
print(main()) | 0 | null | 53,106,525,013,828 | 3 | 251 |
import sys
import math
n = (int)(input())
money = 100000.0
for i in range(n):
money = math.ceil(money * 1.05 / 1000) * 1000
print((int)(money)) | import math
n = int(raw_input())
debt = 100000
for i in range(n):
debt = int(math.ceil(debt * 1.05 / 1000)) * 1000
print debt | 1 | 1,040,635,348 | null | 6 | 6 |
import sys; input = sys.stdin.readline
# n, m , k = map(int, input().split())
# matrix = [list(input().strip()) for _ in range(n)]
n = int(input())
lis = sorted(map(int, input().split()), reverse=True)
ans = lis[0]
i = 1
c = 1
while c<n-1:
if c < n-1: ans += lis[i]; c+=1
if c < n-1: ans += lis[i]; c+=1
i+=1
print(ans)
| n=int(input())
p=list(map(int,input().split()))
min_val=10**18
ans=0
for i in range(n):
if i==0:
min_val=p[i]
ans+=1
continue
if min_val>=p[i]:
min_val=p[i]
ans+=1
print(ans)
| 0 | null | 47,538,928,774,272 | 111 | 233 |
temp = int(input())
if temp >= 30:
print("Yes")
else:
print("No") | x = int(input())
if x >= 30:
print("Yes")
else:
print("No") | 1 | 5,798,886,852,002 | null | 95 | 95 |
a, b = map(int,input().split())
print(a*b if a < 10 and b < 10 and a > 0 and b > 0 else -1) | n,x,m=map(int,input().split())
def f(ai,m):
return (ai*ai)%m
if x==0:
print(0)
elif x==1:
print(n)
elif m==1:
print(0)
elif n<=m*2:
asum=x
ai=x
for i in range(1,n):
ai=f(ai,m)
asum+=ai
print(asum)
else:
chk=[-1]*m
asum00=[0]*m
ai,asum=x,0
for i in range(m):
if chk[ai]!=-1:
icnt0=chk[ai]
break
else:
chk[ai]=i
asum00[i]=asum
asum+=ai
ai=f(ai,m)
icnt=i
asum0=asum00[icnt0]
icntk=icnt-icnt0
n0=n-1-icnt0
nk=n0//icntk
nr=n0%icntk
asumk=asum-asum0
air,asumr=ai,0
for i in range(nr):
asumr+=air
air=f(air,m)
asumr+=air
ans=asum0+asumk*nk+asumr
print(ans)
| 0 | null | 80,805,284,324,700 | 286 | 75 |
# -*- coding:utf-8 -*-
def solve():
import sys
N = int(sys.stdin.readline())
dp = [None]*45
dp[0], dp[1] = 1, 1
def fib(n):
if dp[n] is not None:
return dp[n]
dp[n] = fib(n-1) + fib(n-2)
return dp[n]
print(fib(N))
if __name__ == "__main__":
solve()
| n = int(raw_input())
dp = {}
def fib(n):
if n in dp: return dp[n]
if n == 0:
dp[n] = 1
return 1
elif n == 1:
dp[n] = 1
return 1
else:
dp[n] = fib(n-1)+fib(n-2)
return dp[n]
print fib(n) | 1 | 1,771,340,160 | null | 7 | 7 |
import numpy as np
D = int(input())
c = np.array( list(map(int, input().split())) )
#
s = [[] for i in range(D)]
for i in range(D):
s[i] = np.array( list(map(int, input().split())) )
#
v = 0
cc = np.array( [0]*26 )
last = np.array( [-1]*26 )
for d in range(D):
cc += c
av = s[d] - sum( cc ) + cc
av2 = av + cc*min((D-d-1),13)
m = max(av2)
for t in range(26):
if av2[t] == m:
cc[t] = 0
v += av[t]
print(t+1)
break
#
#print( v )
| from numba import jit
@jit
def solve():
n, k = map(int,input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))
max_score = -10**10
for i in range(n):
count = 1
val = c[i]
next_i = p[i] -1
while next_i != i:
count += 1
val += c[next_i]
next_i = p[next_i] - 1
if val > 0:
loop_num = (k//count -1)
tmp_score = loop_num * val
max_score = max(tmp_score, max_score)
num = k%count+count
else:
tmp_score = 0
num = min(k, count)
next_i = i
for _ in range(num):
next_i = p[next_i] - 1
tmp_score += c[next_i]
max_score = max(tmp_score, max_score)
print(max_score)
solve() | 0 | null | 7,507,288,875,778 | 113 | 93 |
x, n = map(int, input().split())
p = list(map(int, input().split()))
i = 0
while True:
if x-i not in p:
print(x-i)
break
if x+i not in p:
print(x+i)
break
i += 1 | print(((1/3)*float(input("")))**3) | 0 | null | 30,623,924,938,528 | 128 | 191 |
N = int(input())
if N % 1000 == 0:
ans = 0
else:
ans = 1000 - (N % 1000)
print(ans) | i = int(input())
k = 1000
while k < i:
k += 1000
if k > i:
print(k - i)
elif k == i:
print(0) | 1 | 8,437,997,914,568 | null | 108 | 108 |
r = int(input())
pai = 3.1415
print(2*r*pai) | # -*- coding: utf-8 -*-
import sys
import fractions
def lcm(a,b):
return a / fractions.gcd(a,b) * b
for s in sys.stdin:
a,b = map(int,s.split())
gcd_ab = fractions.gcd(a,b)
lcm_ab = lcm(a,b)
print gcd_ab,lcm_ab | 0 | null | 15,775,720,020,762 | 167 | 5 |
n,t = map(int,input().split())
ab = [list(map(int,input().split())) for _ in range(n)]
ab.sort() # 食べるのが早い順にソート
# ナップザック問題に落とし込む
dp = [[0 for i in range(t+1)]for j in range(n+1)]
for i in range(n):
ti,vi = ab[i]
for j in range(t+1):
# 食べたほうがよい(t秒以内かつ満足度が上がるならば)
if j + ti <= t:
dp[i+1][j+ti] = max(dp[i+1][j+ti],dp[i][j]+vi)
# 食べなかった場合の最高値を更新
dp[i+1][j] = max(dp[i][j],dp[i+1][j])
ma = 0
for i in range(n):
# 最後にi番目の皿を食べることができる
ma = max(ma,dp[i][t-1]+ab[i][1])
print(ma) | n=int(input())
a=list(map(int,input().split()))
a.sort()
ans=0
x=[0]+[True]*10**6
for i in range(len(a)):
cnt=a[i]
if x[a[i]]==True and (i==0 or a[i]!=a[i-1]) and (i==(n-1) or a[i]!=a[i+1]):
ans+=1
while cnt<=10**6:
x[cnt]=False
cnt+=a[i]
elif x[a[i]]==True and ((i!=0 and a[i]==a[i-1]) or (i!=(n-1) and a[i]==a[i+1])):
while cnt<=10**6:
x[cnt]=False
cnt+=a[i]
print(ans)
| 0 | null | 82,852,268,945,718 | 282 | 129 |
H, N = map(int, input().split())
A = []
max_A = 0
for i in range(N):
A.append(tuple(map(int, input().split())))
max_A = max(max_A, A[i][0])
INF = 10**9
dp = [INF] * (2 * 10 ** 4 + 1)
dp[0] = 0
for i in range(2 * 10 ** 4):
for a, b in A:
if i + a <= 2 * 10 ** 4:
dp[i+a] = min(dp[i]+b, dp[i+a])
print(min(dp[H:])) | n = int(input())
f = 0
L = []
for i in range(n):
a,b = map(int, input().split())
L.append([a,b])
for i in range(2,n):
if(L[i-2][0] == L[i-2][1] and L[i-1][0] == L[i-1][1] and L[i][0] == L[i][1]):
f = 1
break
if(f):
print('Yes')
else:
print('No') | 0 | null | 42,036,487,021,240 | 229 | 72 |
n=int(input())
s=str(input())
print(s.count("ABC")) | import sys
def I(): return int(sys.stdin.readline().rstrip())
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
S = LS2()
ans = 0
for i in range(N-2):
if S[i] == 'A' and S[i+1] == 'B' and S[i+2] == 'C':
ans += 1
print(ans) | 1 | 99,201,562,679,548 | null | 245 | 245 |
N = int(input())
A = list(map(int,input().split()))
x = True
for i in range(N):
if A[i] % 2 != 0:
continue
if not (A[i]%3==0 or A[i]%5==0):
x = False
if x:
print("APPROVED")
else:
print("DENIED") | s=input()
t=input()
max_=0
for i in range(len(s)-len(t)+1):
c = 0
for j in range(len(t)):
if s[i+j] == t[j]:
c += 1
max_ = max(max_, c)
print(len(t)-max_)
| 0 | null | 36,262,525,330,592 | 217 | 82 |
from collections import deque
n = int(input())
adj = [list(map(int, input().split(' '))) for i in range(n)]
class Node:
def __init__(self, id, ck):
self.id = id
self.ck = ck
self.depth = -1
def __str__(self):
return '{} {}'.format(self.id, self.depth)
class Graph:
def __init__(self):
self.map = {}
def get(self, id):
return self.map[id]
def set(self, id, ck):
self.map[id] = Node(id, ck)
def bfs(self):
root = self.get(1)
root.depth = 0
queue = deque()
queue.append(root)
while(len(queue) > 0):
node = queue.popleft()
for id in node.ck:
target = self.get(id)
if target.depth != -1: continue
target.depth = node.depth + 1
queue.append(target)
def __str__(self):
return '\n'.join(map(str, [self.get(i + 1) for i in range(len(self.map))]))
graph = Graph()
for data in adj:
id = data[0]
ck = data[2:]
graph.set(id, ck)
graph.bfs()
print(graph)
| from itertools import accumulate
N=int(input())
d=[int(i) for i in input().split()]
hp=[]
for i in range(N):
for j in range(N):
if i>j:
hp.append(d[i]*d[j])
l=list(accumulate(hp))
print(l[-1]) | 0 | null | 83,977,621,462,072 | 9 | 292 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
def solve(p):
cur = p
cnt = 1
while cur > 0:
pop = f'{cur:b}'.count("1")
cur = cur % pop
cnt += 1
return cnt
n = int(readline())
s = input()
c = s.count("1")
cp = c + 1
cm = c - 1
fp = 0
fm = 0
for i, x in enumerate(s[::-1]):
if x == "1":
if cp <= n:
fp += pow(2, i, cp)
fp %= cp
if cm > 0:
fm += pow(2, i, cm)
fm %= cm
for i in range(n):
if s[i] == "0":
a = pow(2, n - (i + 1), cp)
cur = (fp + a) % cp
print(solve(cur))
else:
if cm > 0:
a = pow(2, n - (i + 1), cm)
cur = (fm - a) % cm
print(solve(cur))
else:
print(0)
if __name__ == '__main__':
main()
| h,n=map(int,input().split())
c=[list(map(int,input().split()))for _ in range(n)]
d=[0]*20002
for i in range(h):d[i]=min(d[i-a]+b for a,b in c)
print(d[h-1]) | 0 | null | 44,760,050,227,362 | 107 | 229 |
k=int(input())
line="ACL"*k
print(line) | from collections import defaultdict
MOD = 10**9+7
n = int(input())
A = list(map(int, input().split()))
def sieve(n):
n += 1
res = [i for i in range(n)]
for i in range(2, int(n**.5)+1):
if res[i] < i:
continue
for j in range(i**2, n, i):
if res[j] == j:
res[j] = i
return res
U = max(A)+1
min_factor = sieve(U)
def prime_factor(n):
res = defaultdict(lambda: 0)
while 1 < n:
res[min_factor[n]] += 1
n //= min_factor[n]
return res
pf = defaultdict(lambda: 0)
for a in A:
for p, q in prime_factor(a).items():
if pf[p] < q:
pf[p] = q
x = 1
for p, q in pf.items():
x *= pow(p, q, MOD)
x %= MOD
print(sum(x*pow(a, MOD-2, MOD) for a in A) % MOD) | 0 | null | 44,727,968,981,654 | 69 | 235 |
def main():
N = int(input())
comment = []
for i in range(1, N + 1):
A = int(input())
for j in range(1, A + 1):
c = [i]
c.extend(list(map(int, input().split())))
comment.append(c)
ans = 0
for i in range(1, 2**N):
flg = True
for h, t, c in comment:
#発言者が正直者か
if i & (1 << h - 1):
#発言が適切か
if ((i >> t - 1) & 0b1) ^ c:
flg = False
break
if flg:
tmp = 0
for j in range(N):
if i & (1 << j):
tmp += 1
ans = max(ans, tmp)
print(ans)
if __name__ == '__main__':
main() | from itertools import product
N = int(input())
A = [None] * N
lst = [[] for _ in range(N)]
for i in range(N):
A[i] = int(input())
lst[i] = [list(map(int, input().split())) for _ in range(A[i])]
bit_lst = list(product(range(2), repeat=N)) #N桁のビット
ans = 0
for bit in bit_lst:
f = True #このbitの証言が無意味になったらFalse
for a in range(N):
#1人ずつ順番に聞く : a人目の証言
if f:
for b in range(A[a]):
#b個目の証言
if bit[a] == 1:
#この人が正直者なとき
if lst[a][b][1] != bit[lst[a][b][0]-1]:
#正直者の証言と現実が食い違う
f = False
break
else:
#正直者ではないとき
break
if f:
ans = max(ans, sum(bit))
print(ans) | 1 | 121,369,511,730,282 | null | 262 | 262 |
flag = "go"
cnt = 0
while flag == "go":
cnt += 1
x = int(input())
if x == 0:
flag = "stop"
else:
print("Case " + str(cnt) + ": " + str(x))
| N = int(raw_input())
nums = []
for i in range(N):
nums.append(int(raw_input()))
m = -1000000000000000000000000
minvalue = nums[0]
for i in range(1, len(nums)):
minvalue = min(minvalue, nums[i-1])
value = nums[i] - minvalue
if m <= value:
m = value
print(m) | 0 | null | 256,105,436,890 | 42 | 13 |
import sys
from collections import defaultdict, deque, Counter
import math
# import copy
from bisect import bisect_left, bisect_right
import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def nck(n, k, kaijyo):
return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD
def npk(n, k, kaijyo):
if k == 0 or k == n:
return n % MOD
return (kaijyo[n] * divide(kaijyo[n-k])) % MOD
def kaijyo(n):
ret = [1]
for i in range(1, n + 1):
ret.append((ret[-1] * i)% MOD)
return ret
def solve():
n = getN()
nums = getList()
keta = [[0, 0] for i in range(62)]
for num in nums:
tmp = num
for i in range(62):
if tmp % 2 == 1:
keta[i][1] += 1
else:
keta[i][0] += 1
tmp //= 2
ans = 0
dig = 0
for k1, k2 in keta:
ans += ((k1 * k2) * (2**dig)) % MOD
dig += 1
print(ans % MOD)
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve() | import numpy as np
N, T = map(int, input().split())
data = []
for i in range(N):
a, b = map(int, input().split())
data.append((a,b))
data.sort()
data = np.array(data)
dp = np.zeros(T)
ans = 0
for a, b in data:
ans = max(ans,dp[-1]+b)
if a< T:
newtable = dp[:T-a] + b
dp[a:] = np.maximum(dp[a:], newtable)
print(int(ans)) | 0 | null | 137,514,320,096,164 | 263 | 282 |
# coding=utf-8
def main():
n = input()
s = ''
for i in range(1, n + 1):
x = i
if x % 3 == 0:
s += ' ' + str(i)
continue
while x:
if x % 10 == 3:
s += ' ' + str(i)
break
x /= 10
print s
if __name__ == '__main__':
main() | n=int(input())
x=0
y=1
if n==0 or n==1:
print(1)
else:
for i in range(n):
x,y=y,x+y
i+=1
print(y)
| 0 | null | 461,683,458,766 | 52 | 7 |
a=map(int, raw_input().split())
if a[0]<a[1]<a[2]:
print("Yes")
else :
print("No") | MOD = 10 ** 9 + 7
N, K = map(int, input().split())
# cnt(n): gcd = n となる数列の個数
cnt = [0] * (K + 1)
# A1,...,ANのすべてがxの倍数である数列の個数 = floor(k/x)^N個
for n in range(1, K + 1):
cnt[n] = pow(K // n, N, MOD)
res = 0
for k in range(K, 0, -1):
p = 2
while p * k <= K:
cnt[k] -= cnt[p * k]
cnt[k] %= MOD
p += 1
res += cnt[k] * k
res %= MOD
print(res)
| 0 | null | 18,487,474,332,142 | 39 | 176 |
def column_check(grp, grp_count, choco, h, j, k):
""" 0:成功（更新も反映） 1:失敗（区切った結果を返す） 2:不可能 """
# この行のグループ毎のカウント
curr_count = [0] * len(grp_count)
# 数える
for i in range(h):
if choco[i][j] == '0':
continue
curr_count[grp[i]] += 1
# この行だけでk越えてたら現在の横の切り方では不可能
for cc in curr_count:
if cc > k:
return 2
# ここまでの行と合わせてkを越えないかチェック
for i, cc in enumerate(curr_count):
grp_count[i] += cc
# 越えてたら、grp_countを現在の行に上書き
if grp_count[i] > k:
grp_count[:] = curr_count
return 1
return 0
def solve(h, w, k, choco):
ans = 10 ** 9
grp = [0] * h
for bit in range(1 << (h - 1)):
g = 0
for i in range(h):
grp[i] = g
if (bit >> i) & 1:
g += 1
grp_count = [0] * (g + 1)
tmp = 0
possible = True
for j in range(w):
result = column_check(grp, grp_count, choco, h, j, k)
if result == 2:
possible = False
break
if result == 1:
tmp += 1
if not possible:
continue
ans = min(ans, tmp + bin(bit).count('1'))
return ans
h, w, k = map(int, input().split())
choco = [input() for _ in range(h)]
print(solve(h, w, k, choco))
| N = int(input())
S = input()
revALPH = "".join(list(reversed("ABCDEFGHIJKLMNOPQRSTUVWXYZ")))
A = ""
for s in S:
pos = revALPH.find(s)
A += revALPH[pos - N]
print(A) | 0 | null | 91,601,991,348,630 | 193 | 271 |
import sys
from copy import deepcopy
def main():
INF = 10**18
input = sys.stdin.readline
N, M, L = [int(x) for x in input().split()]
d = [set() for _ in range(N+1)]
ds = [[INF] * (N+1) for _ in range(N+1)]
bs = [[INF] * (N+1) for _ in range(N+1)]
for _ in range(M):
A, B, C = [int(x) for x in input().split()]
A, B = sorted([A, B])
d[A].add(B)
if L >= C:
ds[A][B] = C
nes = set()
for k in range(1, N+1):
for i in range(1, N+1):
for j in range(i+1, N+1):
ds[i][j] = min(ds[i][j], ds[min(i, k)][max(i, k)] + ds[min(k, j)][max(k, j)])
if ds[i][j] <= L:
bs[i][j] = 1
for k in range(1, N+1):
for i in range(1, N+1):
for j in range(i+1, N+1):
bs[i][j] = min(bs[i][j], bs[min(i, k)][max(i, k)] + bs[min(k, j)][max(k, j)])
Q, = [int(x) for x in input().split()]
for _ in range(Q):
s, t = sorted(int(x) for x in input().split())
print(bs[s][t]-1 if bs[s][t] < INF else -1)
if __name__ == '__main__':
main()
| n=int(input())
a=[int(i) for i in input().split()]
a.sort()
prod=1
for i in a:
prod*=i
if prod>10**18:
break
if prod>10**18:
print(-1)
else:
print(prod)
| 0 | null | 95,220,434,790,806 | 295 | 134 |
s=input()
num=len(s)
print("x"*num) | l = len(input())
print('x'*l) | 1 | 73,073,062,308,610 | null | 221 | 221 |
def main():
N = int(input())
G = [[] for _ in range(N)]
edge = {}
edge_order = [0]*(N-1)
for i in range(N-1):
a, b = (int(i)-1 for i in input().split())
G[a].append(b)
G[b].append(a)
edge[a*N + b] = -1 # 辺(a,b)の色
edge_order[i] = a*N + b
# 辺彩色
# 最大次数だけ色があればよさそう？
# BFSで塗っていく
# ある辺を塗るときに必要なのは，親の辺の色と，同じ親の頂点を持つ
# 辺のうち彩色済みの色（陽に持たなくてよい）
max_deg = max(len(G[i]) for i in range(N))
from collections import deque
def bfs(s):
que = deque([])
par = [-1]*N
par_color = [-1]*N
c = 0
que.append(s)
while que:
pos = que.popleft()
for v in G[pos]:
if par[pos] == v:
continue
if par_color[pos] == c:
c += 1
if c == max_deg:
c = 0
if pos < v:
edge[pos * N + v] = c
else:
edge[v * N + pos] = c
par[v] = pos
par_color[v] = c
que.append(v)
c += 1
if c == max_deg:
c = 0
bfs(0)
print(max_deg)
for i in range(N-1):
print(edge[edge_order[i]] + 1)
if __name__ == '__main__':
main()
| n, m = input().split()
a = list(map(int, input().split()))
b = []
s = 0
for i in a:
s += i
for i in a:
if float(i) >= float(int(s)/(4*int(m))):
b.append(i)
if len(b) == int(m):
break
if len(b) == int(m):
print("Yes")
else:
print("No") | 0 | null | 87,312,101,735,222 | 272 | 179 |
import sys
input = sys.stdin.readline
T = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = (a[0] - b[0]) * T[0]
q = (a[1] - b[1]) * T[1]
if p > 0:
p *= -1
q *= -1
if p + q < 0:
print(0)
elif p + q > 0:
print(-p // (p + q) * 2 + ((-p % (p + q)) > 0))
else:
print("infinity") | n, m = map(int, input().split())
N = [0]*n
t = [0]*n
if n>1:
N[0]=1
f = 0
for i in range(m):
s, c = map(int, input().split())
if t[s-1]!=0 and N[s-1]!=c:
f = 1
t[s-1] = 1
N[s-1] = c
if n!=1 and N[0]==0:
print(-1)
elif f==1:
print(-1)
else:
for i in range(n):
print(N[i],end="") | 0 | null | 96,146,445,186,440 | 269 | 208 |
N = int(input())
if N % 1000 == 0:
ans = 0
else:
ans = 1000 - (N % 1000)
print(ans) | import sys
def input(): return sys.stdin.readline().rstrip()
N = int(input())
num = (N + 1000 - 1 )// 1000
print(num * 1000 - N) | 1 | 8,405,040,588,950 | null | 108 | 108 |
import math
while True:
N = int(input())
if N == 0:
break
S = list(map(int, input().split()))
S2 = [x ** 2 for x in S]
V = sum(S2)/N - (sum(S)/N) ** 2
print(math.sqrt(V)) | import math
while True:
n = int(input())
if n == 0: break
d = list(map(int, input().strip().split()))
m = sum(d) / n
print(math.sqrt(sum((x - m)**2 for x in d) / n)) | 1 | 191,981,469,792 | null | 31 | 31 |
n = int(raw_input())
a = [int(x) for x in raw_input().split()]
q = int(raw_input())
op = []
for _ in xrange(q):
v = raw_input().split()
op.append([int(x) for x in v])
d = {}
total = 0
for v in a:
d[v] = d.get(v, 0) + 1
total += v
for src, dest in op:
c = d.pop(src, 0)
d[dest] = d.get(dest, 0) + c
total += c * (dest - src)
print total | n = int(input())
A = list(map(int, input().split()))
q = int(input())
S = []
for _ in range(q):
x, y = map(int, input().split())
S.append((x, y))
sum = sum(A)
# print(sum)
R = [0 for _ in range(10**5+1)]
for a in A:
R[a-1] += 1
for (x,y) in S:
sum += (y-x)*R[x-1]
R[y-1] += R[x-1]
R[x-1] = 0
print(sum) | 1 | 12,179,108,100,834 | null | 122 | 122 |
# -*- coding: utf-8 -*-
import math
def main():
N = int(input())
if N % 1.08 == 0:
print(N/1.08)
else:
x = math.ceil(N/1.08)
if x < (N+1)/1.08:
print(x)
else:
print(':(')
return
if __name__ == '__main__':
main() | N = int(input())
a = int(N / 1.08) # min
b = int((N + 1) / 1.08) # max
ans = ':('
for i in range(a, b + 1):
if int(i * 1.08) == N:
ans = i
break
print(ans) | 1 | 125,853,015,314,950 | null | 265 | 265 |
from collections import deque
d = deque()
n = int(input())
for i in range(n):
s = input()
if s == "deleteFirst":
d.popleft()
elif s == "deleteLast":
d.pop()
elif s[:6] == "insert":
d.appendleft(int(s[7:]))
else:
delkey = int(s[7:])
if delkey in d:
d.remove(delkey)
print(" ".join(map(str,d)))
| import sys
n = int(sys.stdin.readline())
lines = sys.stdin.readlines()
#n = int(input())
#import collections
#dll = collections.deque()
class Node:
def __init__(self,v):
self.val = v
self.prev = None
self.next = None
class DLL():
def __init__(self):
self.tail = Node(None)
self.tail.next = self.tail
self.tail.prev = self.tail
def insert(self,x):
n = Node(x)
pre = self.tail.next
n.next = pre
n.prev = self.tail
pre.prev = n
self.tail.next = n
def delete(self,x):
node = self.tail.next
while node != self.tail:
if node.val == x:
p = node.prev
n = node.next
p.next = n
n.prev = p
return
node = node.next
def deleteFirst(self):
pre = self.tail.next
if pre == self.tail:
return
node = self.tail.next
p = node.prev
n = node.next
p.next = n
n.prev = p
def deleteLast(self):
if self.tail.next == self.tail:
return
node = self.tail.prev
p = node.prev
n = node.next
p.next = n
n.prev = p
def inspect(self):
node = self.tail.next
ret = []
while node != self.tail:
ret.append(str(node.val))
node = node.next
print(" ".join(ret))
dll=DLL()
for i in range(n):
q = lines[i]
if q[0] == "i":
dll.insert(int(q.split()[1]))
elif q[6] == " ":
dll.delete(int(q.split()[1]))
elif q[6] == "L":
dll.deleteLast()
elif q[6] == "F":
dll.deleteFirst()
dll.inspect()
#print(" ".join(map(str,dll)))
| 1 | 50,117,372,408 | null | 20 | 20 |
import math
import itertools
n = int(input())
al = [0] * n
bl = [0] * n
for i in range(n):
al[i], bl[i] = map(int, input().split())
bunbo = math.factorial(n)
ans = 0
for p in itertools.permutations(list(range(n))):
for i in range(n-1):
ans += ((al[p[i+1]]-al[p[i]])**2+(bl[p[i+1]]-bl[p[i]])**2)**0.5
print(ans/bunbo)
| from itertools import permutations
import math
N = int(input())
l = [list(map(int, input().split())) for i in range(N)]
waru = 1
for i in range(N):
waru*= i+1
a = [i+1 for i in range(N)]
c = 0
su = 0
for i in permutations(a,N):
li = list(i)
for j in range(len(li)-1):
start = l[li[j]-1]
g = l[li[j+1]-1]
su += math.sqrt((start[0]-g[0]) ** 2 + (start[1]-g[1]) ** 2)
print(su/waru) | 1 | 148,255,660,482,390 | null | 280 | 280 |
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readlines
infty = 2 ** 20
lines = input()
n, m = list(map(int, lines[0].split()))
coin = list(map(int, lines[1].split()))
T = [[0] * (n+1) for i in range(m+1)]
#0行目の初期化
for i in range(1, n+1):
T[0][i] = infty
#0列目の初期化
for i in range(m+1):
T[i][0] = 0
#1行目の初期化
for i in range(1, n+1):
T[1][i] = i
cnt = 0
for i in range(1, m+1):
if coin[i-1] > n:
continue
else:
cnt += 1
for j in range(1, n+1):
if j < coin[i-1]:
T[i][j] = T[i-1][j]
else:
a = T[i-1][j] ; b = T[i][j-coin[i-1]]+1
if a < b:
T[i][j] = a
else:
T[i][j] = b
print(T[cnt][n])
| n, m = map(int, input().split())
c = list(map(int, input().split()))
c.sort() # sortしなくてもこのアルゴリズムは有効
dp = [50001 for i in range(n + 1)]
dp[0] = 0
for i in c:
for j in range(i, n + 1):
dp[j] = min(dp[j], dp[j - i] + 1)
print(dp[n])
| 1 | 142,585,732,732 | null | 28 | 28 |
def main():
n = int(input())
d_lst = list(map(int, input().split()))
ans = 0
for i in range(n - 1):
for j in range(i + 1, n):
ans += d_lst[i] * d_lst[j]
print(ans)
if __name__ == "__main__":
main()
| # 問題：https://atcoder.jp/contests/abc143/tasks/abc143_b
n = int(input())
d = list(map(int, input().strip().split()))
res = 0
for i in range(1, n):
for j in range(i):
res += d[i] * d[j]
print(res)
| 1 | 168,020,831,350,788 | null | 292 | 292 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.