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
|
|---|---|---|---|---|---|---|
N,M = map(int ,input().split())
S = input()
ans = []
i = N
while i > 0:
prev = i
for j in range(max(0, i-M), i):
if S[j] == "0":
ans.append(str(i-j))
i = j
break
if i == prev:
ans = -1
break
if ans == -1:
print(ans)
else:
ans.reverse()
print(*ans)
|
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, M = lr()
S = list(sr())[::-1]
answer = []
count = 0
cur = 0
while True:
next = cur
for i in range(M, 0, -1):
if cur + i > N:
continue
if S[cur+i] == '0':
count += 1
next = cur + i
answer.append(i)
break
else:
continue
if next == cur:
print(-1); exit()
cur = next
if next == N:
break
answer = answer[::-1]
print(*answer)
| 1 | 139,594,270,981,858 | null | 274 | 274 |
N = int(input())
A = list(map(int, input().split()))
sa = sum(A)
last = A[-1]
count = last
root = 1
for i in range(N):
sa -= A[i]
if root <= A[i]:
print(-1)
break
elif root-A[i] > sa:
root = sa + A[i]
count+=root
root = (root-A[i])*2
else:
if count == 0 or root < last:
count = -1
print(count)
|
n,*a=map(int,open(0).read().split())
dp=[0]*(n+1)
dp[0]=1
for i,x in enumerate(a):
if dp[i]<x:
print(-1)
exit()
if i<n:
dp[i+1]=(dp[i]-x)*2
dp[-1]=a[-1]
for i in range(n,0,-1):
if dp[i-1]>a[i-1]+dp[i]:
dp[i-1]=a[i-1]+dp[i]
print(sum(dp))
| 1 | 18,988,986,720,550 | null | 141 | 141 |
n, k = map(int, input().split())
print(sum([i >= k for i in list(map(int,input().split()))]))
|
import math
A, B, H, M = map(int, input().split(' '))
deg = abs(30 * H + 0.5 * M - 6 * M)
if deg >180:
deg = 360 - deg
deg = math.radians(deg)
print(math.sqrt((B - A * math.cos(deg)) ** 2 + (A * math.sin(deg)) ** 2))
| 0 | null | 99,463,872,020,610 | 298 | 144 |
n, m = input().split()
s1 = n*int(m)
s2 = m*int(n)
print(min(s1, s2))
|
n = int(input())
graph = [[] for _ in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
graph[a - 1].append((b - 1, i))
graph[b - 1].append((a - 1, i))
ans = [0] * (n - 1)
from collections import deque
d = deque()
d.append([0, -1])
while d:
point, prev = d.popleft()
color = 1 if prev != 1 else 2
for a, index in graph[point]:
if ans[index] == 0:
ans[index] = color
d.append([a, color])
color += 1 if prev != color + 1 else 2
print(max(ans))
print(*ans, sep='\n')
| 0 | null | 110,494,343,124,370 | 232 | 272 |
import itertools
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
tmp = [n+1 for n in range(N)]
parms = list(itertools.permutations(tmp, N))
for i in range(len(parms)):
if parms[i] == P:
a = i
if parms[i] == Q:
b = i
print(abs(a-b))
|
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
# input = sys.stdin.readline.rstrip()
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return tuple(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 inplt(n): return [tuple(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
n = inp()
P = inpl()
Q = inpl()
i = 0
a = 0
b = 0
for p in permutations(range(1,n+1)):
i += 1
if p == P:
a = i
if p == Q:
b = i
print(abs(a-b))
| 1 | 100,474,676,161,134 | null | 246 | 246 |
line = list(input())
print(''.join(line[:3]))
|
print raw_input()[:3]
| 1 | 14,738,678,161,760 | null | 130 | 130 |
W = input().lower()
ans = 0
while True:
s = input()
if s == "END_OF_TEXT":
break
s = s.lower().split()
ans += s.count(W)
print(ans)
|
import sys
word=input()
text=sys.stdin.read()
print(text.lower().split().count(word))
| 1 | 1,831,385,345,830 | null | 65 | 65 |
def main():
n = input()
non_zero = int(input())
length = len(n)
dp = [[[0, 0] for _ in range(non_zero + 1)] for _ in range(length + 1)]
dp[0][0][0] = 1
for i in range(length):
for j in range(non_zero + 1):
for k in range(2):
now_digit = int(n[i])
for next_d in range(10):
new_i = i + 1
new_j = j
new_k = k
if next_d > 0:
new_j += 1
if new_j > non_zero:
continue
if k == 0:
if next_d > now_digit:
continue
elif next_d < now_digit:
new_k = 1
dp[new_i][new_j][new_k] += dp[i][j][k]
print(sum(dp[length][non_zero]))
if __name__ == '__main__':
main()
|
import math
a, b, C = map(int, input().split())
print('{0}'.format(0.5 * a * b * math.sin(C * math.pi / 180)))
print('{0}'.format(a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(C * math.pi / 180)) ** 0.5))
print('{0}'.format(b * math.sin(C * math.pi / 180)))
| 0 | null | 38,071,374,333,590 | 224 | 30 |
#!/usr/bin/env python3
def main():
A, B = map(int, open(0).read().split())
if (A < 10 and B < 10):
print(A * B)
else:
print('-1')
main()
|
a,b=map(int, input().split())
A = [str(b)]*a
B = [str(a)]*b
if a >= b:
print(''.join(A))
if a < b:
print(''.join(B))
| 0 | null | 120,976,438,064,720 | 286 | 232 |
# E - Colorful Hats 2
MOD = 10**9+7
N = int(input())
A = list(map(int,input().split()))
count = [0]*N+[3]
used = [0]*(N+1)
ans = 1
for x in A:
ans = (ans*(count[x-1]-used[x-1]))%MOD
count[x] += 1
used[x-1] += 1
print(ans)
|
N = int(input())
s = input()
w = 0
r = s.count('R')
ans = min(N, r)
for i in range(N):
if s[i] == 'R':
r -= 1
else:
w += 1
ans = min(ans, max(w, r))
print(ans)
| 0 | null | 68,003,165,368,432 | 268 | 98 |
N = int(input())
if N % 2 != 0:
print((N + 1) // 2 - 1)
else:
print(N//2 -1)
|
def solve(n):
return (n - 1) // 2
assert solve(4) == 1
assert solve(999999) == 499999
n = int(input())
print(solve(n))
| 1 | 153,585,444,980,380 | null | 283 | 283 |
n=input()
S=['S 1','S 2','S 3','S 4','S 5','S 6','S 7','S 8','S 9','S 10','S 11','S 12','S 13']
H=['H 1','H 2','H 3','H 4','H 5','H 6','H 7','H 8','H 9','H 10','H 11','H 12','H 13']
C=['C 1','C 2','C 3','C 4','C 5','C 6','C 7','C 8','C 9','C 10','C 11','C 12','C 13']
D=['D 1','D 2','D 3','D 4','D 5','D 6','D 7','D 8','D 9','D 10','D 11','D 12','D 13']
cards=[S,H,C,D]
for i in range(n):
exist=raw_input()
if 'S' in exist:
cards[0].remove(exist)
if 'H' in exist:
cards[1].remove(exist)
if 'C' in exist:
cards[2].remove(exist)
if 'D' in exist:
cards[3].remove(exist)
for j in range(4):
for i in cards[j]:
print i
|
lst = [True for i in range(52)]
n = int(input())
for i in range (n):
suit, rank = input().split()
rankn = int(rank)
if suit == 'S':
lst[rankn-1] = False
elif suit == 'H':
lst[rankn+12] = False
elif suit == 'C':
lst[rankn+25] = False
else:
lst[rankn+38] = False
for i in range(52):
tf = lst[i]
if i <= 12 and tf:
print ('S %d' % (i+1))
elif 12 < i <= 25 and tf:
print ('H %d' % (i-12))
elif 25 < i <= 38 and tf:
print ('C %d' % (i-25))
elif tf:
print ('D %d' % (i-38))
| 1 | 1,029,192,780,968 | null | 54 | 54 |
import numpy as np
N, *A = map(int, open(0).read().split())
A = np.array(A, dtype=np.int64)
mod = 10**9 + 7
ans = 0
for i in range(60):
mask = 1 << i
cnt = np.count_nonzero(A&mask)
x = cnt * (N-cnt)
x *= mask % mod
ans += x
ans %= mod
print(ans)
|
# ??¬????????±
room = [[[0 for a in range(10)] for b in range(3)] for c in range(4)]
n = int(input())
for cnt0 in range(n):
# ?????°??????????????????
a,b,c,d = map(int,input().split())
room[a-1][b-1][c-1]+=d
# ???????????±??????
for cnt1 in range(4):
for cnt2 in range(3):
for cnt3 in range(10):
# OutputPrit
print(" "+str(room[cnt1][cnt2][cnt3]),end="")
# ??????
print ()
if cnt1<3:
# ????£???????####################(20??????#)?????????
print("#"*20)
| 0 | null | 62,211,597,005,210 | 263 | 55 |
def readinput():
n,k=map(int,input().split())
okashi=[]
for _ in range(k):
d=int(input())
l=list(map(int,input().split()))
okashi.append(l)
return n,k,okashi
def main(n,k,okashi):
sunuke=[0]*(n+1)
for l in okashi:
for su in l:
sunuke[su]+=1
count=0
for i in range(n):
if sunuke[i+1]==0:
count+=1
return count
if __name__=='__main__':
n,k,okashi=readinput()
ans=main(n,k,okashi)
print(ans)
|
N,K=map(int,input().split())
A=[]
B=[]
C=[]
D=[]
for i in range(2*K):
A.append(list(map(int,input().split())))
for i in range(K):
B.append(A[2*i-1])
for i in range(K):
for j in range(len(B[i])):
C.append(B[i][j])
for i in range(1,N+1):
if i not in C:
D.append(i)
print(len(D))
| 1 | 24,498,021,826,816 | null | 154 | 154 |
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return map(int,input().split())
def onem(): #Nとかの取得
return int(input())
def s(x): #圧縮
a = []
if len(x) == 0:
return []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(map(max,x))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
def pow_k(x, n):
ans = 1
while n:
if n % 2:
ans *= x
x *= x
n >>= 1
return ans
"""
def nibu(x,n,r):
ll = 0
rr = r
while True:
mid = (ll+rr)//2
if rr == mid:
return ll
if (ここに評価入れる):
rr = mid
else:
ll = mid+1
"""
n = onem()
a = l()
if n % 2 == 0:
po = [a[i] for i in range(n)]
for i in range(n-3,-1,-1):
po[i] += po[i+2]
ans = sum(a[0::2])
ans = max(ans,sum(a[1::2]))
co = 0
for i in range(0,n,2):
if i+1 <= n-1:
ans = max(ans,co+po[i+1])
else:
ans = max(ans,co)
co += a[i]
print(ans)
else:
po = [a[i] for i in range(n)]
mi = [-Max for i in range(n)]
for i in range(n-3,-1,-1):
po[i] += po[i+2]
ans = sum(a[1::2])
ans = max(ans,sum(a[0::2]) - a[-1])
#print(ans)
l1 = [-Max for i in range(n)]
for i in range(n):
if i != n-1:
l1[i] = po[i+1]
"""
co = 0
for i in range(0,n,2):
if i != n-1:
l1[i] = co + po[i+1]
else:
l1[i] = co
co += a[i]
co = 0
for i in range(1,n,2):
if i != n-1:
l1[i] = co + po[i+1]
else:
l1[i] = co
co += a[i]
"""
for i in range(n-1,-1,-1):
if i == n-1:
continue
elif i == n-2:
mi[i] = l1[i]
else:
mi[i] = max(mi[i+2]+a[i],l1[i])
l1 = mi
"""
for i in range(n-1,-1,-1):
if i <= n-3:
mi[i] = min(mi[i+2],a[i])
else:
mi[i] = a[i]
print(mi)
"""
l2 = [-Max for i in range(n)]
for i in range(n-1,-1,-1):
l2[i] = po[i]
#print(l1)
#print(l2)
co = 0
for i in range(0,n,2):
if i + 2 <= n-1:
#print(ans,co+l1[i+1],co+l2[i+2])
ans = max(ans,co+l1[i+1],co+l2[i+2])
elif i+1 <= n-1:
ans = max(ans,co+l1[i+1])
else:
ans = max(ans,co)
co += a[i]
co = 0
#print(ans)
for i in range(1,n,2):
#print(ans,co+l1[i+1])
ans = max(ans,co+po[i+1])
#ans = max(ans,co+l1[i+1])
co += a[i]
#print("po:"+str(mi[1]))
print(ans)
|
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
INF = float("inf")
import bisect
N = int(input())
a = [0] + list(map(int, input().split()))
o = [a[2*i+1] for i in range(N//2)]
o = list(itertools.accumulate(o))
dp = [0 for i in range(N+1)]
dp[0] = dp[1] = 0
dp[2] = max(a[1], a[2])
if N > 2: dp[3] = max([a[1], a[2], a[3]])
if N > 3:
for i in range(4, N+1):
if i % 2 == 0:
dp[i] = max(dp[i-2] + a[i], o[(i-3)//2] + a[i-1])
else:
dp[i] = max([dp[i-2] + a[i], dp[i-3] + a[i-1], o[(i-2)//2] ])
print(dp[N])
| 1 | 37,354,428,960,552 | null | 177 | 177 |
while True:
[n, m] = [int(x) for x in raw_input().split()]
if [n, m] == [0, 0]:
break
data = []
for x in range(n, 2, -1):
for y in range(x - 1, 1, -1):
for z in range(y - 1, 0, -1):
s = x + y + z
if s < m:
break
if s == m:
data.append(s)
print(len(data))
|
n,k=map(int,input().split())
A=list(map(int,input().split()))
C=[n for _ in range(n)]
for loop in range(k):
B=[0 for _ in range(n)]
for i in range(n):
l,r=max(0,i-A[i]),i+A[i]+1
B[l] +=1
if r<n:B[r] -=1
for i in range(n-1):
B[i+1]=B[i]+B[i+1]
A=B
if A==C:break
print(*A)
| 0 | null | 8,340,546,444,150 | 58 | 132 |
N, K, C = map(int,input().split())
S = list(input())
def solve(List):
ans = []
i = 0
while i < N:
if List[i] == 'o':
ans.append(i+1)
i += C
i += 1
return ans
n = solve(S)
if len(n) > K:
pass
else:
r = solve(S[::-1])
r = list(map(lambda x: N+1-x, r[::-1]))
ans = list(set(n) & set(r))
ans.sort()
for i in ans:
print(i)
|
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)
| 0 | null | 88,108,817,897,006 | 182 | 272 |
import numpy as np
def solve(H, A, B):
A_max = A.max()
dp = np.zeros(H + A_max + 1, dtype=np.int64)
for i in range(A_max + 1, H + A_max + 1):
dp[i] = np.min(dp[i - A] + B)
return dp[-1]
H, N, *AB = map(int, open(0).read().split())
A = np.array(AB[::2], dtype=np.int64)
B = np.array(AB[1::2], dtype=np.int64)
print(solve(H, A, B))
|
h,n = map(int,input().split())
M = []
max_val = 0
for _ in range(n):
a,b = map(int,input().split())
max_val = max(max_val,a)
M.append((a,b))
dp = [float('inf')]*(h+1+max_val)
dp[0] = 0
for i in range(1,h+1+max_val):
for j in range(n):
dp[i] = min(dp[i-M[j][0]] + M[j][1],dp[i])
print(min(dp[h:-1]))
| 1 | 81,068,573,594,518 | null | 229 | 229 |
n = int(input())
s, t = input().split()
ans = ""
for x in range(n):
ans = ans + s[x]
ans = ans + t[x]
print(ans)
|
a=list(map(int,input().split()))
if a[0]>a[1]*2:
print(a[0]-a[1]*2)
else:
print('0')
| 0 | null | 139,604,465,329,758 | 255 | 291 |
n,k = map(int,input().split())
w = [int(input()) for _ in range(n)]
left = max(w)-1
right = sum(w)
while (right - left) > 1:
mid = (left + right)//2
count = 1
c = 0
for s in w:
if mid < c + s:
c = s
count += 1
else:
c += s
if count <= k:
right = mid
else:
left = mid
print(right)
|
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
import numpy as np
INF = float("inf")
#d = defaultdict(int)
#d = defaultdict(list)
#N = int(input())
#A = list(map(int,input().split()))
#S = list(input())
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = [int(input()) for _ in range(N)]
#S = [list(input())[:-1] for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
MOD = 998244353
N = int(input())
D = list(map(int,input().split()))
d = defaultdict(int)
for i in D:
d[i] += 1
ans = 1
if d[0] != 1 or D[0] != 0:
print(0)
else:
for i in range(1,N):
ans = ans*pow(d[i-1],d[i],MOD)
print(ans%MOD)
| 0 | null | 77,867,397,524,630 | 24 | 284 |
s=input()
n=len(s)
K=int(input())
dp=[[[0] * 5 for _ in range(2)] for _ in range(n+1)]
dp[0][0][0]=1
for i in range(n):
ni= int(s[i])
for k in range(4):
# smaller 1 -> 全部OK
dp[i + 1][1][k + 1] += dp[i][1][k] * 9;
dp[i + 1][1][k] += dp[i][1][k];
# smaller 0,next smaller 1 -> nowより小さいのを全部
# 次の桁からsmallerであるためにはN＜ni であることが必要で
# Nは0より大きい必要がある。（0より小さいものがない＝確定しない
if (ni > 0):
dp[i + 1][1][k + 1] += dp[i][0][k] * (ni - 1)
dp[i + 1][1][k] += dp[i][0][k]
# smaller 0,next smaller 0 -> nowだけ
if (ni > 0) :
dp[i + 1][0][k + 1] = dp[i][0][k]
else:
dp[i + 1][0][k] = dp[i][0][k]
ans=dp[n][0][K] + dp[n][1][K]
print(ans)
|
N = int(input())
A = list(map(int, input().split()))
kane=1000
kabu=0
for i in range(N-1):
#print(kane,kabu)
if A[i]<A[i+1]:
kane=kabu*A[i]+kane
kabu=kane//A[i]
kane=kane-kabu*A[i]
else:
kane=kabu*A[i]+kane
kabu=0
print(kane+kabu*A[N-1])
| 0 | null | 41,821,023,236,810 | 224 | 103 |
n = int(input())
tscore = 0
hscore = 0
for i in range(n):
wlist = []
t,h = map(str, input().split())
wlist.append(t)
wlist.append(h)
order = sorted(wlist, key = str.lower)
if (t.lower() == h.lower()):
tscore += 1
hscore += 1
elif (order[1] == t):
tscore += 3
elif (order[1] ==h ):
hscore += 3
print(tscore, hscore)
|
S, W = map(int, input().split())
print('safe') if S>W else print('unsafe')
| 0 | null | 15,674,721,022,730 | 67 | 163 |
import math
r = float(raw_input())
print "%.7f %.7f"%(math.pi*r*r, 2*math.pi*r)
|
from math import pi
r = float(input())
S = r * r * pi
L = 2 * r * pi
print(f'{(S):.6f} {(L):.6f}')
| 1 | 636,946,757,572 | null | 46 | 46 |
def main():
s, w = map(int, input().split())
if s <= w:
ans = 'unsafe'
else:
ans = 'safe'
print(ans)
if __name__ == "__main__":
main()
|
hitsuji, okami = map(int, input().split())
if hitsuji <= okami:
print('unsafe')
else:
print('safe')
| 1 | 29,239,917,364,448 | null | 163 | 163 |
n = int(input())
s = input()
r, g, b = s.count("R"), s.count("G"), s.count("B")
cnt = 0
for i in range(n):
for j in range(i + 1, n):
try:
k = j + (j - i)
if s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
cnt += 1
except:
pass
print(r * g * b - cnt)
|
N = input()
n = len(N)
dp = [[0,0]for i in range(0,n,1)]#[i][0]その桁はピッタリ払う[i][1]一つ上の桁を１枚つかう ときの合計枚数
dp[n-1][0] = int(N[n-1])
dp[n-1][1] = int(10 - int(N[n-1]) + 1 )#一つ上の桁で払うandおつり
for i in range(n-2,-1,-1):
dp[i][0] = int(N[i]) + min(dp[i+1][0],dp[i+1][1])
dp[i][1] = 10 - int(N[i]) + 1 + min(dp[i+1][0],dp[i+1][1] - 2)#次の桁で払った、の＋１を取り消すマイナス１と繰り下がりの
print(min(dp[0][0],dp[0][1]))
| 0 | null | 53,769,906,865,650 | 175 | 219 |
X, Y, Z = list(map(int, input().split()))
print(Z, X, Y)
|
num = list(map(int,input().split()))
print(num[2],num[0],num[1])
| 1 | 38,145,504,908,928 | null | 178 | 178 |
from collections import deque # BFSはこいつを使え！
def dfs(n):
adj = 'abcdefghij'
stack = deque(['a'])
while stack:
# node = stack.pop(0) # pop(0)がO(n)かかっているのでとても遅い！
node = stack.popleft()
if len(node) == n:
print(node)
else:
for child in adj[:len(set(node))+1]:
stack.append(node+child)
return -1
# 再帰での実装
# def dfs(s,n,adj):
# if len(s) == n:
# print(s)
# else:
# for child in adj[:len(set(s))+1]:
# dfs(s+child,n,adj)
# return -1
def main():
import sys
def input(): return sys.stdin.readline().rstrip()
n = int(input())
# adj = 'abcdefghij'
# dfs('a',n,adj)
dfs(n)
if __name__ == '__main__':
main()
|
n, m = map(int, input().split())
a = map(int, input().split())
res = n - sum(a)
if res < 0:
print(-1)
else:
print(res)
| 0 | null | 42,253,144,056,608 | 198 | 168 |
a,b = map(int,input().split())
for i in range(1,1251):
if int(i*0.08)==a and int(i*0.1)==b:
print(i); break
else:
print('-1')
|
import math
a,b = map(int,input().split())
c = math.ceil
min8, max8 = c(a*12.5), c((a+1)*12.5)
min10, max10 = c(b*10), c((b+1)*10)
l8, l10 = list(range(min8, max8)), list(range(min10, max10))
s8, s10 = set(l8), set(l10)
ss = s8 & s10
#print(min8, max8, min10, max10)
print(min(ss) if len(ss) >0 else -1)
#print(238*0.08)
| 1 | 56,416,828,215,498 | null | 203 | 203 |
R = int(input())
print(6.28*R)
|
def main():
from collections import namedtuple
from operator import attrgetter
Dish = namedtuple('Dish', 'time deliciousness')
N, T = map(int, input().split())
dishes = []
for _ in range(N):
a, b = map(int, input().split())
d = Dish(time=a, deliciousness=b)
dishes.append(d)
dishes.sort(key=attrgetter('time'))
dp = [0] * T
ma = 0
ret = 0
for d in dishes:
ret = max(ret, ma + d.deliciousness)
for t in range(T - 1, d.time - 1, -1):
dp[t] = max(dp[t], dp[t - d.time] + d.deliciousness)
ma = max(ma, dp[t])
print(ret)
if __name__ == '__main__':
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
| 0 | null | 91,550,160,118,372 | 167 | 282 |
x, y = map(int, input().split())
money = [300000, 200000, 100000]
if x == 1 and y == 1:
print(1000000)
elif x <= 3 and y <= 3:
print(money[x - 1] + money[y - 1])
elif x <= 3:
print(money[x - 1])
elif y <= 3:
print(money[y - 1])
else:
print(0)
|
N=int(input())
A=list(map(int,input().split()))
mod=10**9+7
buf=0
s=0
for k in range(N-1):
buf=(buf+A[N-1-k])%mod
s=(s+A[N-2-k]*buf)%mod
print(s)
| 0 | null | 72,176,700,904,812 | 275 | 83 |
n = int(input())
print(sum(i for i in range(1, n + 1) if i % 3 != 0 and i % 5 != 0))
|
import math
A, B, N = map(int,input().split())
if N < B:
temp1 = math.floor(A*1/B) - A*math.floor(1/B)
temp2 = math.floor(A*N/B) - A*math.floor(N/B)
ans = max(temp1, temp2)
if N >= B:
temp1 = math.floor(A*1/B) - A*math.floor(1/B)
temp2 = math.floor(A*(B-1)/B) - A*math.floor((B-1)/B)
ans = max(temp1, temp2)
print(ans)
| 0 | null | 31,575,402,522,088 | 173 | 161 |
h = []
w = []
while True:
a,b = map(int, raw_input().split())
h.append(a)
w.append(b)
if a == 0 and b == 0:
break
for h,w in zip(h,w):
if h == 0 and w == 0:
break;
else:
r = "#"
for x in xrange(w-1):
r = r + "#"
for x in xrange(h):
print r
print
|
n=int(input())
s=input()
from itertools import product
cnt=0
for i,j in product("0123456789",repeat=2):
try:
ind_i=s.index(i)
except:
continue
try:
ind_j=s.rindex(j)
except:
continue
if ind_i>ind_j:
continue
for k in "0123456789":
cnt+=(k in s[ind_i+1:ind_j])
print(cnt)
| 0 | null | 64,532,695,077,630 | 49 | 267 |
import time as ti
class MyQueue(object):
"""
My Queue class
Attributes:
queue: queue
head
tail
"""
def __init__(self):
"""Constructor
"""
self.length = 50010
self.queue = [0] * self.length
# counter = 0
# while counter < self.length:
# self.queue.append(Process())
# counter += 1
self.head = 0
self.tail = 0
# def enqueue(self, name, time):
def enqueue(self, process):
"""enqueue method
Args:
name: enqueued process name
time: enqueued process time
Returns:
None
"""
self.queue[self.tail] = process
# self.queue[self.tail].name = name
# self.queue[self.tail].time = time
self.tail = (self.tail + 1) % self.length
def dequeue(self):
"""dequeue method
Returns:
None
"""
# self.queue[self.head].name = ""
# self.queue[self.head].time = 0
self.queue[self.head] = 0
self.head = (self.head + 1) % self.length
def is_empty(self):
"""check queue is empty or not
Returns:
Bool
"""
if self.head == self.tail:
return True
else:
return False
def is_full(self):
"""chech whether queue is full or not"""
if self.tail - self.head >= len(self.queue):
return True
else:
return False
class Process(object):
"""process class
"""
def __init__(self, name="", time=0):
"""constructor
Args:
name: name
time: time
"""
self.name = name
self.time = time
def forward_time(self, time):
"""time forward method
Args:
time: forward time interval
Returns:
remain time
"""
self.time -= time
return self.time
def time_forward(my_queue, interval, current_time,):
"""
Args:
my_queue: queue
interval: time step interval
current_time: current time
"""
value = my_queue.queue[my_queue.head].forward_time(interval)
if value <= 0:
current_time += (interval + value)
print my_queue.queue[my_queue.head].name, current_time
my_queue.dequeue()
elif value > 0:
current_time += interval
# name, time = my_queue.queue[my_queue.head].name, \
# my_queue.queue[my_queue.head].time
my_queue.enqueue(my_queue.queue[my_queue.head])
my_queue.dequeue()
return current_time
my_queue = MyQueue()
n, q = [int(x) for x in raw_input().split()]
counter = 0
while counter < n:
name, time = raw_input().split()
my_queue.enqueue(Process(name, int(time)))
counter += 1
# end_time_list = []
current_time = 0
while not my_queue.is_empty():
current_time = time_forward(my_queue, q, current_time)
|
S = input()
Count = 0
for T in range(0,len(S)//2):
if S[T]!=S[-T-1]:
Count += 1
print(Count)
| 0 | null | 59,789,180,166,660 | 19 | 261 |
import sys
N = int(sys.stdin.readline().rstrip())
A = list(map(int, sys.stdin.readline().rstrip().split()))
mod = 10**9 + 7
ans = 1
cnt = [0] * N
for a in A:
if a > 0:
ans *= (cnt[a - 1] - cnt[a])
cnt[a] += 1
ans %= mod
for i in range(cnt[0]):
ans *= 3 - i
print(ans % mod)
|
n=int(input())
a=list(map(int,input().split()))
#R,B,Gの順に埋めていく
#R,B,Gの現在の数を保存する
cnt={'R':0,'B':0,'G':0}
ans=1
for i in range(n):
count=0
edi=0
for j in 'RBG':
if cnt[j]==a[i]:
count+=1
if edi==0:
cnt[j]+=1
edi=1
ans*=count
print(ans%(10**9+7))
| 1 | 130,283,916,002,750 | null | 268 | 268 |
import math
I=list(map(int,input().split()))
X=(2*I[1]-I[0])//3
Y=(2*I[0]-I[1])//3
n=X+Y
r=X
if (X<0 or Y<0 or (I[0]+I[1])%3!=0):
print(0)
exit()
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
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)
print(cmb(n, r, p))
|
# Aizu Problem ITP_1_8_B: Sum of Numbers
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def digit_sum(n):
s = 0
while n > 0:
s += n % 10
n //= 10
return s
while True:
n = int(input())
if n == 0:
break
print(digit_sum(n))
| 0 | null | 76,151,681,942,470 | 281 | 62 |
n, m = map(int,input().split())
lst = list(map(int,input().split()))
lst2 = []
for i in range(n):
lst3 = [lst[i]]
lst2.append(lst3)
for i in range(m):
a, b = map(int,input().split())
a = a - 1
b = b - 1
lst2[a].append(lst2[b][0])
lst2[b].append(lst2[a][0])
ans = 0
for i in range(n):
x = lst2[i][0]
lst2[i].sort()
lst2[i].reverse()
if (len(lst2[i]) == 1):
ans = ans + 1
elif (x == lst2[i][0]):
lst2[i].pop(0)
y = lst2[i][0]
if (x != y):
ans = ans + 1
print(ans)
|
import math
r = float(input())
s = r * r * math.pi
l = r * 2.0 * math.pi
print("{:f} {:f}".format(s, l))
| 0 | null | 12,959,713,025,280 | 155 | 46 |
import math
A, B, C, D = map(int, input().split())
T_kougeki = C / B # 高橋くんが攻撃して、青木くんの体力が0になるまでの回数
A_kougeki = A / D # 青木くんが攻撃して、高橋くんの体力0になるまでの回数
if math.ceil(T_kougeki) <= math.ceil(A_kougeki): #切り上げた値で少ない方、同数なら先行の高橋くんの勝ち
print('Yes')
else:
print('No')
|
print("aA"[input()<"a"])
| 0 | null | 20,492,383,873,570 | 164 | 119 |
s = list(input())
num = 0
n = len(s)
l = []
i = 0
while i < n:
if s[i] == '<':
l.append(num)
num+=1
i+=1
if i==n:
l.append(num)
else:
cur = 0
while i < n and s[i]=='>':
i+=1
cur+=1
if cur <= num:
l.append(num)
cur-=1
l.append((cur*(cur+1))//2)
num = 0
print(sum(l))
|
S = input()
if S =="AAA" or S == "BBB":
result = "No"
else:
result = "Yes"
print(result)
| 0 | null | 105,425,454,749,002 | 285 | 201 |
from collections import defaultdict
def bfs(s):
q = [s]
while q != []:
p = q[0]
del q[0]
for node in adj[p]:
if not visited[node]:
visited[node] = True
q.append(node)
n,m = map(int,input().split())
adj = defaultdict(list)
visited = [False]*(n+1)
comp = 0
for _ in range(m):
a,b = map(int,input().split())
adj[a].append(b)
adj[b].append(a)
for i in range(1,n+1):
if not visited[i]:
comp+=1
bfs(i)
print(comp-1)
|
from sys import stdin
input = stdin.readline
K = int(input())
print("ACL" * K)
| 0 | null | 2,276,217,915,840 | 70 | 69 |
while True:
a, b = map(int, input().split())
if a == 0 and b == 0:
break;
for i in range(0, a):
if i % 2 == 0:
print(("#." * int((b + 1) / 2))[:b])
else:
print((".#" * int((b + 1) / 2))[:b])
print("")
|
def check(s, p):
for i in range(len(s)):
count = 0
for j in range(len(p)):
if s[(i+j) % len(s)] != p[j]:
break
count += 1
if count == len(p):
return True
return False
s = raw_input()
p = raw_input()
flag = check(s, p)
if flag:
print("Yes")
else:
print("No")
| 0 | null | 1,299,850,132,648 | 51 | 64 |
N = int(input())
X = list(map(int, input().split()))
def cost(p):
res = 0
for x in X:
res += (x - p)**2
return res
m = sum(X) // N
print(min(cost(m), cost(m+1)))
|
import os, sys, re, math
N = int(input())
X = [int(n) for n in input().split()]
d = [i ** 2 for i in range(101)]
min_v = 100 ** 2 * 100
for i in range(1, 101):
min_v = min(min_v, sum(d[abs(x - i)] for x in X))
print(min_v)
| 1 | 65,229,476,114,700 | null | 213 | 213 |
if __name__ == '__main__':
try:
n = int(raw_input())
except:
print 'the first input must be integer value!'
exit()
genoms = set([])
answers = []
for _ in range(n):
values = raw_input().split()
order = values[0]
genom = values[1]
if order == "insert":
genoms.add(genom)
else:
# TODO: fasten here!
answers.append('yes' if genom in genoms else 'no' )
# print(genoms)
# print(answers)
for answer in answers:
print answer
|
n = int(input())
d = set()
for i in range(n):
com = input().split()
if com[0] == "insert":
d.add(com[1])
else:
print("yes" if com[1] in d else "no")
| 1 | 75,092,456,450 | null | 23 | 23 |
t = ""
D = set([])
for _ in range(5):
t += "hi"
D.add(t)
print("Yes" if input() in D else "No")
|
s = input()
L = s.split("hi")
ans = 1
for x in L:
if x != "":
ans = 0
print(["No","Yes"][ans])
| 1 | 53,151,300,194,272 | null | 199 | 199 |
from math import ceil
n = int(input())
A = list(map(int,input().split()))[::-1]
mn,mx = A[0], A[0]
step = [[mn,mx]]
for i in range(1, n+1):
mn = ceil(mn/2) + A[i]
mx = mx + A[i]
step.append([mn,mx])
if not mn<=1 and 1<=mx:
print(-1)
else:
step = step[::-1]
A = A[::-1]
now = 1
ans = 1
for i in range(1, n+1):
now = min(step[i][1],
(now-A[i-1])*2)
ans += now
print(ans)
|
n,*a=map(int,open(0).read().split())
dp=[0]*(n+1)
dp[0]=1
for i,x in enumerate(a):
if dp[i]<x:
print(-1)
exit()
if i<n:
dp[i+1]=(dp[i]-x)*2
dp[-1]=a[-1]
for i in range(n,0,-1):
if dp[i-1]>a[i-1]+dp[i]:
dp[i-1]=a[i-1]+dp[i]
print(sum(dp))
| 1 | 19,034,695,639,632 | null | 141 | 141 |
import sys
input = sys.stdin.readline
import numpy as np
N, M = map(int, input().split())
L = list(map(int, input().split()))
A = np.zeros(1<<18)
for i in L:
A[i] += 1
C = (np.fft.irfft(np.fft.rfft(A) * np.fft.rfft(A)) + .5).astype(np.int64)
G = C.cumsum()
count = np.searchsorted(G, N*N-M)
rest = N*N-M - G[count-1]
temp = (C[:count]*np.arange(count, dtype=np.int64)).sum() + count*rest
ans = sum(L)*2*N - temp
print(ans)
|
import bisect
n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
r=a[n-1]*2+1
l=0
while r-l>=2:
mid=(l+r)//2
#mid以上はいくつあるか
#答えはl以上r未満
cnt=0
for i in range(n):
cnt+=n-bisect.bisect_left(a,mid-a[i])
if cnt>=k:
l=mid
else:
r=mid
#lだとk個以上 rだとk個未満
ans,p,=0,0
b=[0]
for i in range(n):
p+=a[i]
b.append(p)
for i in range(n):
q=bisect.bisect_left(a,r-a[i])
ans+=b[n]-b[q]
ans+=a[i]*(n-q)
k-=n-q
ans+=l*k
print(ans)
| 1 | 108,137,273,998,104 | null | 252 | 252 |
s, t = input().split()
a, b = map(int, input().split())
u = input()
print(a - (s == u), b - (t == u))
|
string = input()
if string[len(string)-1] == "s":
print(string+'es')
else:
print(string+'s')
| 0 | null | 37,347,120,070,690 | 220 | 71 |
h = int(input())
i =1
while h>1:
h //=2
i += 1
print(2**i-1)
|
h = int(input())
cnt = 0
while h > 1:
h //= 2
cnt += 1
print(2**(cnt+1)-1)
| 1 | 80,442,804,682,900 | null | 228 | 228 |
x,y = map(int,input().split())
a = [0]*210
a[:3] = [300000, 200000, 100000]
if x == y and x == 1:
print(1000000)
else:
print(a[x-1] + a[y-1])
|
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7
#main code here!
x,y=MI()
ans=0
if x<=3:
ans+=(4-x)*(10**5)
if y<=3:
ans+=(4-y)*(10**5)
if x==1 and y==1:
ans+=4*10**5
print(ans)
if __name__=="__main__":
main()
| 1 | 140,889,995,073,800 | null | 275 | 275 |
#!/usr/bin/env python3
import sys, math
sys.setrecursionlimit(300000)
def solve(H: int, W: int, N: int):
ret = min(math.ceil(N / H), math.ceil(N / W))
print(ret)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
H = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
N = int(next(tokens)) # type: int
solve(H, W, N)
if __name__ == '__main__':
main()
|
import math
a=int(input())
b=int(input())
x=int(input())
print(math.ceil(x/max(a,b)))
| 1 | 88,919,854,377,428 | null | 236 | 236 |
a, b = map(int, input().split())
for i in range(max(a, b)):
print(str(min(a, b)), end="")
|
a,b = input().split()
print(a*int(b)) if a < b else print(b*int(a))
| 1 | 84,444,716,519,576 | null | 232 | 232 |
from sys import stdin
inp = lambda : stdin.readline().strip()
def dfs_iter(n):
stack = [n]
ans = 0
while stack:
node = stack.pop()
if not visited[node]:
visited[node] = True
ans += 1
for child in adj[node]:
if not visited[child]:
stack.append(child)
return ans
n, m = [int(x) for x in inp().split()]
adj = [set() for i in range(n)]
visited = [False]*n
for i in range(m):
u, v = [int(x) for x in inp().split()]
adj[u - 1].add(v - 1)
adj[v - 1].add(u - 1)
ans = 0
for i in range(n):
if not visited[i]:
ans = max(ans, dfs_iter(i))
print(ans)
|
MOD = 1000000007
def mod_pow(x , y):
if y == 0:
return 1
if y == 1:
return x
r = mod_pow(x , y // 2)
r2 = (r * r) % MOD
if y % 2 == 0:
return r2 % MOD
else:
return (r2 * x) % MOD
N , K = map(int , input().split())
result = 0
memo = {}
for g in range(K , 0 , -1):
comb = mod_pow(K // g , N)
for j in range(2 , K // g + 1):
comb = (comb - memo[j * g] + MOD) % MOD
memo[g] = comb
result = (result + comb * g) % MOD
print(result)
| 0 | null | 20,270,236,745,950 | 84 | 176 |
h,a = [int(x) for x in input().split()]
print((h+a-1)//a)
|
num=(int)(input())
n=num//100
amari=num%100
if num <= 99 or amari / n > 5:
print(0)
else:
print(1)
| 0 | null | 102,043,087,726,458 | 225 | 266 |
n=int(input())
x=list(map(int,input().split()))
ans=10**9
for i in range(1,101):
tmp=0
for j in range(n):
tmp+=(i-x[j])*(i-x[j])
ans=min(ans,tmp)
print(ans)
|
n=int(input())
l=list(map(int,input().split()))
s=sum(l)//n
k=1+(sum(l)//n)
c=0
x=0
for i in range(n):
c+=(l[i]-s)**2
for i in range(n):
x+=(l[i]-k)**2
print(min(c,x))
| 1 | 65,318,210,540,938 | null | 213 | 213 |
store = {"SUN":7,"MON":6,"TUE":5,"WED":4,"THU":3,"FRI":2,"SAT":1}
s = input()
print(store[s])
|
from collections import deque
N, M, K = map(int, input().split())
friend = [list(map(int, input().split())) for _ in range(M)]
block = [list(map(int, input().split())) for _ in range(K)]
f = [set() for _ in range(N + 1)]
b = [set() for _ in range(N + 1)]
for i, j in friend:
f[i].add(j)
f[j].add(i)
for i, j in block:
b[i].add(j)
b[j].add(i)
stack = deque()
ans = [0] * (N + 1)
visited = [0] * (N + 1)
for i in range(1, N + 1):
if visited[i]:
continue
# setは{}で書く
link = {i}
stack.append(i)
visited[i] = 1
while stack:
n = stack.pop()
# nのフレンド全員について
for j in f[n]:
if visited[j] == 0:
stack.append(j)
visited[j] = 1
# link(set)に追加
link.add(j)
for i in link:
# 全体-既にフレンドの人数-ブロックした人数-自分自身
# set同士で積集合をとる
ans[i] = len(link) - len(link & f[i]) - len(link & b[i]) - 1
print(*ans[1:])
| 0 | null | 97,330,144,274,780 | 270 | 209 |
s = input()[::-1]
cnts = [0] * 2019
cnts[0] = 1
n, d = 0, 1
for char in s:
n = (n + int(char) * d) % 2019
d = d * 10 % 2019
cnts[n] += 1
ans = 0
for cnt in cnts:
ans += cnt * (cnt - 1) // 2
print(ans)
|
import copy
s = list(input())
s.reverse()
n = len(s)
MOD = 2019
m = [0] * n
msum = [0] * (n+1)
cnt = [0] * (MOD)
cnt[0] = 1
t = 1
for i in range(n):
m[i] = int(s[i]) * t % MOD
msum[i+1] = (msum[i] + m[i]) % MOD
cnt[msum[i+1]] += 1
t = t * 10 % MOD
ans = 0
for i in range(MOD):
ans += cnt[i] * (cnt[i] - 1) // 2
print(ans)
| 1 | 30,818,918,730,940 | null | 166 | 166 |
while True:
h,w = [int(s) for s in input().split(' ')]
if h==0 and w==0:
break
else:
low = '#' * w
rectangle = (low+'\n') * h
print(rectangle)
|
while True:
H, W = [int(i) for i in input().split()]
if H ==0 and W ==0:
break
for i in range(0, H):
print('#'*W)
print()
| 1 | 787,206,510,490 | null | 49 | 49 |
a = input()
print("Yes" if (a[2] == a[3]) and (a[4] == a[5]) else "No")
|
import sys
from collections import deque
import numpy as np
import math
sys.setrecursionlimit(10**6)
def S(): return sys.stdin.readline().rstrip()
def SL(): return map(str,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return map(int,sys.stdin.readline().rstrip().split())
def Main():
s = S()
if len(s)<6:
print('No')
exit()
if s[2]==s[3] and s[4]==s[5]:
print('Yes')
else:
print('No')
return
if __name__=='__main__':
Main()
| 1 | 41,898,509,796,132 | null | 184 | 184 |
# (+1,+2)をn回，(+2,+1)をm回とすると
# n + 2m = X
# 2n + m = Y でn,mが求まる．
# このとき答えは(n+m)Cn通り
def combination(n,r):
"""
高速な組み合わせの計算．
nCrは必ず整数になるため分母を全部約分で1にしてから残った分子の積を求める．
[参考]https://kadzus.hatenadiary.org/entry/20081211/1229023326
"""
if n-r < r: r = n-r
if r == 0: return 1
if r == 1: return int(n)
numerator = [i+1 for i in range(n-r, n)]
denominator = [i+1 for i in range(r)]
for p in range(2,r+1):
pivot = denominator[p-1]
if pivot > 1:
offset = (n-r)%p
for k in range(p-1, r, p):
numerator[k-offset] /= pivot
denominator[k] /= pivot
ans = 1
for i in range(r):
if numerator[i] > 1:
ans *= numerator[i]
if ans >= 1e9+7: ans %= 1e9+7
return int(ans)
X,Y = map(int, input().split())
if (X+Y)%3 != 0:
ans = 0
else:
n = int((2*Y-X)/3)
m = int(Y-2*n)
if n<0 or m<0:
ans = 0
else:
ans = combination(n+m, n)
print(ans)
|
#####################################################
# 組み合わせを10**9+7で割った余り、を高速に求めるアルゴリズム
# https://drken1215.hatenablog.com/entry/2018/06/08/210000
# https://qiita.com/derodero24/items/91b6468e66923a87f39f
# 全然理解できていない
MOD = 10**9 + 7
def comb(n, r):
if (r < 0 and r > n):
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % MOD
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(int, input().split())
# X+Yが3の倍数のマスしか通りえない
if not (X + Y) % 3:
# (1,2)移動をn回、(2,1)移動をm回したとする
# n+2m = X, 2n+m = Y
# → n+m = (X+Y)/3
# n = (2n+m)-(n+m) = X - (X+Y)/3 = (-X+2Y)/3
# mも同様
n = (2 * Y - X) // 3
m = (2 * X - Y) // 3
if n >= 0 and m >= 0:
print(comb(n + m, n))
else:
print(0)
# X+Yが3の倍数でない場合
else:
print(0)
| 1 | 150,233,550,286,008 | null | 281 | 281 |
n, a, b = map(int, input().split())
if (b-a)%2 == 0:
ans = (b-a)//2
else:
ans = 0
if a-1 <= n-b:
ans += a
a, b = 1, b-a
ans += (b-a)//2
else:
ans += n-b+1
a, b = a+n-b+1, n
ans += (b-a)//2
print(ans)
|
n=int(input())
a=10**9+7
b=10**n%a-2*9**n%a+8**n%a
if b<0:
b+=a
print(b)
| 0 | null | 56,601,828,802,372 | 253 | 78 |
s, t = map(str, input().split())
w = "{}{}".format(t,s)
print(w)
|
n = int(input())
a = [int(x) for x in input().split()]
q = int(input())
bc=[]
for i in range(q):
bc.append([int(x) for x in input().split()])
a_cnt=[0]*(10**5+1)
for i in range(len(a)):
a_cnt[a[i]]+=1
a_goukei=sum(a)
for gyou in range(q):
a_goukei+=(bc[gyou][1]-bc[gyou][0])*a_cnt[bc[gyou][0]]
print(a_goukei)
a_cnt[bc[gyou][1]]+=a_cnt[bc[gyou][0]]
a_cnt[bc[gyou][0]]=0
| 0 | null | 57,794,595,632,002 | 248 | 122 |
h, w, m = map(int, input().split())
bord_x, bord_y = [0]*h, [0]*w
hw = []
for _i in range(m):
s, t = map(int, input().split())
s -= 1
t -= 1
bord_x[s] += 1
bord_y[t] += 1
hw.append([s, t])
x_max, y_max = max(bord_x), max(bord_y)
cnt = 0
for i, j in hw:
if bord_x[i] == x_max and bord_y[j] == y_max:
cnt += 1
if cnt == bord_x.count(x_max)*bord_y.count(y_max):
x_max -= 1
print(x_max+y_max)
|
import sys
import numpy as np
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
#======================================================#
def main():
h, w, m = MII()
bombs = [MIIZ() for _ in range(m)]
a = [0]*h
b = [0]*w
for y,x in bombs:
a[y] += 1
b[x] += 1
maxa = max(a)
maxb = max(b)
sumv = maxa + maxb
c = a.count(maxa)*b.count(maxb) - sum(a[y]+b[x] == sumv for y,x in bombs)
print(sumv - (c<=0))
if __name__ == '__main__':
main()
| 1 | 4,673,021,302,232 | null | 89 | 89 |
H=int(input())
ans=0
i=0
while 2**i<=H:
ans+=2**i
i+=1
print(ans)
|
n=int(input())
A=[{} for _ in range(n)]
for i in range(n):
for _ in range(int(input())):
x,y=map(int,input().split())
A[i][x]=y
a=0
for i in range(2**n):
t=0
for j in range(n):
if i>>j&1:
if A[j] and any(i>>~-k&1!=A[j][k] for k in A[j]): break
else: t+=1
else: a=max(a,t)
print(a)
| 0 | null | 100,884,704,982,478 | 228 | 262 |
w = str(input())
s = []
for k in(list(w)):
s.append(k)
if s[2] == s[3]:
if s[4] == s[5]:
print("Yes")
else:
print("No")
else:
print("No")
|
def ABC_160_A():
S = input()
if S[2] == S[3] and S[4] == S[5]:
print('Yes')
else:
print('No')
if __name__ == '__main__':
ABC_160_A()
| 1 | 42,104,249,430,048 | null | 184 | 184 |
from array import array
def readinput():
n=int(input())
a=array('L',list(map(int,input().split())))
return n,a
count=0
def merge(a,left,mid,right):
INFTY=10**9+1
global count
n1=mid-left
n2=right-mid
#L=[a[left+i] for i in range(n1)]
L=a[left:mid]
L.append(INFTY)
#R=[a[mid+i] for i in range(n2)]
R=a[mid:right]
R.append(INFTY)
i=0;j=0
for k in range(left,right):
if(L[i]<=R[j]):
a[k]=L[i]
i+=1
else:
a[k]=R[j]
j+=1
count+=1
def mergeSort(a,left,right):
if(left+1<right):
mid=(left+right)//2
mergeSort(a,left,mid)
mergeSort(a,mid,right)
merge(a,left,mid,right)
return
def main(n,a):
global count
mergeSort(a,0,n)
return a,count
if __name__=='__main__':
n,a=readinput()
a,count=main(n,a)
print(' '.join(map(str,a)))
print(count)
|
def counts(num):
countlist.append(len(str(num[0] + num[1])))
countlist = []
flag = True
while flag :
try:
counts(map(int, raw_input().split()))
except:
flag = False
for x in countlist:
print x
| 0 | null | 59,256,443,612 | 26 | 3 |
input()
print(" ".join(reversed(input().split())))
|
input()
ls = input().split()
print(' '.join(reversed(ls)))
| 1 | 985,201,878,960 | null | 53 | 53 |
nm = input().split()
n = int(nm[0])
m = int(nm[1])
ans = 0
n1 = n*(n-1)/2
n2 = m*(m-1)/2
ans = int(n1 + n2)
print(ans)
|
N , M = map(int,input().split())
ans = 0
ans += N * (N - 1) // 2
ans += M * (M - 1) // 2
print( ans )
| 1 | 45,318,455,531,580 | null | 189 | 189 |
N = int(input())
M = [[0]*10 for _ in range(10)]
for n in range(1,N+1):
head = int(str(n)[0])
tail = int(str(n)[-1])
M[head][tail] += 1
ans = 0
for i in range(10):
for j in range(i+1,10):
ans += M[i][j]*M[j][i]*2
ans += M[i][i]**2
print(ans)
|
from collections import defaultdict
n = int(input())
dct = defaultdict(int)
for i in range(1,n+1):
s = str(i)
dct[(s[0],s[-1])] += 1
ans = 0
for i in range(1,n+1):
s = str(i)
ans += dct[(s[-1],s[0])]
print(ans)
| 1 | 86,742,515,966,298 | null | 234 | 234 |
import math
def main():
h,w = map(int, input().split())
if h == 1 or w == 1:
print(1)
else:
print(math.ceil(h*w/2))
if __name__ == "__main__":
main()
|
import collections
N,M = map(int,input().split())
road = [[] for _ in range(N+1)]
for _ in range(M):
A,B = map(int,input().split())
road[A].append(B)
road[B].append(A)
no_visit =set(range(1,N+1))
q = collections.deque([])
cnt = 0
while no_visit:
q.append(no_visit.pop())
cnt +=1
while q:
now = q.popleft()
for nxt in road[now]:
if nxt in no_visit:
q.append(nxt)
no_visit.discard(nxt)
print(cnt-1)
| 0 | null | 26,605,850,781,760 | 196 | 70 |
H,N = (int(x) for x in input().split())
A = [int(x) for x in input().split()]
if sum(A)>=H:
print('Yes')
else:
print('No')
|
x = int(input())
money = 100
year = 0
if x <= 100:
print(0)
exit()
while True:
money += money*100//10000
year += 1
if money >= x:
print(year)
exit()
| 0 | null | 52,522,995,020,144 | 226 | 159 |
nums = input().split()
ab = [int(nums[0]), int(nums[1])]
cd = [int(nums[2]), int(nums[3])]
res = []
for i in ab:
for j in cd:
tmp = i * j
res.append(tmp)
print(max(res))
|
a,b,c,d=map(int,input().split())
ans=-10**20
if ans<a*c:
ans=a*c
if ans<a*d:
ans=a*d
if ans<b*c:
ans=b*c
if ans<b*d:
ans=b*d
print(ans)
| 1 | 3,046,679,262,880 | null | 77 | 77 |
a = int(raw_input())
b, c = divmod(a, 3600)
d, e = divmod(c, 60)
print ("%d:%d:%d") % (b,d,e)
|
# encoding:utf-8
while True:
L = list(map(int, input().split(" ")))
if L[0] == 0 and L[1] == 0:
break
L.sort()
print("{0} {1}".format(L[0],L[1]))
| 0 | null | 423,290,268,168 | 37 | 43 |
A, B, N = map(int, input().split())
x = min(B-1, N)
ans = (A * x // B) - A * (x // B)
print(ans)
|
n,a,b=list(map(int,input().split()))
#2^n-nCa-nCbを求める
#冪乗を求める関数を求める
#2のn乗をmで割ったあまりを求める
def pow(a,n,m):
if n==0:
return 1
else:
k=pow(a*a%m,n//2,m)
if n%2==1:
k=k*a%m
return k
#次は組み合わせを計算する
#まずは前処理をする
inv=[0 for i in range(200001)]
finv=[0 for i in range(200001)]
inv[1]=1
finv[1]=1
for i in range(2,200001):
#逆元の求め方p=(p//a)*a+p%a a^(-1)=-(p//a)*(p%a)^(-1)
inv[i]=(-(1000000007//i)*inv[1000000007%i])%1000000007
finv[i]=finv[i-1]*inv[i]%1000000007
#nが10^7程度であればnCk=n!*(k!)*((n-k)!)を求めればいい
#nがそれより大きい時は間に合わない。ここでkが小さいことに着目すると
#nCk=n*(n-1).....*(n-k+1)*(k!)^(-1)で求められることがわかる
a_num=1
b_num=1
for i in range(n-a+1,n+1):
a_num=i*a_num%1000000007
for i in range(n-b+1,n+1):
b_num=i*b_num%1000000007
print((pow(2,n,1000000007)-1-a_num*finv[a]-b_num*finv[b])%1000000007)
| 0 | null | 47,239,714,613,050 | 161 | 214 |
from math import log2
print(2 ** int(log2(int(input())) + 1) - 1)
|
N,A,B = map(int,input().split())
if (B-A)%2==0:
print((B-A)//2)
else:
print(min(A,N-B+1)+(B-A-1)//2)
| 0 | null | 94,706,584,255,120 | 228 | 253 |
x = input()
x = int(x)
x **= 3
print(x)
|
N=int(input())
for a in range(1,10):
for b in range(1,10):
if a*b==N:
print('Yes')
exit()
print('No')
| 0 | null | 79,932,224,806,600 | 35 | 287 |
n = 0
list = []
while n < 10:
x = int(input())
list.append(x)
n += 1
list.sort()
print(list[9])
print(list[8])
print(list[7])
|
if __name__=="__main__":
dataset = []
for i in range(10):
a = int(input())
dataset.append(a)
for j in range(3):
print(max(dataset))
dataset.remove(max(dataset))
| 1 | 39,701,662 | null | 2 | 2 |
N=int(input())
if N%2==1:
print(int(float(N-1)/2))
else:
print(int(float(N-2)/2))
|
H, N = map(int, input().split())
Magic = [list(map(int, input().split())) for i in range(N)]
MAX_COST = max(Magic)[1]
# dp[damage] := モンスターに damage を与えるために必要な最小コスト
dp = [float('inf')] * (H + 1)
dp[0] = 0
for h in range(H):
for damage, cost in Magic:
next_index = min(h + damage, H)
dp[next_index] = min(dp[next_index], dp[h] + cost)
print(dp[-1])
| 0 | null | 117,145,151,622,862 | 283 | 229 |
n=int(input())
cnt=0
a=1
while(a*a<n):
cnt+=1
cnt+=max((n-1)//a-a,0)*2
a+=1
print(cnt)
|
import sys
input=sys.stdin.readline
n,k=map(int,input().split())
INF=10**9+7
l=[0]*k
ans=0
for i in range(k-1,-1,-1):
x=i+1
temp=pow(k//x,n,INF)
for j in range(2,k//x+1):
temp=(temp-l[j*x-1])%INF
l[i]=temp
ans=(ans+x*temp)%INF
print(ans)
| 0 | null | 19,534,409,969,540 | 73 | 176 |
INF = 10**10
def merge(ary, left, mid, right):
lry = ary[left:mid]
rry = ary[mid:right]
lry.append(INF)
rry.append(INF)
i = 0
j = 0
for k in range(left, right):
if lry[i] <= rry[j]:
ary[k] = lry[i]
i += 1
else:
ary[k] = rry[j]
j += 1
return right - left
def merge_sort(ary, left, right):
cnt = 0
if left + 1 < right:
mid = (left + right) // 2
cnt += merge_sort(ary, left, mid)
cnt += merge_sort(ary, mid, right)
cnt += merge(ary, left, mid, right)
return cnt
if __name__ == '__main__':
n = int(input())
ary = [int(_) for _ in input().split()]
cnt = merge_sort(ary, 0, n)
print(*ary)
print(cnt)
|
s=j=0
a=[];b=[];d=[]
for i,x in enumerate(input()):
if x=='\\':a+=[i]
elif x=='/' and a:
j=a.pop()
c=i-j;s+=c
while b and b[-1]>j:c+=d.pop();b.pop()
b+=[j];d+=[c]
print(s)
print(len(b),*(d))
| 0 | null | 83,639,176,942 | 26 | 21 |
def alp(c):
return chr(c+64)
def Base10to(n,k):
if(int(n/k)):
if n%k ==0 and n/k==1:
return str(alp(26))
elif n%k ==0:
return Base10to(int((n/k)-1),k)+str(alp(26))
else:
return Base10to(int(n/k),k)+str(alp(n%k))
return str(alp(n%k))
n = int(input())
k = 26
ans = Base10to(n,k)
print(ans.lower())
|
n = int(input())
digit = 1
while n > 26 ** digit:
n -= 26 ** digit
digit += 1
ans = []
n -= 1
char = 'abcdefghijklmnopqrstuvwxyz'
for i in list(range(digit)):
ans.append(char[n % 26])
n -= n%26
n = int(n/26)
print(''.join(reversed(ans)))
| 1 | 11,804,596,424,640 | null | 121 | 121 |
import math
r=input()
S = r*r*math.pi
l = 2*r*math.pi
print "%f %f" %(S,l)
|
import math
r = float(input())
S = math.pi * (r**2)
l = 2 * math.pi * r
print("{} {}".format(S, l))
| 1 | 641,583,370,408 | null | 46 | 46 |
from fractions import gcd
def count(x):
ans = 0
while x % 2 == 0:
ans += 1
x = x // 2
return ans
N, M = map(int, input().split(' '))
a = list(map(lambda x: int(x) // 2, input().split(' ')))
lcm, div2 = a[0], count(a[0])
flag = True
for i in range(1, N):
lcm = lcm // gcd(lcm, a[i]) * a[i]
if count(a[i]) != div2:
flag = False
if flag:
print((M // lcm + 1) // 2)
else:
print(0)
|
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def lcm(a, b):
return a // gcd(a, b) * b
N, M = map(int, input().split())
A = list(map(int, input().split()))
A = [a//2 for a in A]
while A[0] % 2 == 0:
for i in range(N):
if A[i] % 2 != 0:
print(0)
exit()
A[i] //= 2
M //= 2
for i in range(N):
if A[i] % 2 == 0:
print(0)
exit()
lcm_ = 1
for i in range(N):
lcm_ = lcm(lcm_, A[i])
if M < lcm_:
print(0)
exit()
print((M // lcm_ + 1) // 2)
| 1 | 101,688,431,350,252 | null | 247 | 247 |
a1, a2, a3 = map(int, input().split(" "))
tmp = a1 + a2 + a3
if tmp >= 22:
print("bust")
else:
print("win")
|
import numpy as np
S = input()
a = [0]*(len(S)+1)
for i in range(len(S)):
if S[i] == '<':
a[i+1] =max(a[i+1], a[i]+1)
else:
a[i] = max(a[i],a[i+1]+1)
for i in range(len(S)-1,-1,-1):
if S[i] == '<':
a[i+1] =max(a[i+1], a[i]+1)
else:
a[i] = max(a[i],a[i+1]+1)
print(sum(a))
| 0 | null | 137,839,091,445,580 | 260 | 285 |
from collections import Counter
def main():
n = int(input())
S = [input() for _ in range(n)]
c = Counter(S).most_common()
V = c[0][1]
ans = [k for k, v in c if v == V]
[print(a) for a in sorted(ans)]
if __name__ == '__main__':
main()
|
N = int(input())
S = sorted([input() for x in range(N)])
word = [S[0]]+[""]*(N-1) #単語のリスト
kaisuu = [0]*N #単語の出た回数のリスト
k = 0 #今wordリストのどこを使っているか
for p in range(N): #wordとkaisuuのリスト作成
if word[k] != S[p]:
k += 1
word[k] = S[p]
kaisuu[k] += 1
else:
kaisuu[k] += 1
m = max(kaisuu) #m:出た回数が最大のもの
ansnum = [] #出た回数が最大のもののwordリストでの位置
for q in range(N):
if kaisuu[q] == m:
ansnum += [q]
for r in range(len(ansnum)):
print(word[ansnum[r]])
| 1 | 70,223,919,305,840 | null | 218 | 218 |
n=int(input())
a=list(map(int,input().split()))
ans=0
c=sum(a)
for i in range(n):
c=c-a[i]
b=(a[i]*c)
ans=ans+b
d=ans%(1000000007)
print(d)
|
N = int(input())
A = list(map(int, input().split()))
mod = 10**9+7
k = int((10**9 + 8)/2)
sum = 0
sum_1 = 0
for i in range(N):
sum += A[i]
sum = (sum**2)%mod
for j in range(N):
sum_1 += A[j]**2
sum_1 = (sum_1)%mod
ans = sum - sum_1
ans = (ans*k)%mod
print(ans)
| 1 | 3,834,043,778,470 | null | 83 | 83 |
def a():
x = int(input())
k = 1
while (k * x) % 360 != 0:
k += 1
print(k)
a()
|
s = input()
p = input()
str2 = s + s
if str2.find(p) >= 0:
print("Yes")
else:
print("No")
| 0 | null | 7,474,700,262,142 | 125 | 64 |
N = int(input())
from itertools import permutations
P=tuple(map(int, input().split()))
Q=tuple(map(int, input().split()))
A=list(permutations([i for i in range(1, N+1)]))
a=A.index(P)
b=A.index(Q)
print(abs(a-b))
|
from math import factorial
N = int(input())
P = [int(x) for x in input().split()]
Q = [int(x) for x in input().split()]
orderP = 1 + (P[0]-1)*factorial(N-1)
orderQ = 1 + (Q[0]-1)*factorial(N-1)
for i in range(1,N):
redP = 0
redQ = 0
for j in range(i):
if P[j] < P[i]: redP += 1
if Q[j] < Q[i]: redQ += 1
orderP += (P[i]-redP-1)*factorial(N-i-1)
orderQ += (Q[i]-redQ-1)*factorial(N-i-1)
print(abs(orderP - orderQ))
| 1 | 100,197,176,317,292 | null | 246 | 246 |
def main():
a, b, c = map(int, input().split())
if(a+b+c >= 22):
print('bust')
else:
print('win')
return 0
if __name__ == '__main__':
main()
|
A1, A2, A3 = map(int, input().split())
ans = A1 + A2 + A3
if ans > 21:
print('bust')
else:
print('win')
| 1 | 118,455,575,766,880 | null | 260 | 260 |
def main4():
N = int(input())
S = input()
R = set()
G = set()
B = set()
for i in range(len(S)):
if S[i] == "R":
R.add(i)
elif S[i] == "G":
G.add(i)
elif S[i] == "B":
B.add(i)
ans = 0
for r in R:
for g in G:
a, b = sorted([r, g])
tmp = len(B)
if ((b + a) % 2 == 0) and ((b + a) // 2) in B:
tmp -= 1
if (2*a - b) in B:
tmp -= 1
if (2*b - a) in B:
tmp -= 1
ans += tmp
print(ans)
if __name__ == "__main__":
main4()
|
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
A = []
for _ in range(int(input())):
x, l = map(int, input().split())
A.append((x - l, x + l))
A.sort(key = lambda x : x[1])
ans = 0
now = -INF
for l, r in A:
if now <= l:
now = r
ans += 1
print(ans)
resolve()
| 0 | null | 63,058,961,596,342 | 175 | 237 |
nums = input().split()
a = int(nums[0])
b = int(nums[1].replace('.', ''))
result = str(a * b)
if len(result) < 3:
print(0)
else:
print(result[:-2])
|
A,B = input().split()
A = int(A)
x = ""
for i in range(len(B)):
if B[i]!=".":
x += B[i]
B = int(x)
C = A*B
C = C//100
print(C)
| 1 | 16,482,476,996,196 | null | 135 | 135 |
S = input()
T = input()
Nmax = len(T)
for i in range(len(S)-len(T)+1):
diff = 0
for j in range(len(T)):
if(S[i+j] != T[j]):
diff += 1
Nmax = min(diff, Nmax)
print(Nmax)
|
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
k = int(input())
keta = 1
mod = 7%k
while keta < 10**7:
if mod==0:
print(keta)
break
keta += 1
mod = (mod*10 + 7)%k
else:
print(-1)
if __name__=='__main__':
main()
| 0 | null | 4,869,441,565,340 | 82 | 97 |
N=int(input())
cnt=0
ans="No"
for i in range(N):
x,y=input().split()
if x==y:
cnt=cnt+1
else:
cnt=0
if cnt>=3:
ans="Yes"
print(ans)
|
N=int(input())
S,T=map(list,input().split())
lis=[]
for i in range(0,N):
lis.append(S[i])
lis.append(T[i])
print(''.join(lis))
| 0 | null | 57,072,752,910,712 | 72 | 255 |
n, x, m = map(int, input().split())
v = list(range(m))
p = [-1 for _ in range(m)]
a = x
p[a - 1] = 0
s = [x]
l, r = n, n
for i in range(n):
a = a ** 2 % m
if p[a - 1] >= 0:
l, r = p[a - 1], i + 1
break
else:
s.append(a)
p[a - 1] = i + 1
ans = sum(s[:l])
if l != r:
b = (n - 1 - i) // (r - l) + 1
c = (n - 1 - i) % (r - l)
ans += b * sum(s[l:r]) + sum(s[l:l + c])
print(ans)
|
N,X,M=map(int, input().split())
m=[0]*M
t={}
def f(x,y):
return x*x % y
a = X
s=0
for i in range(N):
if a in t:
x = t[a]
nn = N - x
q,r = divmod(nn,i-x)
s = m[x-1] + (m[i-1] - m[x-1])*q + m[x-1+r] - m[x-1]
break
t[a]=i
s += a
m[i] = s
a = f(a,M)
print(s)
| 1 | 2,831,791,967,652 | null | 75 | 75 |
def resolve():
N = int(input())
A = list(map(int, input().split()))
import collections
counter = collections.Counter(A)
total = 0
for k, v in counter.items():
total += v*(v-1)//2
for a in A:
cnt = counter[a]
cntm1 = cnt - 1
print(total - cnt*(cnt-1)//2 + cntm1*(cntm1-1)//2)
if '__main__' == __name__:
resolve()
|
N = int(input())
A = list(map(int,input().split()))
li = [0] * (N + 1)
total = 0
for i in A:
li[i] += 1
for i in li[1:]:
total += i * (i - 1) // 2
for i in A:
j = li[i]
print(total - (j * (j - 1) // 2) + ((j - 1) * (j - 2) // 2))
| 1 | 47,987,643,525,890 | null | 192 | 192 |
n,x,y = map(int,input().split())
ans = [0]*n
for i in range(1,n+1):
for j in range(i+1,n+1):
if i <= x and j >= y:
a = abs(j-i)-abs(y-x)+1
b = abs(i-x)+abs(j-y)+1
ans[min(a,b)] += 1
else:
c = abs(x-i)+abs(y-j)+1
d = abs(j-i)
ans[min(c,d)] += 1
for i in range(1,n):
print(ans[i])
|
import math
from math import gcd,pi,sqrt
INF = float("inf")
import sys
sys.setrecursionlimit(10**6)
import itertools
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def main():
n, x, y = i_map()
ans = [0] * n
for fr in range(1, n+1):
for to in range(fr+1, n+1):
cost = min(to - fr, abs(x-fr) + abs(to - y) + 1)
ans[cost] += 1
print(*ans[1:], sep="\n")
if __name__=="__main__":
main()
| 1 | 44,033,517,795,720 | null | 187 | 187 |
a = int(input())
b = a * a * a
print(b)
|
x=input()
print x*x*x
| 1 | 277,525,323,428 | null | 35 | 35 |
N = int(input())
A = list(map(int,input().split()))
for i in range(N):
v = A[i]
j = i - 1
while j >= 0 and A[j] > v:
A[j+1] = A[j]
j -= 1
A[j+1] = v
print(" ".join(map(str, A)))
|
N = int(input())
if(N % 9 == 0):
ans = True
else:
ans = False
print("Yes" if ans else "No")
| 0 | null | 2,238,712,705,362 | 10 | 87 |
time = int(input())
h = time // 3600
m = (time // 60) % 60
t = time % 60
print("{0}:{1}:{2}" .format(h, m, t))
|
import sys
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
n=int(input())
if n==1:
print(0)
sys.exit()
l=factorization(n)
ans =0
for x in l:
a=x[0] #素数
b=x[1] #素数の個数
k=0
t=0
while(True):
t += 1
k += t
if k==b:
ans += t
break
elif k > b:
ans += t-1
break
print(ans)
| 0 | null | 8,698,214,699,680 | 37 | 136 |
def main():
alphabets = "abcdefghijklmnopqrstuvwxyz"
c = input()
print(alphabets[alphabets.index(c)+1])
main()
|
C = input()
alphabet = 'abcdefghijklmnopqrstuvwxyz'
print(alphabet[(alphabet.index(C) + 1) % len(alphabet)])
| 1 | 92,236,450,656,098 | null | 239 | 239 |
def main():
from sys import setrecursionlimit, stdin
from os import environ
from collections import defaultdict, deque, Counter
from math import ceil, floor, gcd
from itertools import accumulate, combinations, combinations_with_replacement
setrecursionlimit(10**6)
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in environ else lambda *x: 0
input = lambda: stdin.readline().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
P = 10**9+7
INF = 10**9+10
N = II()
args = defaultdict(lambda:defaultdict(lambda:[0]*2))
zeros = 0
for _ in range(N):
x,y = map(int,input().split())
if x == 0:
if y == 0:
zeros += 1
else:
args[0][0][0] += 1
continue
elif y == 0:
args[0][0][1] += 1
continue
g = gcd(x,y)
x2,y2 = abs(x//g),abs(y//g)
if x*y < 0:
args[x2][y2][1] += 1
else:
args[y2][x2][0] += 1
ans = 1
for y, a in args.items():
for x, p in a.items():
ans *= (pow(2,p[0],P) + pow(2,p[1],P) -1)
ans %= P
print((ans + zeros -1 + P)%P)
main()
|
import sys
BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001
P = str(input()).upper()
line = []
while True:
tmp_line = str(input())
if tmp_line == 'END_OF_TEXT':
break
line += tmp_line.upper().split()
ans = 0
for tmp_word in line:
if tmp_word == P:
ans += 1
print("%d"%(ans))
| 0 | null | 11,337,083,678,830 | 146 | 65 |
N = int(input())
# N = 25
def calculate(n):
result = {}
for index in range(1, n + 1):
i = int(str(index)[0])
j = int(str(index)[-1])
if result.get((i, j)) == None:
if i != 0:
result.__setitem__((i, j), 1)
else:
result.__setitem__((i, j), result.get((i, j)) + 1)
res = 0
for i in range(10):
for j in range(10):
s1 = result.get((i, j))
s2 = result.get((j, i))
s1 = 0 if s1 == None else s1
s2 = 0 if s2 == None else s2
res += s1 * s2
print(res)
calculate(N)
|
a, b = map(str, input().split())
ans = [a] * int(b) if int(a)<=int(b) else [b] * int(a)
print(''.join(ans))
| 0 | null | 85,387,806,189,600 | 234 | 232 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.