code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
H, W, M = map(int, input().split())
R = [0]*H #各行にある爆弾の個数
C = [0]*W #各列にある爆弾の個数
bombs = []
for _ in range(M):
h, w = map(lambda x: int(x)-1, input().split())
R[h] += 1
C[w] += 1
bombs.append((h, w))
R_max = max(R)
C_max = max(C)
### Rが最大かつCが最大な座標であって、
# そこに爆弾がない場合があれば
# 答えがR_max+C_max
# なければR_max+C_max-1
count = 0 # 爆弾がある座標であって、Rが最大かつCが最大の組の個数
for bx, by in bombs:
if R[bx] == R_max and C[by] == C_max:
count += 1
count_R = R.count(R_max)
count_C = C.count(C_max)
if count >= count_R*count_C:
ans = R_max + C_max - 1
else:
ans = R_max + C_max
print(ans) | import sys
buildings = [[[0 for i in xrange(10)] for j in xrange(3)] for k in xrange(4)]
n = input()
for i in xrange(n):
b, f, r, v = map(int, raw_input().split())
buildings[b-1][f-1][r-1] += v
for i in xrange(4):
if i != 0:
print "####################"
for j in xrange(3):
for k in xrange(10):
sys.stdout.write(" "+str(buildings[i][j][k]))
print | 0 | null | 2,946,252,028,892 | 89 | 55 |
A, B = map(int,input().split())
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
def lcm(a,b):
return a*b//gcd(a,b)
print(lcm(A,B))
| def gcd(a, b):
return b if a % b == 0 else gcd(b, a % b)
def lcm(a, b):
return a // gcd(a, b) * b
a, b = map(int, input().split())
print(lcm(a, b))
| 1 | 113,468,002,971,850 | null | 256 | 256 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
for _ in range(K):
B = [0]*(N+1)
for i in range(N):
l = max(0, i-A[i])
r = min(N-1, i+A[i])
B[l] += 1
B[r+1] -= 1
for i in range(N):
B[i+1] += B[i]
A = B[:N]
if all([x == N for x in A]):
break
print(*A) | N,K=map(int,input().split())
A=list(map(int,input().split()))
imos=[0 for i in range(N+1)]
zero=[0 for i in range(N+1)]
ANS=[str(N)]*N
if K>=40:
ans=" ".join(ANS)
print(ans)
else:
for t in range(K):
for i in range(N):
l=max(0,i-A[i])
r=min(N,i+A[i]+1)
imos[l]+=1
imos[r]-=1
for i in range(0,N):
imos[i+1]+=imos[i]
A[i]=imos[i]
imos=[0 for i in range(N+1)]
for i in range(N):
A[i]=str(A[i])
ans=" ".join(A)
print(ans) | 1 | 15,477,794,339,080 | null | 132 | 132 |
x = int(input())
if x <= 599:
print(8,"\n")
elif x <= 799:
print(7,"\n")
elif x <= 999:
print(6,"\n")
elif x <= 1199:
print(5,"\n")
elif x <= 1399:
print(4,"\n")
elif x <= 1599:
print(3,"\n")
elif x <= 1799:
print(2,"\n")
elif x <= 1999:
print(1,"\n") | S=input()
Week=['SUN','MON','TUE','WED','THU','FRI','SAT']
for i in range(7):
if S==Week[i]:
today=i
print(7-today) | 0 | null | 69,506,784,181,316 | 100 | 270 |
# A - Station and Bus
# https://atcoder.jp/contests/abc158/tasks/abc158_a
s = input()
if len(set(s)) == 2:
print('Yes')
else:
print('No')
| import sys
sys.setrecursionlimit(10000000)
n,x,y=map(int,input().split())
x-=1
y-=1
res=[0]*n
for i in range(n):
for j in range(i+1,n):
m = min(j-i, abs(i-x)+abs(j-y)+1, abs(i-y)+abs(j-x)+1)
res[m]+=1
for i in range(1,n):
print(res[i]) | 0 | null | 49,676,987,171,460 | 201 | 187 |
S = list(input())
a,b=S.pop(),S.pop()
c,d=S.pop(),S.pop()
if a==b and c==d:
print("Yes")
else:
print("No") | S = input()
if S[0]!=S[1] and S[2]==S[3] and S[4]==S[5]:
print('Yes')
else:
print('No') | 1 | 42,181,837,779,410 | null | 184 | 184 |
def main():
n = int(input())
s_set = set()
for i in range(n):
order = input().split()
if order[0] == "insert":
s_set.add(order[1])
else:
if order[1] in s_set:
print("yes")
else:
print("no")
if __name__ == '__main__':
main()
| n = int(input())
lr1, lr2 = [], []
res = 0
for _ in range(n):
s = input()
m = len(s)
l, r = 0, 0
tmp = 0
for i in range(m):
if s[i] == ')':
tmp += 1
else:
tmp -= 1
l = max(l, tmp)
tmp = 0
for i in range(m):
if s[m-1-i] == '(':
tmp += 1
else:
tmp -= 1
r = max(r, tmp)
res += r - l
if r - l >= 0:
lr1.append((l, r))
else:
lr2.append((l, r))
if res != 0:
print('No')
exit()
lr1.sort(key=lambda x: x[0])
lr2.sort(key=lambda x: x[1])
flg1, flg2 = True, True
n1, n2 = len(lr1), len(lr2)
tmp = 0
for i in range(n1):
l, r = lr1[i]
tmp -= l
if tmp < 0:
flg1 = False
tmp += r
tmp = 0
for i in range(n2):
l, r = lr2[i]
tmp -= r
if tmp < 0:
flg2 = False
tmp += l
if flg1 and flg2:
print('Yes')
else:
print('No')
| 0 | null | 11,931,302,079,412 | 23 | 152 |
table = [[[ 0 for i in range(10)] for j in range(3)] for k in range(4)]
n = int(input())
i = 0
while i < n:
b,f,r,v = (int(x) for x in input().split())
table[b-1][f-1][r-1] += v
i += 1
for i,elem_i in enumerate(table): # building
for j,elem_j in enumerate(elem_i): # floor
for k, elem_k in enumerate(elem_j): # room
print (" " + str(elem_k), end='')
print ("")
if i != 3:
print ("####################")
| a_1= [[0 for i in range(10)] for j in range(3)]
a_2= [[0 for i in range(10)] for j in range(3)]
a_3= [[0 for i in range(10)] for j in range(3)]
a_4= [[0 for i in range(10)] for j in range(3)]
def print_ninzu(a):
print("",end=" ")
print(" ".join(map(str,a[0])))
print("",end=" ")
print(" ".join(map(str,a[1])))
print("",end=" ")
print(" ".join(map(str,a[2])))
n = int(input())
for i in range(n):
com = list(map(int,input().split()))
if com[0] == 1:
a_1[com[1]-1][com[2]-1] += com[3]
if com[0] == 2:
a_2[com[1]-1][com[2]-1] += com[3]
if com[0] == 3:
a_3[com[1]-1][com[2]-1] += com[3]
if com[0] == 4:
a_4[com[1]-1][com[2]-1] += com[3]
print_ninzu(a_1)
print("####################")
print_ninzu(a_2)
print("####################")
print_ninzu(a_3)
print("####################")
print_ninzu(a_4) | 1 | 1,115,124,107,400 | null | 55 | 55 |
k=int(input())
a=7
cnt=1
while cnt<=k+2:
if a%k==0:
print(cnt)
flag=True
break
else:
flag=False
cnt+=1
a=(10*a+7)%k
if not flag:
print(-1)
| from math import *
PI = 3.1415926535898
while True:
try:
t = input()
ans = ""
ans += str(t/(60*60))
t %= 60*60
ans += ":"
ans += str(t/60)
t %= 60
ans += ":"
ans += str(t)
print ans
except EOFError:
break | 0 | null | 3,180,857,916,862 | 97 | 37 |
import sys
input = sys.stdin.readline
def main():
ans = 10**5 * 2
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = sorted(a)[0] + sorted(b)[0]
for i in range(M):
x, y, c = map(int, input().split())
cost = a[x-1] + b[y-1] - c
ans = min(ans, cost)
print(ans)
if __name__ == '__main__':
main() | import math
def isPrime(n):
for i in range(2, int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
N = int(input())
nums = [int(input()) for i in range(N)]
print(sum([isPrime(n) for n in nums])) | 0 | null | 27,161,982,564,848 | 200 | 12 |
def main():
n, m, l = tuple(map(int, input().split()))
matA = [[0 for j in range(m)] for i in range(n)]
matB = [[0 for k in range(l)] for j in range(m)]
matC = [[0 for k in range(l)] for i in range(n)]
for i in range(n):
tmp = list(map(int, input().split()))
for j in range(m):
matA[i][j] = tmp[j]
for j in range(m):
tmp = list(map(int, input().split()))
for k in range(l):
matB[j][k] = tmp[k]
for i in range(n):
for k in range(l):
for j in range(m):
matC[i][k] += matA[i][j] * matB[j][k]
for i in range(n):
for k in range(l):
if k == l-1:
print(matC[i][k])
else:
print(matC[i][k], end=' ')
if __name__ == '__main__':
main()
| n = int(input()) / 2 + 0.01
print(int(round(n)))
| 0 | null | 30,175,083,888,512 | 60 | 206 |
import sys
readline = sys.stdin.readline
li = []
for i, s in enumerate(readline().strip()):
if s == "\\":
li.append([i, 0])
elif s == "/":
if li:
if li[-1][1] == 0:
li[-1][1] = i - li[-1][0]
else:
for j in range(len(li) - 1, -1, -1):
if li[j][1] == 0:
li = li[:j] + [[li[j][0], sum(tuple(zip(*li[j + 1:]))[1]) + i - li[j][0]]]
break
ans = []
for a in li:
if a[1] != 0:
ans.append(a[1])
print(sum(ans))
print(len(ans), *ans)
| # -*- coding: utf-8 -*-
"""
stackの応用(水たまりの面積)
"""
from collections import deque
S = list(input())
# 総合面積
ans = 0
# 総合面積用スタック(直近の\の位置)
stack1 = deque()
# 個別用スタック(その水たまりを開始する\の位置, その時点での面積)
stack2 = deque()
for i in range(len(S)):
if S[i] == '\\':
stack1.append(i)
# 一番最近いれた\を取り出せば、今回の/と対になる(同じ高さ)
elif S[i] == '/' and stack1:
# 両者の距離がその高さでの面積になる
# (\/が三角形な分-1なのが半開区間だからちょうど合う)
j = stack1.pop()
ans += i - j
# 各水たまりのマージ作業
# stack2から、今回の合併候補を抽出
# (条件：水たまりの開始位置が今回対になってる\より右側にある)
pond = i - j
while stack2 and stack2[-1][0] >= j:
pond += stack2.pop()[1]
# マージした水たまりの情報を詰める
stack2.append([j, pond])
print(ans)
# リスト内包とアンパックできれいにまとまった
print(len(stack2), *[pond for j, pond in stack2])
| 1 | 61,977,640,338 | null | 21 | 21 |
N,M=map(int,input().split())
par=[i for i in range(N)]
size=[1 for i in range(N)]
def find(x):
if par[x]==x:
return x
else:
par[x]=find(par[x])
return par[x]
def union(a,b):
x=find(a)
y=find(b)
if x!=y:
if size[x]<size[y]:
par[x]=par[y]
size[y]+=size[x]
else:
par[y]=par[x]
size[x]+=size[y]
else:
return
for i in range(M):
a,b=map(int,input().split())
union(a-1,b-1)
print(max(size)) | N,M=map(int, input().split())
class UnionFind():
def __init__(self, n):
self.n = n # ノード数
self.parents = [-1]*n # 各ノードごとのparent
def find(self, x):
# 自身が根であれば
if self.parents[x]<0:
return x
# そうでなければ、再帰的に繰り返し、自身の根を探索
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
# それぞれの根
x = self.find(x)
y = self.find(y)
# 根が同一であれば
if x == y:
return
if self.parents[x] > self.parents[y]:
x,y = y,x
self.parents[x]+=self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
uf = UnionFind(N)
for _ in range(M):
i, j = map(int, input().split())
i-=1
j-=1
uf.union(i,j)
max_size = 0
for i in range(N):
if uf.parents[i]<0:
size = uf.size(i)
if max_size<size:
max_size = size
print(max_size)
| 1 | 3,985,055,830,164 | null | 84 | 84 |
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 main():
dx = [1,0]
dy = [0,1]
INF = float('inf')
h,w = readInts()
dp = [[INF]*w for _ in range(h)]
FIELD = [input() for _ in range(h)]
# dp[j][i] = i番目とj番目にかかる魔法の度合い
# 初期値 魔法1, なし 0
if FIELD[0][0] == '#':
dp[0][0] = 1
else:
dp[0][0] = 0
for i in range(w):
for j in range(h):
for x,y in dx,dy:
ny = j + y
nx = i + x
if ny >= h or nx >= w:
continue
add = 0
if FIELD[ny][nx] == '#' and FIELD[j][i] == '.':
add = 1
dp[ny][nx] = min(dp[ny][nx], dp[j][i] + add)
print(dp[h-1][w-1])
if __name__ == '__main__':
main()
| import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()
def main():
h,w=LI()
l=[]
l.append('.'*(w+1))
for _ in range(h):
x='.'
x+=S()
l.append(x)
dp=[[inf]*(w+10) for _ in range(h+10)]
if l[1][1]=='#':
dp[1][1]=1
else:
dp[1][1]=0
for i in range(1,h+1):
for j in range(1,w+1):
if i==1 and j==1:
continue
if l[i][j]=='#':
if l[i-1][j]=='.':
dp[i][j]=min(dp[i][j],dp[i-1][j]+1)
else:
dp[i][j]=min(dp[i][j],dp[i-1][j])
if l[i][j-1]=='.':
dp[i][j]=min(dp[i][j],dp[i][j-1]+1)
else:
dp[i][j]=min(dp[i][j],dp[i][j-1])
else:
dp[i][j]=min(dp[i-1][j],dp[i][j-1])
# print(dp)
return dp[h][w]
# main()
print(main())
| 1 | 49,068,787,020,520 | null | 194 | 194 |
import sys
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
t = int(input())
if t >= 30:
print("Yes")
else:
print("No") | def solve(x):
if x >= 30:
return "Yes"
else:
return "No"
def main():
x = int(input())
res = solve(x)
print(res)
def test():
assert solve(25) == "No"
assert solve(30) == "Yes"
if __name__ == "__main__":
test()
main()
| 1 | 5,795,269,017,806 | null | 95 | 95 |
n=int(input())
d=list(map(int,input().split()))
num=[0]*n
num[0]=1
if d[0]!=0 or d.count(0)!=1:
print(0)
else:
ans=1
for i in range(1,n):
num[d[i]]+=1
for i in range(1,max(d)+1):
ans*=num[i-1]**num[i]
ans%=998244353
print(ans)
| from collections import Counter
N = input()
D_list = list(map(int, input().split()))
max_D = max(D_list)
cnt_dic = dict(Counter(D_list))
if (D_list[0] == 0) & (cnt_dic.get(0) == 1):
ans = 1
for n in range(1, max_D + 1):
ans *= cnt_dic.get(n - 1, 0) ** cnt_dic.get(n, 1)
print(ans % 998244353)
else:
print(0) | 1 | 154,350,969,543,298 | null | 284 | 284 |
n, k = map(int, input().split())
a_nums = list(map(int, input().split()))
f_point = sum(a_nums[:k])
for i in range(n - k):
if a_nums[i] < a_nums[i + k]:
print("Yes")
else:
print("No") | N, K = map(int, input().split())
A = list(map(int, input().split()))
ans = ['Yes' if A[i] > A[i - K] else 'No' for i in range(K, N)]
print("\n".join(ans)) | 1 | 7,143,766,088,128 | null | 102 | 102 |
N, M = map(int, input().split())
to = [[] for i in range(100010)]
for i in range(M):
a, b = map(int, input().split())
to[a].append(b)
to[b].append(a)
dist = [0] * (N+1)
q = [1]
dist[0] = -1
#print(to[:4])
dist = [0] * N
pre = [0] * N
while len(q) != 0:
a = q.pop(0)
for i in to[a]:
if dist[i-1] == 0:
dist[i-1] = dist[a-1] + 1
pre[i-1] = a
q.append(i)
#print(q)
print("Yes")
for i in range(1, N):
print(pre[i])
| n=int(input())
r=int(n**0.5+1)
ans=0
for i in range(2,r):
e=0
while n%i==0:
n//=i
e+=1
k=1
while e>=k:
e-=k
ans+=1
k+=1
if n!=1:
ans+=1
print(ans)
| 0 | null | 18,755,975,286,228 | 145 | 136 |
n=int(input())
flag=0
for i in range(1,10):
for j in range(1,10):
if((i*j)==n):
flag=1
break
if(flag==1):
print('Yes')
else:
print('No') | import math
a, b, x = map(int, input().split())
if pow(a,2) * b == x:
print(0)
elif pow(a,2) * b / 2 <= x:
print(90 - math.degrees(math.atan((a / 2) / (b - x / pow(a,2)))))
else:
print(90 - math.degrees(math.atan((2 * x / (a * b)) / b)))
'''
left = 0
right = math.pi / 2
for i in range(10**5):
mid = (left + right) / 2
water = b * b * math.tan(math.pi / 2 - mid) * 0.5 * a
if water > x:
left = mid
elif water < x:
right = mid
else: break
print(i, water, x)
print(math.degrees(mid))
''' | 0 | null | 161,850,934,639,648 | 287 | 289 |
N = int(input())
X = input().split()
distance = 0
min_distance = float('Inf')
for i in range(1,101):
for j in range(N):
distance += (int(X[j]) - i) ** 2
min_distance = min(min_distance, distance)
distance = 0
print(min_distance) | import sys
x = int(raw_input())
print(x*x*x) | 0 | null | 32,616,352,314,604 | 213 | 35 |
#
# abc147 c
#
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 = """3
1
2 1
1
1 1
1
2 0"""
output = """2"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """3
2
2 1
3 0
2
3 1
1 0
2
1 1
2 0"""
output = """0"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """2
1
2 0
1
1 0"""
output = """1"""
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & (1 << i):
for c in C[i]:
if bit & (1 << c[0]-1) != (1 << c[0]-1)*c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count("1"))
print(ans)
if __name__ == "__main__":
# unittest.main()
resolve()
| n,p = map(int,input().split())
s = list(map(int, list(input()))) # 数値のリストにしておく
def solve():
if p in [2,5]: # 例外的な処理
ret = 0
for i in range(n): # 文字位置: i: 左から, n-1-i:右から (0 基準)
lsd = s[n-1-i] # 最下位桁
if lsd % p == 0: ret += n - i # LSD が割り切れたら LSD から右の桁数分加算
return ret
ten = 1 # S[l,r) のときの 10^r, init r=0 -> 10^0 = 1
cnt = [0]*p # 余りで仕分けして個数を集計
r = 0 # 左からの文字数 0 のときの余り
cnt[r] += 1 # 余りが同じものをカウント
for i in range(n): # 文字位置: i: 左から, n-1-i:右から (0 基準)
msd = s[n-1-i] # 最上位桁
r = (msd * ten + r) % p # r: 今回の余り
ten = ten * 10 % p # N≦2*10^5 桁 なので剰余計算忘れずに！
cnt[r] += 1 # 余りが同じものをカウント
ret = 0
for r in range(p): # 余り r の個数から組み合わせを計算
ret += cnt[r] * (cnt[r] - 1) // 2 # nCr(n=i,r=2)= n(n-1)/2
return ret
print(solve())
| 0 | null | 90,172,812,613,628 | 262 | 205 |
data = list(map(int,input().split()))
if(data[0] < data[1]): data[0],data[1] = data[1],data[0]
def gcd(x,y):
return x if y == 0 else gcd(y,x%y)
print(gcd(data[0],data[1]))
| s_list=[]
while True:
s = input()#文字列
if s == "-":
break
shuffle = int(input())
for i in range(shuffle):
h=int(input())
s = s[h:]+s[:h]
s_list.append(s)
for i in range(len(s_list)):
print(s_list[i])
| 0 | null | 961,034,697,180 | 11 | 66 |
X, K, D = map(int, input().split())
XX = abs(X)
if XX > K*D:
print(XX - K*D)
else:
if (K - X//D)%2 == 0:
print(X%D)
else:
print(abs(X%D -D))
| import sys
input = sys.stdin.readline
def marge(A, left, right, mid):
cnt = 0
n1 = mid - left
n2 = right - mid
L = [0] * (n1 + 1)
R = [0] * (n2 + 1)
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = 10 ** 9 + 1
R[n2] = 10 ** 9 + 1
i = 0
j = 0
for k in range(left, right):
cnt += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
return cnt
def margesort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
cnt1 = margesort(A, left, mid)
cnt2 = margesort(A, mid, right)
return cnt1 + cnt2 + marge(A, left, right, mid)
return 0
def main():
n = int(input())
A = list(map(int, input().split()))
cnt = margesort(A, 0, n)
print(' '.join(list(map(str, A))))
print(cnt)
if __name__ == '__main__': main()
| 0 | null | 2,659,257,266,468 | 92 | 26 |
a = [list(map(int,input().split())) for i in range(3)]
n = int(input())
b = [int(input()) for i in range(n)]
for i in range(3):
for j in range(3):
if a[i][j] in b:
a[i][j] = "o"
for i in range(3):
if a[i][0] == a[i][1] == a[i][2]:
print("Yes")
exit()
elif a[0][i] == a[1][i] == a[2][i]:
print("Yes")
exit()
elif a[0][0] == a[1][1] == a[2][2]:
print("Yes")
exit()
elif a[0][2] == a[1][1] == a[2][0]:
print("Yes")
exit()
elif i == 2:
print("No") | import math
#入力
x = int(input())
x_upper = (x+1) / 1.08
x_lower = x / 1.08
x_candidate = math.ceil(x_lower)
if x_lower <= x_candidate < x_upper:
print(x_candidate)
else:
print(":(") | 0 | null | 93,268,669,850,370 | 207 | 265 |
n = int(input())
x = list(map(int, input().split()))
m = 10**9
for i in range(min(x),max(x)+1):
t = 0
for h in x:
t += (h-i)**2
if t < m:
m = t
print(m) | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
R = 2**(N.bit_length())
st = [0] * (R*2)
def update(i,s):
x = 2 ** (ord(s) - ord('a'))
i += R-1
st[i] = x
while i > 0:
i = (i-1) // 2
st[i] = st[i*2+1] | st[i*2+2]
def query(a,b,n,l,r):
ret = 0
if a <= l and r <= b: return st[n]
if a < r and b > l:
vl = query(a,b,n*2+1,l,(l+r)//2)
vr = query(a,b,n*2+2,(l+r)//2,r)
ret = vl | vr
return ret
for i,s in enumerate(sys.stdin.readline().rstrip()):
update(i+1,s)
Q = NI()
for _ in range(Q):
c,a,b = sys.stdin.readline().split()
if c == '1':
update(int(a),b)
else:
ret = query(int(a),int(b)+1,0,0,R)
cnt = 0
b = 1
for i in range(26):
cnt += (b & ret) > 0
b <<= 1
print(cnt)
if __name__ == '__main__':
main() | 0 | null | 63,800,541,265,370 | 213 | 210 |
N,M,K=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
c=0
b=0
for i in range(M):
b+=B[i]
if b<=K:
c+=1
else:
break
a=0
b=sum(B)
j=M
ans=0
for i in range(N):
a+=A[i]
if a>K:
break
while a+b>K:
b-=B[-1]
B.pop(-1)
j-=1
ans=max(ans,i+j+1)
ans=max(ans,c)
print(ans)
| N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
SA =[0]
SB =[0]
for i in range(len(A)):
SA.append(SA[i] + A[i])
for j in range(len(B)):
SB.append(SB[j] + B[j])
l = M
ans = 0
for k in range(N+1):
if SA[k] > K:
break
while SA[k] + SB[l] > K:
l -= 1
ans = max(ans, k + l)
print(ans) | 1 | 10,772,132,619,972 | null | 117 | 117 |
from scipy.sparse.csgraph import floyd_warshall
# 下準備
N, M, L = map(int,input().split())
d = [[float("inf") for i in range(N)] for j in range(N)]
answer_d = [[float("inf") for i in range(N)] for j in range(N)]
for i in range(M):
A, B, C = map(int,input().split())
d[A-1][B-1] = d[B-1][A-1] = C
for i in range(N):
d[i][i] = 0
# 燃料補給回数の最小値を求める
d = floyd_warshall(d)
for i in range(N):
for j in range(N):
if d[i][j] <= L:
answer_d[i][j] = answer_d[j][i] = 1
d = floyd_warshall(answer_d)
# クエリを答える
Q = int(input())
answer = [-1]*Q
for i in range(Q):
s, t = map(int,input().split())
if d[s-1][t-1] != float("inf"):
answer[i] = d[s-1][t-1]-1
for i in answer:
print(i) | import sys
INF = 1 << 32 - 1
S = sys.stdin.readlines()
N, M, L = map(int, S[0].split())
dp = [[INF] * N for _ in range(N)]
for i in range(1, M + 1):
A, B, C = map(int, S[i].split())
dp[A - 1][B - 1] = C
dp[B - 1][A - 1] = C
for i in range(N):
dp[i][i] = 0
for k in range(N):
for i in range(N):
for j in range(N):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
dp2 = [[INF] * N for _ in range(N)]
for i in range(N):
for j in range(N):
if dp[i][j] <= L:
dp2[i][j] = 1
# for i in range(N):
# dp2[i][i] = 0
for k in range(N):
for i in range(N):
for j in range(N):
dp2[i][j] = min(dp2[i][j], dp2[i][k] + dp2[k][j])
Q = int(S[M + 1])
for i in range(M + 2, M + 2 + Q):
s, t = map(int, S[i].split())
refuel = dp2[s - 1][t - 1]
if refuel >= INF:
print(-1)
else:
print(refuel - 1)
| 1 | 173,664,891,827,168 | null | 295 | 295 |
A,B=input().split()
A=int(A)
B=int(B[2:])+int(B[0])*100
print(A*B//100) | S = input()
ans = 'ARC' if S == 'ABC' else 'ABC'
print(ans) | 0 | null | 20,448,897,698,720 | 135 | 153 |
n,k = list(map(int,input().split()))
point = list(map(int,input().split()))
rsp = ['r', 's', 'p']
t = input()
m = [rsp[rsp.index(i)-1] for i in t]
ans = 0
for i in range(n):
if i<k :
ans += point[rsp.index(m[i])]
else:
if m[i]!=m[i-k]:
ans += point[rsp.index(m[i])]
else:
try:
m[i] = rsp[rsp.index(m[i+k])-1]
except:
pass
# print(ans)
print(ans) | N, K = [int(x) for x in input().split()]
r, s, p = [int(x) for x in input().split()]
win_point = {
'r': r,
's': s,
'p': p,
}
next_hands = {
'r': ['s', 'p'],
's': ['r', 'p'],
'p': ['r', 's'],
}
enemy_hands = input()
def can_win(enemy_hand, my_hands):
# 勝てる場合にはTrueと勝てる手を教えてくれる
if enemy_hand == 'r' and 'p' in my_hands:
return True, 'p'
if enemy_hand == 's' and 'r' in my_hands:
return True, 'r'
if enemy_hand == 'p' and 's' in my_hands:
return True, 's'
# 勝てる手がない場合
return False, None
point = 0
for index in range(K):
now_hands = ['r', 'p', 's']
for i in range(index, N, K):
win, hand = can_win(enemy_hands[i], now_hands)
if win:
point += win_point[hand]
now_hands = next_hands[hand]
else:
# 勝てない場合次似邪魔しない手を選ぶ
# 勝てない回の次は必ず勝てるため全手出せる前提とする
now_hands = ['r', 'p', 's']
print(point)
| 1 | 107,399,956,878,340 | null | 251 | 251 |
import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
import bisect
n,m=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
def hand(x):
cnt=0
for i in range(n):
p=x-A[i]
cnt+=n-bisect.bisect_left(A,p)
return cnt
def main():
l=0
h=2*10**5+1
mid=(l+h)//2
while l+1<h:
mid=(l+h)//2
if hand(mid)<m:
h=mid
else:
l=mid
B=A[::-1]
for i in range(n-1):
B[i+1]+=B[i]
B=B[::-1]
ans=0
cnt=0
for i in range(n):
y=l-A[i]+1
index=bisect.bisect_left(A,y)
if n==index:
continue
else:
ans+=(n-index)*A[i]+B[index]
cnt+=(n-index)
ans+=(m-cnt)*l
print(ans)
if __name__ == "__main__":
main()
| a = input()
n = ord(a)
if ord('A') <= n <= ord('Z'):
print('A')
else:
print('a')
| 0 | null | 59,969,057,413,826 | 252 | 119 |
N = int(input())
A = [input() for _ in range(N)]
count = [0] * 4
for a in A:
if a == 'AC':
count[0] += 1
elif a == 'WA':
count[1] += 1
elif a == 'TLE':
count[2] += 1
else:
count[3] += 1
print(f"AC x {count[0]}")
print(f"WA x {count[1]}")
print(f"TLE x {count[2]}")
print(f"RE x {count[3]}") | n = int(input())
ac = 0
wa = 0
tle = 0
re = 0
for i in range(n):
status = input()
if status == 'AC':
ac += 1
elif status == 'WA':
wa += 1
elif status == 'TLE':
tle += 1
else:
re += 1
print('AC x', ac)
print('WA x', wa)
print('TLE x', tle)
print('RE x', re)
| 1 | 8,682,316,700,618 | null | 109 | 109 |
import sys
read=sys.stdin.read
h,w,n=map(int, read().split())
m=max(h,w)
print(n//m+(n%m!=0)) | import sys
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
def solve():
s = input()
if s[2] == s[3] and s[4] == s[5]:
print('Yes')
else:
print('No')
if __name__ == '__main__':
solve()
| 0 | null | 65,357,416,160,498 | 236 | 184 |
n=int(input())
a=list(map(int,input().split()))
q=int(input())
bc=[list(map(int,input().split())) for i in range(q)]
d=[0 for i in range(pow(10,5)+1)]
s=sum(a)
for i in range(n):
d[a[i]]+=1
for i in range(q):
s+=(bc[i][1]-bc[i][0])*d[bc[i][0]]
print(s)
d[bc[i][1]]+=d[bc[i][0]]
d[bc[i][0]]=0
| from decimal import Decimal
x = int(input())
money = 100
ans = 0
while 1:
ans += 1
money = money + int(money * Decimal(str(0.01)))
if money >= x:
print(ans)
exit() | 0 | null | 19,462,277,953,020 | 122 | 159 |
n,m = map(int, input().split())
ink = list(map(int, input().split()))
ink.sort()
array = [0 for i in range(n+1)]
array[1] = 1
for i in range(2, n+1):
if i in ink:
array[i] = 1
else:
mini = i
for j in ink[::-1]:
if j < i:
if mini > 1 + array[i-j]:
mini = 1 + array[i-j]
array[i] = mini
print(array[n])
| n,m=map(int,input().split())
if n%2==1:
for i in range(m):
print(n-i-1,i+1)
else:
cnt=1
for i in range(m):
if i%2==0:
print(n//4-i//2,n//4-i//2+cnt)
else:
print(n//2+n//4-i//2,n//2+n//4-i//2+cnt)
cnt+=1
| 0 | null | 14,482,418,654,208 | 28 | 162 |
from collections import deque
N, M, K = map(int,input().split())
friendlist = [[] for _ in range(N+1)]
for n in range(M):
A, B = map(int,input().split())
friendlist[A].append(B)
friendlist[B].append(A)
blocklist = [[] for _ in range(N+1)]
for n in range(K):
C, D = map(int, input().split())
blocklist[C].append(D)
blocklist[D].append(C)
whatgroup = [-1 for _ in range(N+1)]
visited = [-1] * (N+1)
d = deque()
leaderdic = {}
for person in range(1,N+1):
d.append(person)
leader = person
cnt = 0
while len(d)>0:
nowwho = d.popleft()
if whatgroup[nowwho] != -1:
continue
d.extend(friendlist[nowwho])
whatgroup[nowwho] = leader
cnt += 1
if cnt != 0:
leaderdic[leader] = cnt
for person in range(1,N+1):
ans = leaderdic[whatgroup[person]]
ans -= 1
ans -= len(friendlist[person])
for block in blocklist[person]:
if whatgroup[person]==whatgroup[block]:
ans -= 1
print(ans) | # union find
def find_root(x):
if parent[x] == x:
return x
else:
return find_root(parent[x])
def unite(x, y):
'''x,yの属する集合の併合'''
x = find_root(x)
y = find_root(y)
if x != y:
if rank[x] < rank[y]:
parent[x] = y
size[y] += size[x]
else:
parent[y] = x
size[x] += size[y]
if rank[x] == rank[y]:
rank[x] += 1
def roots():
'''rootリストを返す'''
roots = []
for i in range(N):
roots.append(find_root(i))
return roots
def group_size(x):
'''xが所属するグループのサイズ'''
return size[find_root(x)]
# 入力
N, M = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(M)]
# 初期化
parent = [i for i in range(N)] # 根
rank = [1] * N # 深さ
size = [1] * N # iを根とするグループのサイズ
# 前処理
edge = [[ab[M - 1 - i][0] - 1, ab[M - 1 - i][1] - 1] for i in range(M)]
# 結合
for i in range(M):
unite(edge[i][0], edge[i][1])
ans = 0
for i in range(N):
ans = max(ans, group_size(i))
print(ans)
| 0 | null | 32,805,229,121,700 | 209 | 84 |
def main():
N=int(input())
A=[int(a) for a in input().split()]
Acnt, Aprob={}, {}
for a in A:
Acnt[a] = Acnt.get(a, 0) + 1
sumA=0
for k, a in Acnt.items():
Aprob[k]=a*(a-1)//2
sumA+=Aprob[k]
#Acnt=[A.count(n) for n in range(N+1)]
#Aprob=[Acnt[n]*(Acnt[n]-1)//2 for n in range(N+1)]
#sumA=sum(Aprob)
for a in A:
ans=(Acnt[a]-1)*(Acnt[a]-2)//2
print(ans+sumA-Aprob[a])
main()
| from collections import Counter
n=int(input())
A=list(map(int,input().split()))
c=Counter(A)
s=0
for v in c.values():
s+=v*(v-1)//2
for i in range(n):
ans=s-(c[A[i]])+1
print(ans) | 1 | 47,716,534,450,272 | null | 192 | 192 |
K,N=map(int, input().split())
A=list(map(int, input().split()))
B=[0]*N
for i in range(N-1):
B[i]=A[i+1]-A[i]
B[-1]=A[0]+K-A[-1]
B=sorted(B)
ans = sum(B[0:-1])
print(ans) | K, N = list(map(lambda x: int(x), input().split(" ")))
A = list(map(lambda a: int(a), input().split(" ")))
D = [A[i + 1] - A[i] if i < len(A) - 1 else K - A[i] + A[0] for i in range(len(A))]
D.sort()
print(K - D[-1]) | 1 | 43,381,725,815,990 | null | 186 | 186 |
n = int(input())
num = [1,1]
for i in range(2,45):
f = num[i - 1] + num[i - 2]
num.append(f)
print(num[n])
| n=int(input())
a1=1
a=1
i=1
while i<n:
a1,a=a,a1+a
i+=1
print(a)
| 1 | 1,888,248,420 | null | 7 | 7 |
import math
def is_prime(n):
if n == 1: return False
for k in range(2, int(math.sqrt(n)) + 1):
if n % k == 0:
return False
return True
x = int(input())
for i in range(x, 10**5 + 4):
if is_prime(i) == True:
print(i)
exit()
| # -*- coding: utf-8 -*-
# Next Prime
import sys
TEST_INPUT = \
"""
100000
"""
TEST_OUTPUT = \
"""
100003
"""
def primes(n):
if n == 0 or n == 1: return []
ps = [2]
for odd in range(3, n + 1, 2):
for p in ps:
if odd % p == 0:
break
if p ** 2 > odd:
ps.append(odd)
break
return ps
def isprime(n):
if n == 0 or n == 1: return False
last = int(n**.5)
for m in primes(last):
if n % m == 0:
return False
return True
def nextprime(n):
if n in primes(n):
return n
else:
i = n
while not isprime(i):
i += 1
return i
def main(stdin):
n = int(stdin)
print(nextprime(n))
if __name__ == "__main__":
main(sys.stdin.read().strip()) | 1 | 105,912,562,839,570 | null | 250 | 250 |
n=int(input())
s=input()
ans=''
for i in range(n-1):
if s[i]==s[i+1]:
pass
else:
ans+=s[i]
ans+=s[-1]
print(len(ans)) | # -*- coding: utf-8 -*-
n = int(input())
s = input()
ans = 1
tmp = s[0]
for c in s:
if tmp != c:
ans += 1
tmp = c
print(ans)
| 1 | 170,164,934,524,090 | null | 293 | 293 |
nums = input().split(' ')
a = int(nums[0])
b = int(nums[1])
c = int(nums[2])
d = int(nums[3])
multi = []
multi.append(a * c)
multi.append(a * d)
multi.append(b * c)
multi.append(b * d)
ans = - 10 ** 18
for i in range(4):
if multi[i] > ans:
ans = multi[i]
print(ans) |
a,b,c,d=map(int, input().split())
if b<0 and c>0:
print(c*b)
elif d<0 and a>0:
print(d*a)
elif b>=0 or d>=0:
print(max(b*d,a*c))
else:
print(a*c)
| 1 | 3,018,405,640,140 | null | 77 | 77 |
a, b, c = map(int, input().split())
print('No' if a != b and b != c and c != a or a == b and b == c else 'Yes') | import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
A, B, C = map(int, input().split())
if A == B and B != C:
print("Yes")
elif B == C and B != A:
print("Yes")
elif C == A and C != B:
print("Yes")
else:
print("No") | 1 | 68,015,578,052,058 | null | 216 | 216 |
S = list(input())
if S[-1] == 's':
S.append('e')
S.append('s')
else:
S.append('s')
strS = ''.join(S)
print(strS) | N,A,B = map(int,input().split())
p = N // (A+B)
q = N % (A+B)
if q > A:
r = A
else:
r = q
print(A * p + r) | 0 | null | 28,822,693,651,886 | 71 | 202 |
h = int(input())
ans = 0
cnt = 1
while h > 1:
ans += cnt
h /= 2
cnt = cnt * 2
if int(h) == 1:
ans += cnt
print(ans) | import itertools
import math
n = int(input())
#座標のリスト
xy_list = []
for i in range(n) :
xy_list.append(list(map(int, input().split())))
#順列を生成
per_list = []
for j in itertools.permutations([x for x in range(n)]) :
per_list.append(j)
#順列に従って距離を加算
d = 0
for k in per_list :
for l in range(n - 1) :
d += math.sqrt((xy_list[k[l + 1]][0] - xy_list[k[l]][0]) ** 2 + (xy_list[k[l + 1]][1] - xy_list[k[l]][1]) ** 2)
print(d/(len(per_list))) | 0 | null | 113,609,957,613,438 | 228 | 280 |
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)) | LARGE = 10 ** 9 + 7
def solve(n, k):
# singular cases
if k == 0:
return 1
elif k == 1:
return n * (n - 1)
# pow
pow_mod = [1] * (n + 1)
for i in range(n):
pow_mod[i + 1] = pow_mod[i] * (i + 1) % LARGE
pow_mod_inv = [1] * (n + 1)
pow_mod_inv[-1] = pow(pow_mod[-1], LARGE - 2, LARGE)
for i in range(n - 1, 0, -1):
pow_mod_inv[i] = pow_mod_inv[i + 1] * (i + 1) % LARGE
res = 0
for i in range(min(k, n - 1) + 1):
# find where to set 0
pick_zeros = pow_mod[n] * pow_mod_inv[i] * pow_mod_inv[n - i] % LARGE
# how to assign ones
assign_ones = pow_mod[n - 1] * pow_mod_inv[i] * pow_mod_inv[n - 1 - i] % LARGE
res += pick_zeros * assign_ones
res %= LARGE
return res
def main():
n, k = map(int, input().split())
res = solve(n, k)
print(res)
def test():
assert solve(3, 2) == 10
assert solve(200000, 1000000000) == 607923868
assert solve(15, 6) == 22583772
if __name__ == "__main__":
test()
main()
| 0 | null | 34,411,482,727,270 | 67 | 215 |
s = input()
if "B" in s:
print("ARC")
else:
print("ABC") | # A - A?C
# 'ABC'には'ARC'を、'ARC'には'ABC'を返す
S = str(input())
if S == 'ABC':
print('ARC')
elif S == 'ARC':
print('ABC')
| 1 | 23,940,984,607,772 | null | 153 | 153 |
def sep():
return map(int,input().strip().split(" "))
def lis():
return list(sep())
n=int(input())
ar=lis()
k=0
for i in ar:
k=(k^i)
for i in ar:
print(k^i,end=" ")
| from sys import stdin,stdout
LI=lambda:list(map(int,input().split()))
MAP=lambda:map(int,input().split())
IN=lambda:int(input())
S=lambda:input()
import math
from collections import Counter,defaultdict
n=IN()
a=LI()
ans=0
for i in range(n):
ans^=a[i]
for i in range(n):
print(ans^a[i],end=" ")
| 1 | 12,538,542,495,580 | null | 123 | 123 |
n, k = map(int, input().split())
if n >= k:
n %= k
n = min(n, k-n)
else :
n = min(n, k-n)
print(n)
| N, K = map(int, input().split())
def f(x):
return( N-x*K )
def test(x):
return( f(x) >= 0 )
left = - 1 # return = right = (取り得る値の最小値) の可能性を排除しないために、-1 が必要
right = 10**18
while right - left > 1: # 最終的に (right, left, mid) = (最小値, 最小値 - 1, 最小値 - 1) に収束するため、差が 1 になったときに終了すればよい
mid = (left+right)//2
if test(mid):
left = mid
else:
right = mid
print(min(abs(N-left*K), abs(N-right*K))) | 1 | 39,403,224,830,968 | null | 180 | 180 |
def f(n):
mod = 1000000007
return (pow(10, n, mod) - 2 * pow(9, n, mod) + pow(8, n, mod)) % mod
n = int(input())
print(f(n))
| n = int(input())
print((pow(10,n) - pow(9, n) - pow(9, n) + pow(8, n))%(10**9+7)) | 1 | 3,146,486,347,228 | null | 78 | 78 |
a = int(input())
ans = 0
for i in range(3):
ans += a**(i+1)
print(ans) | a = int(input())
out = a + a**2 + a**3
print(out) | 1 | 10,197,354,271,796 | null | 115 | 115 |
N=int(input())
d={}
for i in range(1,10):
for j in range(1,10):
d[i*10+j]=0
for i in range(1,min(10,N+1)):
d[i*10+i]=1
for i in range(11,N+1):
i=str(i)
h,t=int(i[0])*10,int(i[-1])
if t!=0:
d[h+t]+=1
ans=0
for i in range(1,9):
for j in range(i+1,10):
ans+=(d[i*10+j]*d[j*10+i])*2
for i in range(1,10):
ans+=d[i*10+i]**2
print(ans) | N = int(input())
numss = [[0]*(10) for _ in range(10)]
for i in range(1, N+1):
ss = str(i)
hd = int(ss[0])
tl = int(ss[-1])
numss[hd][tl] += 1
#print(f'hd = {hd}, tl = {tl}')
ans = 0
for x in range(1, 10):
for y in range(1, 10):
ans += numss[x][y] * numss[y][x]
print(ans) | 1 | 86,136,487,033,730 | null | 234 | 234 |
import numpy as np
n = int(input())
a = [int(x) for x in input().split()]
a.sort()
m = np.zeros(max(a)+1, dtype=int)
cnt = 0
for i in range(n):
x = a[i]
if i == n-1:
if m[x] == 0:
cnt +=1
else:
if m[x] == 0 and a[i] != a[i+1]:
cnt +=1
m[x::x] += 1
print(cnt) | #!/usr/bin/env python
n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
ma = a[-1]
dup = [0 for _ in range(ma+1)]
div = [0 for _ in range(ma+1)]
for i in range(n):
dup[a[i]] += 1
#print('dup =', dup)
for i in range(n):
for j in range(a[i], ma+1, a[i]):
div[j] += 1
#print('div =', div)
ans = 0
for i in range(n):
if div[a[i]] == 1:
ans += 1
print(ans)
| 1 | 14,447,642,601,860 | null | 129 | 129 |
# https://atcoder.jp/contests/nikkei2019-2-qual/tasks/nikkei2019_2_qual_b
# まず、本当に木を構築するモノではないだろう
from collections import Counter
n = int(input())
nums = [int(i) for i in input().split()]
mod = 998244353
MAX = max(nums)
c = Counter(nums)
if nums[0] != 0 or nums.count(0) != 1:
ans = 0
else:
ans = 1
for i in range(1, MAX + 1):
ans = ans * pow(c.get(i - 1, 0), c.get(i, 0), mod) % mod
ans %= mod
print(ans) | N=int(input())
D=list(map(int,input().split()))
mod=998244353
ans=1
count=[0 for i in range(0,N)]
for i in range(0,N):
count[D[i]]+=1
able=True
if D[0]!=0 or count[0]!=1:
able=False
for i in range(0,N-1):
if count[i]==0 and count[i+1]!=0:
able=False
if able:
for i in range(0,N-1):
ans=(ans*pow(count[i],count[i+1],mod))%mod
print(ans)
else:
print(0) | 1 | 155,124,530,530,632 | null | 284 | 284 |
import sys
input = sys.stdin.buffer.readline
H, N = map(int, input().split())
A = [tuple(map(int, line.split())) for line in sys.stdin.buffer.readlines()]
INF = 1 << 30
dp = [INF]*(H+1)
dp[H] = 0
for i in range(N):
a, b = A[i]
for h in range(H, -1, -1):
x = h-a if h-a > 0 else 0
if dp[x] > dp[h]+b:
dp[x] = dp[h]+b
print(dp[0])
| h,n=map(int, input().split())
a=[0]*n
b=[0]*n
for i in range(n):
a[i],b[i]=map(int,input().split())
max_a=max(a)
dp=[float("inf")]*(h+max_a+1)
dp[0]=0
for i in range(h):
for j in range(n):
dp[i+a[j]] = min(dp[i+a[j]], dp[i]+b[j])
print(min(dp[h:])) | 1 | 81,575,028,711,680 | null | 229 | 229 |
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N = 10 ** 6 # N は必要分だけ用意する
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
X, Y = map(int, input().split())
if (2*Y-X)%3 == 0:
if (2*X-Y)%3 == 0:
a = (2*Y-X)//3
b = (2*X-Y)//3
else:
print(0)
exit()
else:
print(0)
exit()
print(cmb(a+b, a, p))
| X, Y = map(int, input().split())
m, r = divmod(2*Y-X, 3)
if r != 0:
print(0)
exit()
n = Y - 2*m
if n < 0 or m < 0:
print(0)
exit()
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n-i) * modinv(i+1, mod) % mod
return res
print(combination(n+m, n)) | 1 | 149,785,270,103,970 | null | 281 | 281 |
S = input()
S = S.replace('><','>,<').split(',')
ans = 0
for s in S:
small = s.count('<')
big = s.count('>')
tmp = max(small,big)\
+ (max(small,big)-1)*max(small,big)//2\
+ (min(small,big)-1)*min(small,big)//2
ans += tmp
print(ans) | S=input()
N=len(S)+1
LEFT=[0]
RIGHT=[0]
left=0
right=0
for i in range(N-1):
if S[i]==">":
left=0
else:
left+=1
LEFT+=[left]
for i in range(N-2,-1,-1):
if S[i]=="<":
right=0
else:
right+=1
RIGHT+=[right]
ans=0
for i in range(N):
ans+=max(LEFT[i],RIGHT[N-1-i])
print(ans) | 1 | 155,895,065,952,252 | null | 285 | 285 |
while True:
x = input()
if x == '0':
break
length = len(x)
tot = 0
for i in range(length):
tot += int(x[i:i + 1])
print(tot)
| while True:
x = list(input())
if x[0] == "0":
break
sum = 0
for i in range(len(x)):
sum += int(x[i])
print(sum)
#print(x) | 1 | 1,598,888,544,260 | null | 62 | 62 |
n = int(input())
s = input()
sr = []
sg = []
sb = [0] * n
kcnt = 0
for i in range(n):
if s[i] == 'R':
sr.append(i)
elif s[i] == 'G':
sg.append(i)
else:
sb[i] = 1
kcnt += 1
ans = 0
for i in sr:
for j in sg:
nki = j*2 - i
nkj = i*2 - j
nkk = (j+i)
ans += kcnt
if 0<= nki < n and sb[nki] == 1:
ans -= 1
if 0<= nkj < n and sb[nkj] == 1:
ans -= 1
if nkk%2 == 0 and 0<= (nkk//2) < n and sb[nkk//2] == 1:
ans -= 1
print(ans) | a,b,c,d = (int(x) for x in input().split())
ans = max(a*c,a*d,b*c,b*d)
print(ans) | 0 | null | 19,685,256,618,144 | 175 | 77 |
N = int(input())
if N == 1:
print(0)
exit()
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
candidates = factorization(N)
# print(candidates)
li = []
for item in candidates:
for i in range(item[1]):
li.append(item[0]**(i+1))
li.sort()
# print(li)
cnt = 0
for i in range(len(li)):
if N % li[i] == 0:
N /= li[i]
cnt += 1
print(cnt)
| import math
from collections import defaultdict
from itertools import accumulate
N=int(input())
data=defaultdict(int)
result=0
for i in range(2,int(math.sqrt(N))+1):
while N%i==0:
N//=i
data[i]+=1
if N!=1:
data[N]+=1
cumsum=list(accumulate(range(1,10**6*2)))
for value in data.values():
for i in range(10**6*2):
if value<cumsum[i]:
result+=i
break
if result==0:
if N!=1:
result=1
print(result) | 1 | 17,031,824,201,538 | null | 136 | 136 |
input_line = input().rstrip().split(' ')
l = int(input_line[0])
r = int(input_line[1])
d = int(input_line[2])
output = 0
for i in range(l,r+1):
if i % d == 0:
output = output + 1
print(output) | l,R, d = map(int, input().split())
a =0
for i in range(l,R+1):
if i % d == 0:
a = a+1
print(a)
| 1 | 7,611,879,489,682 | null | 104 | 104 |
import math
def koch_kurve(n, p1=[0, 0], p2=[100, 0]):
if n == 0: return
s, t, u = make_edge_list(p1, p2)
koch_kurve(n-1, p1, s)
# print(s)
# print(s)
print(" ".join([ str(i) for i in s ]))
koch_kurve(n-1, s, u)
print(" ".join([ str(i) for i in u ]))
koch_kurve(n-1, u, t)
print(" ".join([ str(i) for i in t ]))
koch_kurve(n-1, t, p2)
def make_edge_list(p1, p2):
sx = 2 / 3 * p1[0] + 1 / 3 * p2[0]
sy = 2 / 3 * p1[1] + 1 / 3 * p2[1]
# s = (sx, sy)
s = [sx, sy]
tx = 1 / 3 * p1[0] + 2 / 3 * p2[0]
ty = 1 / 3 * p1[1] + 2 / 3 * p2[1]
t = [tx, ty]
theta = math.radians(60)
ux = math.cos(theta) * (tx - sx) - math.sin(theta) * (ty - sy) + sx
uy = math.sin(theta) * (tx - sx) + math.cos(theta) * (ty - sy) + sy
u = [ux, uy]
return s, t, u
n = int(input())
print("0 0")
koch_kurve(n)
print("100 0")
| import math
def make_stu(p1, p2):
s = [(2 * p1[0] + p2[0]) / 3, (2 * p1[1] + p2[1]) / 3]
t = [(p1[0] + 2 * p2[0]) / 3, (p1[1] + 2 * p2[1]) / 3]
u = [s[0] + (t[0] - s[0]) / 2 - math.sqrt(3) * (t[1] - s[1]) / 2,
s[1] + (t[1] - s[1]) / 2 + math.sqrt(3) * (t[0] - s[0]) / 2]
return s, t, u
def koch_curve(n, p1, p2):
if n >= 1:
s, t, u = make_stu(p1, p2)
if n == 1:
print(s[0], s[1])
print(u[0], u[1])
print(t[0], t[1])
else:
koch_curve(n - 1, p1, s)
print(s[0], s[1])
koch_curve(n - 1, s, u)
print(u[0], u[1])
koch_curve(n - 1, u, t)
print(t[0], t[1])
koch_curve(n - 1, t, p2)
n = int(input())
print(0.0, 0.0)
koch_curve(n, [0.0, 0.0], [100.0, 0.0])
print(100.0, 0.0)
| 1 | 131,255,269,014 | null | 27 | 27 |
import math
N = int(input())
A = list(map(int, input().split()))
A = sorted(A)
maxA = A[len(A)-1]
valid = [True] * (maxA+1)
for i in range(len(A)):
if valid[A[i]] == False:
continue
if i != 0 and A[i-1] == A[i]:
valid[A[i]] = False
else:
for j in range(A[i]*2, maxA+1, A[i]):
valid[j] = False
count = 0
for i in range(len(A)):
if valid[A[i]] == True:
count += 1
print(count)
| from collections import Counter
n = int(input())
a = list(map(int, input().split()))
a.sort()
dp = [0] * a[-1]
c = Counter(a)
for i in a:
for j in range(i, a[-1]+1, i):
dp[j-1] += 1
ans = 0
for i in a:
if dp[i-1] == 1 and c[i]:
ans += 1
print(ans) | 1 | 14,329,004,276,160 | null | 129 | 129 |
A = []
P = ['o']*9
for i in range(3):
a = [int(i) for i in input().split()]
for j in range(3):
A.append(a[j])
N = int(input())
for i in range(N):
b = int(input())
for j in range(9):
if A[j] == b:
P[j] = 'x'
t = 0
for i in range(3):
if (P[i] == P[i+3] == P[i+6] == 'x') or (P[3*i] == P[3*i+1] == P[3*i+2] == 'x'):
t += 1
break
if (P[0] == P[4] == P[8] == 'x') or (P[2] == P[4] == P[6] == 'x'):
t += 1
if t == 0:
print('No')
else:
print('Yes') | A = []
for i in [0]*3:
A.append(list(map(int,input().split())))
N = int(input())
B = []
for i in [0]*N:
B.append(int(input()))
for b in B:
for i in range(3):
for j in range(3):
if A[i][j] == b:
A[i][j] = -1
#ヨコ
for i in range(3):
if A[i] == [-1,-1,-1]:
print("Yes")
exit()
#タテ
for i in range(3):
if [A[0][i],A[1][i],A[2][i]] == [-1,-1,-1]:
print("Yes")
exit()
#ナナメ
if [A[0][0],A[1][1],A[2][2]] == [-1,-1,-1]:
print("Yes")
exit()
if [A[0][2],A[1][1],A[2][0]] == [-1,-1,-1]:
print("Yes")
exit()
print("No")
| 1 | 59,900,456,252,540 | null | 207 | 207 |
#!/usr/bin/env python
# coding: utf-8
# In[15]:
N = int(input())
A = list(map(int, input().split()))
# In[17]:
total = sum(A)
ans = total
left = 0
for i in A:
left += i
right = total - left
ans = min(ans, abs(left - right))
# print(left, right, ans)
print(ans)
# In[ ]:
| import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
n, k = map(int, input().split())
nums = [i for i in range(n+1)]
sums = [0]
ans = 0
x = 10**9 + 7
for i in range(n):
sums.append(nums[i+1]+sums[i])
for j in range(k, len(nums)+1):
if j == len(nums):
ans += 1
else:
ans += sums[-1] - sums[-(1+j)] - sums[j-1] + 1
print(ans%x)
if __name__ == '__main__':
main() | 0 | null | 87,830,093,990,268 | 276 | 170 |
import sys
def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
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 S(): return input()
def LS(): return input().split()
INF = float('inf')
s = S()
print(s[:3])
| i=str(input())
print(i[:3])
| 1 | 14,832,238,054,588 | null | 130 | 130 |
s=input()
ans = 0
for i in range(len(s)):
j = len(s)-i-1
if i > j: break
if s[i] != s[j]: ans += 1
print(ans) | import bisect
def binary_search(items, a, b, i, j):
def c_is_x(c):
is1 = c > max(a - b, b - a)
is2 = c < a + b
if is1 and is2:
return 0
elif is1:
return 1
else:
return 2
low = j+1
high = len(items) - 1
while low <= high:
mid = (low + high) // 2
ans = items[mid]
c_type = c_is_x(ans)
if c_type == 0 and mid != i and mid != j:
return mid
elif c_type == 1:
low = mid + 1
else:
high = mid - 1
return None
N = int(input())
L = list(map(int, input().split()))
L.sort()
# print(L)
count = 0
for i in range(N):
for j in range(i+1, N):
# i = N - i - 1
# j = N - j - 1
a = L[i]
b = L[j]
k = bisect.bisect_left(L, a+b, lo=j) - 1
if k < N:
c = L[k]
# print(a, b, c, a+b)
# print(i, j, k)
count += max(k - j, 0)
print(count)
| 0 | null | 145,895,307,933,496 | 261 | 294 |
s=input()
s.lower()
print(s[0:3]) | import random
s = str(input()).lower()
t = random.randint(0, len(s)-3)
print(s[t:t+3]) | 1 | 14,721,701,642,780 | null | 130 | 130 |
n = int(input())
b = 0
while b < n:
b += 1000
print(b-n) | import sys; input = sys.stdin.readline
n = int(input())
if n%1000 == 0: print(0)
else: print(1000 - n%1000)
| 1 | 8,412,836,406,040 | null | 108 | 108 |
# Serval vs Monster
H, A = map(int, input().split())
ans = (H // A) + min(1, H % A)
print(ans) | x = int(input())
xSum = 0
cnt = 1
while True:
xSum += x
if xSum%360 == 0:
break
cnt += 1
print(cnt) | 0 | null | 45,089,843,268,746 | 225 | 125 |
import math
X=int(input())
def ans165(X:int):
cash=100#当初の預金額
count=0
while True:
# cash=int(cash*1.01) #元本に１パーセントの利子をつけ小数点以下切り捨て # WA
# cash = cash * 1.01 * 100 // 100 # 1%の利子をつけて100倍した後に100で割って整数部のみ取り出す # WA
# cash += cash * 0.01 * 100 // 100 # 1%の利子を計算して100倍した後に100で割って整数部のみ取り出す # WA
# cash += cash // 100 # 元本に100で割った整数部を足す # AC
# cash += math.floor(cash * 0.01) # WA
# cash += math.floor(cash / 100) # WA
cash += math.floor(cash // 100) # WA
count += 1#利子をつける回数だけcountを増やす
if cash>=X:#cashがXの値以上になったらループ終了
break
return count
print(ans165(X)) | import sys
X = int(input())
a = 100
d = 0
while(a<X):
a = a * 101 // 100
d += 1
print(d)
| 1 | 27,039,574,922,230 | null | 159 | 159 |
input()
l = list(map(int,input().split()))
l.sort()
ans = 1000000
n_ans = 0
for i in range(l[0],l[len(l)-1]+1):
for j in range(len(l)):
n_ans += (l[j]-i) ** 2
if n_ans <= ans:
ans = n_ans
n_ans = 0
else:
n_ans = 0
print(ans) | n, k = map(int, input().split())
g = [1] * k
mod = 10 ** 9 + 7
for i in range(k, 0, -1):
x = k // i
m = n
while m > 0:
if m & 1:
g[i-1] = g[i-1] * x % mod
x = x * x % mod
m >>= 1
y = 2
while i * y <= k:
g[i-1] -= g[i*y-1]
y += 1
ans = 0
for i in range(k):
ans = (ans + g[i] * (i + 1)) % mod
print(ans)
| 0 | null | 51,066,495,015,130 | 213 | 176 |
x = list(map(int, input().split(" ")))
h1 = x[0]
m1 = x[1]
h2 = x[2]
m2 = x[3]
s = x[4]
h = (h2-h1)*60
m = m2-m1
print((h+m)-s) | a, b, c, d = map(int, input().split())
for i in range(101):
x = c - b*i
y = a - d*i
if x <= 0:
print("Yes")
break
elif y <= 0:
print("No")
break | 0 | null | 23,996,537,236,800 | 139 | 164 |
import numpy as np
n, k = map(int, input().split())
aa = list(map(np.int64, input().split()))
aa = np.array(aa)
def mul(dd):
mod = 10**9+7
ret = 1
for d in dd:
ret = (ret*d)%mod
return ret
def sol(aa, n, k):
mod = 10**9+7
aap = aa[aa>0]
aam = aa[aa<0]
if n == k:
return mul(aa)
if len(aap) + 2*(len(aam)//2) < k:
return 0
# マイナスのみ
if len(aam) == n:
aam.sort()
if k%2==1:
return mul(aam[-k:])
else:
return mul(aam[:k])
aap = aa[aa>=0]
aap.sort()
aap = aap[::-1]
aam.sort()
ret=1
if k%2 >0:
k = k-1
ret *= aap[0]
aap = aap[1:]
aap2 = [aap[2*i]*aap[2*i+1] for i in range(len(aap)//2)]
aam2 = [aam[2*i]*aam[2*i+1] for i in range(len(aam)//2)]
aap2.extend(aam2)
aap2.sort(reverse=True)
aap2 = [i%mod for i in aap2]
return (ret*mul(aap2[:k//2]))%mod
print(sol(aa, n, k))
| import bisect
H,W,K=map(int,input().split())
s=[""]*H
ans=[[0]*W for _ in range(H)]
St=[0]*H#i行目にイチゴがあるか？
St2=[]
for i in range(H):
s[i]=input()
if "#" in s[i]:
St[i]=1
St2.append(i)
a=1
#i行目，aからスタートして埋める
for i in range(H):
if St[i]==1:
flag=0
for j in range(W):
if s[i][j]=="#":
if flag==0:
flag=1
else:
a+=1
ans[i][j]=a
a+=1
for i in range(H):
k=bisect.bisect_left(St2,i)
#近いところを参照したいけど参照したいけど，端での処理が面倒
if k!=0:
k-=1
if St[i]==0:
ans[i]=ans[St2[k]]
for i in range(H):
print(" ".join(map(str, ans[i]))) | 0 | null | 76,443,127,421,274 | 112 | 277 |
n,k=map(int,input().split())
s=[]
s2=[]
mod=998244353
for i in range(k):
l,r=map(int,input().split())
s+=[i for i in range(l,r+1)]
s2.append([l,r])
s.sort()
dp=[0]*(n+1)
dpsum=[0]*(n+1)
dp[1]=1
dpsum[1]=1
for i in range(2,n+1):
for j in range(k):
if i-s2[j][0]>=0:
dp[i]+=(dpsum[i-s2[j][0]]-dpsum[max(i-s2[j][1],1)-1])%mod
dp[i]%=mod
dpsum[i]=(dpsum[i-1]+dp[i])%mod
print(dp[n])
| α = str(input())
if α.isupper():
print('A')
else:
print('a') | 0 | null | 7,024,958,082,890 | 74 | 119 |
n=raw_input()
k=n.split()
k.sort()
print k[0],
print k[1],
print k[2] | N = int(input())
AB = [[int(_) for _ in input().split()] for _ in range(N)]
A = sorted([a for a, b in AB])
B = sorted([b for a, b in AB])
ans = B[N // 2] + B[(N - 1) // 2] - (A[N // 2] + A[(N - 1) // 2])
if N % 2:
ans //= 2
ans += 1
print(ans)
| 0 | null | 8,854,190,306,482 | 40 | 137 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from itertools import accumulate
from bisect import bisect
def main():
n, m, k = map(int, input().split())
a = tuple(accumulate(map(int, input().split())))
b = tuple(accumulate(map(int, input().split())))
r = bisect(b, k)
for i1, ae in enumerate(a):
if k < ae:
break
r = max(r, bisect(b, k - ae) + i1 + 1)
print(r)
if __name__ == '__main__':
main() | import math
def prime(n):
if (n==2):
return True
if(n<2 or n%2==0):
return False
i=3
while(i<=math.sqrt(n)):
if (n%i==0):
return False
i=i+2
return True
N=int(input())
count=0
for i in range(N):
n=int(input())
if(prime(n)):
count+=1
print(count) | 0 | null | 5,409,321,821,998 | 117 | 12 |
a = int(input())
s = a
s = s * a + a
s = s * a + a
print(s) | a = int(input())
print((lambda x:x+x**2+x**3)(a))
| 1 | 10,212,785,698,920 | null | 115 | 115 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
for i in range(N - K):
print("Yes" if A[i] < A[i + K] else "No")
if __name__ == "__main__":
main()
| import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
n,k = inpm()
a = inpl()
for i in range(n - k):
if a[i + k] > a[i]:
print('Yes')
else:
print('No')
| 1 | 7,115,582,744,960 | null | 102 | 102 |
import numpy as np
inputs = open(0).readlines()
def main(inputs):
h, w, k = map(int, inputs[0].split())
cake, count, coords = np.zeros((h, w), dtype=np.uint), 0, {}
for i, s in enumerate(inputs[1:]):
for j, c in enumerate(s):
if c == '#':
count += 1
cake[i, j] = count
coords[count] = (j, i)
empty_rows = {i for i, rows in enumerate(cake) if not np.any(rows)}
for i in range(1, count+1):
x, y = coords[i]
x0, y0 = x-1, y-1
x1, y1 = x+1, y+1
while 0 <= x0 and cake[y, x0] == 0:
cake[y, x0] = i
x0 -= 1
x0 += 1
while x1 < w and cake[y, x1] == 0:
cake[y, x1] = i
x1 += 1
while 0 <= y0 and y0 in empty_rows:
cake[y0, x0:x1] = i
y0 -= 1
while y1 < h and y1 in empty_rows:
cake[y1, x0:x1] = i
y1 += 1
for rows in cake:
print(*rows)
main(inputs) | #!/usr/bin/env python
x = int(input())
n = x//100
for i in range(n+1):
tmp = x
tmp -= i*100
if 5*i >= tmp:
print(1)
exit()
print(0)
| 0 | null | 135,307,637,148,852 | 277 | 266 |
A,B,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
l=[]
for i in range(m):
x,y,c=map(int,input().split())
l.append(a[x-1]+b[y-1]-c)
l.append(min(a)+min(b))
print(min(l)) | s=len(input());print('x'*s) | 0 | null | 63,574,851,090,112 | 200 | 221 |
N = int(input())
graph = [[] for _ in range(N+1)]
AB = []
for _ in range(N-1):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
AB.append((a, b))
root = 1
parent = [0] * (N+1)
order = []
stack = [root]
while stack:
x = stack.pop()
order.append(x)
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
color = [-1] * (N+1)
K = -1
for x in order:
ng = color[x]
c = 1
for y in graph[x]:
if y == parent[x]:
continue
if c == ng:
c += 1
K = max(c, K)
color[y] = c
c += 1
ans = []
for a, b in AB:
if parent[a] == b:
ans.append(color[a])
else:
ans.append(color[b])
print(K)
for i in ans:
print(i)
| s = input()
t = input()
ans = 10**8
for i in range(len(s)-len(t)+1):
cnt = 0
for j in range(len(t)):
if s[i+j] != t[j]: cnt += 1
ans = min(ans, cnt)
print(ans)
| 0 | null | 69,720,221,604,488 | 272 | 82 |
N=int(input())
c=list(input())
R=c.count('R')
L=c[:R].count('R')
print(R-L) | while True:
x, y = map(int, input().split())
if x == 0 and y == 0:
break
if x > y:
x, y = y, x
print(x, y)
| 0 | null | 3,375,623,683,520 | 98 | 43 |
from functools import reduce
N = int(input())
A = [int(x) for x in input().split()]
SUM=reduce(lambda a, b: a^b, A)
[print(SUM^A[i]) for i in range(N)] | N = int(input())
A = list([int(x) for x in input().split()])
xor_base = A[0]
for a in A[1:]:
xor_base ^= a
result = []
for a in A:
result.append(a ^ xor_base)
print(*result)
| 1 | 12,442,870,269,632 | null | 123 | 123 |
N=int(input())
*A,=map(int, input().split())
B=[(i+1,a) for i,a in enumerate(A)]
from operator import itemgetter
B.sort(reverse=True, key=itemgetter(1))
dp = [[-1] * (N+1) for _ in range(N+1)]
dp[0][0] = 0
for i in range(1,N+1):
idx, act = B[i-1]
for j in range(i+1):
k = i-j
if 0<j: dp[j][k] = max(dp[j][k], dp[j-1][k] + act * abs(idx-j))
if 0<k: dp[j][k] = max(dp[j][k], dp[j][k-1] + act * abs(idx-(N-k+1)))
ans=0
for j in range(N+1):
ans = max(ans, dp[j][N-j])
print(ans)
| import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
from collections import defaultdict
def resolve():
N = ir()
A = sorted([[i+1, d] for i, d in enumerate(lr())], key=lambda x: x[1])[::-1]
dp = defaultdict(lambda: -float('inf'))
dp[0, 0] = 0
for x in range(N):
for y in range(N-x):
i, d = A[x+y]
dp[x+1, y] = max(dp[x, y]+d*(i-x-1), dp[x+1, y])
dp[x, y+1] = max(dp[x, y]+d*(N-y-i), dp[x, y+1])
ans = 0
for i in range(N+1):
ans = max(ans, dp[i, N-i])
print(ans)
resolve() | 1 | 33,822,585,403,488 | null | 171 | 171 |
a,b = map(int, open(0).read().split())
i = int(a/0.08-1e-8)
while 1:
if int(i*0.08)==a and int(i*0.1)==b:
print(i)
break
if int(i*0.08)>a:
print(-1)
break
i += 1 | from sys import stdin
import sys
import math
from functools import reduce
a,b = [int(x) for x in stdin.readline().rstrip().split()]
c = int(b*10)
for i in range(10):
if a == int(c*0.08):
print(c)
sys.exit()
c = c + 1
print(-1)
| 1 | 56,258,378,095,350 | null | 203 | 203 |
def main():
K = int(input())
S = input()
N = len(S)
mod = 10**9 + 7
r = 0
t = pow(26, K, mod)
s = 1
inv26 = pow(26, mod - 2, mod)
inv = [0] * (K + 2)
inv[1] = 1
for i in range(2, K + 2):
inv[i] = -inv[mod % i] * (mod // i) % mod
for i in range(K + 1):
r = (r + t * s) % mod
t = (t * 25 * inv26) % mod
s = (s * (N + i) * inv[i + 1]) % mod
return r
print(main())
| K = int(input())
S = input()
s = len(S)
mod = int(1e9+7)
n = pow(26, K, mod)
ans = n
for i in range(K):
n = n*25*(s+i)*pow(26*(i+1),-1,mod)%mod
ans = (ans +n) % mod
print(ans) | 1 | 12,818,943,187,948 | null | 124 | 124 |
while 1:
a,b = map(int, raw_input().split())
if a == b == 0:
break
elif a < b:
print "%s %s" % (a,b)
else:
print "%s %s" % (b,a) | a = []
while True:
d = list(map(int,input().split()))
if d == [-1,-1,-1]:
break
a.append(d)
def Point2Grade(d):
m,f,r = d
if (m==-1)|(f==-1):
return 'F'
elif m+f >= 80:
return 'A'
elif m+f >= 65:
return 'B'
elif m+f >= 50:
return 'C'
elif m+f >= 30:
if r >=50: return 'C'
else: return 'D'
else: return 'F'
for x in a:
print(Point2Grade(x)) | 0 | null | 880,423,314,552 | 43 | 57 |
a, b, x = map(int, input().split())
import math
if x <= ((a ** 2) * b) / 2:
n = 2 * x / (a * b)
ans = math.acos(n / (math.sqrt(b ** 2 + n ** 2)))
else:
n = 2 * b - (2 * x / (a ** 2))
ans = math.acos(a / math.sqrt(a ** 2 + n ** 2))
print(math.degrees(ans)) | import sys
input = sys.stdin.readline
import math
a,b,x = (int(i) for i in input().rstrip('\n').split())
if b*(a**2)<2*x:
S=2*(b*(a**2)-x)
res = math.atan2(S,a**3)
res2 = math.degrees(res)
print(res2)
else:
res = math.atan2(2*x,a*(b**2))
res2 = math.degrees(res)
print(90-res2) | 1 | 163,019,166,306,752 | null | 289 | 289 |
N = int(input())
ans = []
while N > 0:
N -= 1
a = N%26
ans.append(chr(97+a))
N = N//26
#print(ans)
ret = ""
for i in range(len(ans)):
ret += ans[-1-i]
#print(ret)
print(ret) | import sys
def display(inp):
s = len(inp)
for i in range(s):
if i!=len(inp)-1:
print("%d" % inp[i], end=" ")
else:
print("%d" % inp[i], end="")
print("")
line = sys.stdin.readline()
size = int(line)
line = sys.stdin.readline()
inp = []
for i in line.split(" "):
inp.append(int(i))
display(inp)
for i in range(1,size):
if inp[i]!=size:
check = inp.pop(i)
for j in range(i):
if check<inp[j]:
inp.insert(j,check)
break
if j==i-1:
inp.insert(j+1,check)
break
display(inp) | 0 | null | 5,889,094,865,044 | 121 | 10 |
n,m=map(int,input().split())
s=list(map(int,list(input())))
ans=[]
i=n
while i>0:
j=max(0,m-i)
while s[i-(m-j)]!=0:
j+=1
if j==m:
print(-1)
exit(0)
ans.append(m-j)
i-=(m-j)
ans.reverse()
print(' '.join(map(str,ans)))
| h,a = map(int,input().split())
print(-1*(h//(-1*a))) | 0 | null | 108,245,813,368,420 | 274 | 225 |
n,k = map(int,input().split())
p = list(map(int,input().split()))
sum = 0
for i in range(n):
p[i] = (1+p[i])/2
if i<k-1:
sum += p[i]
elif i==k-1:
sum += p[i]
largest = sum
else:
sum = sum + p[i] - p[i-k]
largest = max(largest,sum)
print(largest)
| n,k = map(int,input().split())
p = list(map(int,input().split()))
ps = [p[0]] + [0]*(n-1)
for i in range(1,n):
ps[i] = ps[i-1] + p[i]
maxs = ps[k-1]
for i in range(1,n-k+1):
maxs = max(maxs,ps[i+k-1]-ps[i-1])
print((maxs+k)/2) | 1 | 74,767,356,897,980 | null | 223 | 223 |
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def LIST() : return list(MAP())
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
x, y = MAP()
a = 2*x - y
b = 2*y - x
if a >= 0 and b >= 0 and a % 3 == 0 and b % 3 == 0:
a //= 3
b //= 3
ans = cmb(a+b, a, 10**9+7)
else:
ans = 0
print(ans) | import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def lgcd(l):
return reduce(gcd,l)
def llcm(l):
return reduce(lcm,l)
def powmod(n,i,mod):
return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
return x.bit_length()
def div10(x):
return len(str(x))-(x==0)
def intput():
return int(input())
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x,d=1):
self.setdefault(x,0)
self[x] += d
def list(self):
l = []
for k in self:
l.extend([k]*self[k])
return l
class comb():
def __init__(self, n, mod=None):
self.l = [1]
self.n = n
self.mod = mod
def get(self,k):
l,n,mod = self.l, self.n, self.mod
k = n-k if k>n//2 else k
while len(l)<=k:
i = len(l)
l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
return l[k]
def pf(x):
C = counter()
p = 2
while x>1:
k = 0
while x%p==0:
x //= p
k += 1
if k>0:
C.add(p,k)
p = p+2-(p==2) if p*p<x else x
return C
X,Y=mint()
if (X+Y)%3!=0:
print(0)
exit()
k=abs(X-Y)
N=min(X,Y)-k
if N<0:
print(0)
exit()
n=2*(N//3)+k
C=comb(n,MOD)
print(C.get(N//3)) | 1 | 150,452,548,688,032 | null | 281 | 281 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
import bisect
import heapq
import itertools
import math
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from math import gcd
from operator import add, itemgetter, mul, xor
def cmb(n,r,mod):
bunshi=1
bunbo=1
for i in range(r):
bunbo = bunbo*(i+1)%mod
bunshi = bunshi*(n-i)%mod
return (bunshi*pow(bunbo,mod-2,mod))%mod
mod = 10**9+7
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)]
#bisect.bisect_left(list,key)はlistのなかでkey未満の数字がいくつあるかを返す
#つまりlist[i] < x となる i の個数
#bisect.bisect_right(list, key)はlistのなかでkey以下の数字がいくつあるかを返す
#つまりlist[i] <= x となる i の個数
#これを応用することで
#len(list) - bisect.bisect_left(list,key)はlistのなかでkey以上の数字がいくつあるかを返す
#len(list) - bisect.bisect_right(list,key)はlistのなかでkeyより大きい数字がいくつあるかを返す
#これらを使うときはあらかじめlistをソートしておくこと！
k = I()
d = deque([1,2,3,4,5,6,7,8,9])
for i in range(k):
num = d.popleft()
if num%10 != 0:
d.append(10*num + (num%10) -1)
d.append(10*num + (num%10))
if num%10 != 9:
d.append(10*num + (num%10) + 1)
print(num) | def resolve():
K = int(input())
lunluns = [1, 2, 3, 4, 5, 6, 7, 8, 9]
count = 9
pointer = 0
while K > count:
lunnum = lunluns[pointer]
lunlast = int(str(lunnum)[-1])
if lunlast == 0:
for i in [0, 1]:
lunluns.append(int(str(lunnum)+str(lunlast+i)))
count += 1
elif lunlast == 9:
for i in [-1, 0]:
lunluns.append(int(str(lunnum)+str(lunlast+i)))
count += 1
else:
for i in [-1, 0, 1]:
lunluns.append(int(str(lunnum)+str(lunlast+i)))
count += 1
pointer += 1
print(lunluns[K-1])
if '__main__' == __name__:
resolve() | 1 | 40,014,912,988,430 | null | 181 | 181 |
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
ans = 0
for i in range(0, K):
rsp_K = T[i::K]
rsp_before = ''
for rsp in rsp_K:
if rsp == 'r':
if rsp_before != 'r':
ans += P
rsp_before = 'r'
else:
rsp_before = ''
elif rsp == 's':
if rsp_before != 's':
ans += R
rsp_before = 's'
else:
rsp_before = ''
elif rsp == 'p':
if rsp_before != 'p':
ans += S
rsp_before = 'p'
else:
rsp_before = ''
print(ans)
| def main():
H1,M1,H2,M2,K = map(int,input().split())
time1 = H1*60 + M1
time2 = H2*60 + M2
time = time2-time1
ans = time-K
return ans
print(main())
| 0 | null | 62,338,209,109,372 | 251 | 139 |
S = input()
flg = True
for i in range(len(S)):
if flg == True and S[i] == "h":
flg = False
continue
elif flg == False and S[i] == "i":
flg = True
continue
else:
print("No")
break
else:
if flg == False:
print("No")
else:
print("Yes") | N, K = map(int,input().split())
A = list(map(int,input().split()))
B = [0];BB=[0]
S = set([]);S.add(0)
now = 0
Flag = False
loop_start = -1
if K <= 2*pow(10,5)+10:
for i in range(K):
nxt = A[now]-1
BB.append(nxt)
now = nxt
#print(BB)
print(BB[K]+1)
exit()
for i in range(N*2):
nxt = A[now]-1
#print(now,nxt)
if nxt in S:
if Flag:
if nxt == loop_start:
#print(nxt,i)
loop_cycle = i-loop_num
break
else:
loop_start = nxt
loop_num = i
B.append(nxt)
#print(loop_num,loop_start,B)
Flag = True
else:
B.append(nxt);S.add(nxt)
now = nxt
loop_num += 1-loop_cycle
#print(B,loop_start,loop_cycle,loop_num)
loc = (K-loop_num)%loop_cycle+loop_num
#print(loc)
#print(len(B))
print(B[loc]+1) | 0 | null | 38,121,527,179,008 | 199 | 150 |
def solve():
H,W,M = map(int,input().split())
h_counter = [0] * H
w_counter = [0] * W
opponents = []
for _ in range(M):
h, w = map(lambda x:int(x)-1, input().split())
h_counter[h] += 1
w_counter[w] += 1
opponents.append((h,w))
h_max = max(h_counter)
w_max = max(w_counter)
h_max_area_cnt = 0
h_max_area_nums = set()
for h in range(H):
if h_counter[h] == h_max:
h_max_area_nums.add(h)
h_max_area_cnt += 1
w_max_area_cnt = 0
w_max_area_nums = set()
for w in range(W):
if w_counter[w] == w_max:
w_max_area_nums.add(w)
w_max_area_cnt += 1
max_area_cnt = h_max_area_cnt * w_max_area_cnt
opponent_in_max_area = 0
for h,w in opponents:
if h in h_max_area_nums and w in w_max_area_nums:
opponent_in_max_area += 1
if max_area_cnt > opponent_in_max_area:
print(h_max + w_max)
else:
print(h_max + w_max - 1)
if __name__ == '__main__':
solve()
| S=input()
if S=='hi' or S=='hihi' or S=='hihihi' or S=='hihihihi'or S=='hihihihihi':
print('Yes')
else:
print('No')
| 0 | null | 28,915,098,871,318 | 89 | 199 |
H, W, K = map(int, input().split())
S = [list(map(int, input())) for _ in range(H)]
C = [[0 for w in range(W)] for h in range(H)] #各行のw列目までに1が何個あるか
#print(S)
for h in range(H):
for w in range(W):
#print(h,w)
C[h][w] = C[h][w-1] + S[h][w]
#print(C)
def settify(l):
set_label = set()
i = 0
while l > 0:
if l % 2 == 1:
set_label.add(i)
l //= 2
i += 1
return set_label
def set_label(s):
tmp = 0
for i in s:
tmp += 2**i
return tmp
def sum_set(s, w):
s_list = list(s)
s_list.sort()
s_list.append(H-1)
tmp = 0
it = 0
ans_list = []
for h in range(H):
tmp += C[h][w]
#print(w, tmp)
if h == s_list[it]:
ans_list.append(tmp)
tmp = 0
it += 1
return ans_list
#print(sum_set(set(), 0), sum_set(set(), 1))
ans = 10**8
for l in range(2**(H-1)):
s = settify(l)
lt_prv = [0 for _ in range(len(s)+1)]
lt_now = [0 for _ in range(len(s)+1)]
lt_1minus = [0 for _ in range(len(s)+1)]
tmp = len(s)
w = 0
w_prv = -1
imp = False
while w < W:
lt_now = sum_set(s, w)
flag = False
for j in range(len(s)+1):
if lt_now[j] - lt_prv[j] > K:
flag = True
break
if flag:
if w_prv == w-1:
imp = True
tmp += 1
lt_prv = lt_1minus
w_prv = w-1
w += 1
lt_1minus = lt_now
if imp:
break
#print(s, w-1)
#print(lt_prv, lt_1minus, lt_now)
if not imp:
ans = min(ans, tmp)
print(ans)
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
H,W,K = map(int, readline().split())
S = [list(map(int, readline().strip())) for j in range(H)]
white = 0
for line in S:
white += sum(line)
if white <= K:
print(0)
exit()
# 横線の決め方を全探索
ans = 10**5
#yに横線Patternごとの列合計を作成
#入力例１のPattern[bin(2)]場合、y=[[1,1,1,0,0], [1,0,1,1,2]]
for pattern in range(2**(H-1)):
# 初期化
impossible = False
x = 0
ly = bin(pattern).count("1")
y = [S[0]]
line = 0
for i in range(1,H):
if (pattern >> i-1) & 1:
line += 1
y.append(S[i])
else:
y[line] = [y[line][j] + S[i][j] for j in range(W)]
# 各列の値を加算していく
count = [0]*(ly + 1)
for j in range(W):
for i in range(line+1):
if y[i][j] > K :
impossible = True
break
count[i] += y[i][j]
#print("横Pattern{} 縦列まで {} カウント数{} 縦線の数{}".format(i, j, count[i], x))
#横Patten毎にｊ列までのホワイトチョコ合計数をカウント、
#カウント＞Kとなったら、縦線数を＋１、その列値でカウント数を初期化
if count[i] > K:
x += 1
for i in range(line+1):
count[i] = y[i][j]
break
#x縦線の数 + ly横線の数がAnsより大きくなったらBreak
if x + ly > ans or impossible:
impossible = True
break
if impossible:
x = 10**6
#x縦線の数 + ly横線の数がAnsより小さくなったらAnsを更新
ans = min(ans, x + ly)
print(ans)
main() | 1 | 48,647,088,710,880 | null | 193 | 193 |
import math
p = map(float, raw_input().split())
print("%.10f" %(math.sqrt((p[2] - p[0]) * (p[2] - p[0]) + (p[3] - p[1]) * (p[3] - p[1])))) | import math
val = str(input()).split()
numList = list(map(float, list(val)))
print(math.sqrt(((numList[2]-numList[0]) ** 2) + ((numList[3]-numList[1]) ** 2)))
| 1 | 157,926,512,810 | null | 29 | 29 |
A, B, N = map(int, input().split())
from math import floor
if B - 1 <= N:
x = B - 1
else:
x = N
print(floor(A*x/B) - A*floor(x/B)) | a,b,n = map(int, input().split())
yuka = lambda a,b: (a-(a%b))//b
x = min(n,b-1)
score = yuka(a*(x%b),b)
ans = score
print(ans) | 1 | 28,238,082,837,012 | null | 161 | 161 |
from collections import Counter
N=int(input())
A=list(map(int,input().split()))
Q=int(input())
#BC=[]
#for i in range(Q):
# BC.append(list(map(int,input().split())))
A_sum=sum(A)
A_count=Counter(A)
for i in range(Q):
B,C=(map(int,input().split()))
A_sum+=(C-B)*A_count[B]
A_count[C]+=A_count[B]
A_count[B]=0
print(A_sum) | while True:
H,W = map(int, input().split())
if H == 0 and W == 0:
break
elif H > 301 or W > 301:
break
else:
for i in range(H):
row = '#' * W
print(row)
print("\n", end ='') | 0 | null | 6,531,810,448,098 | 122 | 49 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.