code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
from sys import stdin
from itertools import product
suits = ['S', 'H', 'C', 'D']
suits_priority = {
'S': 1,
'H': 2,
'C': 3,
'D': 4
}
ranks = list(range(1, 14))
original_deck = set(product(suits, ranks))
if __name__ == '__main__':
n = int(stdin.readline().rstrip())
deck = set()
for _ in range(n):
suit, rank = stdin.readline().rstrip().split()
deck.add((suit, int(rank)))
diff = list(original_deck - deck)
diff.sort(key=lambda x: x[1])
diff.sort(key=lambda x: suits_priority[x[0]])
for card in diff:
print("{} {}".format(*card))
| n=input().strip()
if n[-1]=='s':
print(n+'es')
else:
print(n+'s') | 0 | null | 1,741,760,833,892 | 54 | 71 |
n = int(input())
print(sum((n - 1) // i for i in range(1, n))) | ln=10**6+10
sieve=[i for i in range(ln)]
p=2
while p**2<=ln:
if sieve[p]==p:
for q in range(p*2,ln,p):
if sieve[q]==q:
sieve[q]=p
p+=1
import collections
def primef(n):
prime_count=collections.Counter()
while n>1:
prime_count[sieve[n]]+=1
n//=sieve[n]
return prime_count
n=int(input())
ans=0
for i in range(1,n):
t=1
for j in primef(i).values():
t=t*(j+1)
ans+=t
print(ans) | 1 | 2,587,358,254,368 | null | 73 | 73 |
#!/usr/bin/env python3
import collections as cl
import sys
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def main():
N, R = MI()
if N >= 10:
print(R)
else:
print(R + 100 * (10 - N))
main()
| n,r = map(int,input().split())
if n > 10:
print(r)
else:
a = r + (100 * (10-n))
print(a)
| 1 | 63,126,986,811,460 | null | 211 | 211 |
L = int(input())
a = L / 3
print(a*a*a) | def main():
A = input()
ans = chr(ord(A) + 1)
print(ans)
main() | 0 | null | 69,569,535,677,502 | 191 | 239 |
import math
#import matplotlib.pyplot as plt
def kock(n,p1,p2):
#global x
#global y
if n==0:
return
s=[0,0]
t=[0,0]
u=[0,0]
s[0]=(float((2*p1[0]+p2[0])/3))
s[1]=(float((2*p1[1]+p2[1])/3))
t[0]=(float((p1[0]+2*p2[0])/3))
t[1]=(float((p1[1]+2*p2[1])/3))
u[0]=((t[0]-s[0])*math.cos(math.radians(60))-(t[1]-s[1])*math.sin(math.radians(60))+s[0])
u[1]=((t[0]-s[0])*math.sin(math.radians(60))+(t[1]-s[1])*math.cos(math.radians(60))+s[1])
kock(n-1,p1,s)
print(*s)
# x.append(s[0])
#y.append(s[1])
kock(n-1,s,u)
print(*u)
#x.append(u[0])
#y.append(u[1])
kock(n-1,u,t)
print(*t)
#x.append(t[0])
#y.append(t[1])
kock(n-1,t,p2)
n=int(input())
p1=[0.0,0.0]
p2=[100.0,0.0]
#x=[]
#y=[]
print(*p1)
#x.append(p1[0])
#y.append(p1[1])
kock(n,p1,p2)
print(*p2)
| from math import sqrt
N=int(input())
for i in range(int(sqrt(N)),0,-1):
j = N/i
if j == int(j):
print(int(i+j-2))
break | 0 | null | 80,900,494,845,472 | 27 | 288 |
x,y,z=[int(i) for i in input().split()]
if x<y<z:
print("Yes")
else:
print("No") | if __name__ == '__main__':
a, b, c = input().split()
a, b, c = int(a), int(b), int(c)
if a < b and b < c:
print("Yes")
else:
print("No")
| 1 | 388,844,118,300 | null | 39 | 39 |
import numpy as np
k,n = map(int, input().split())
a = np.array(list(map(int, input().split())))
a.sort()
dif = np.diff(a, n=1)
maximum = max(dif.max(), a[0]+(k-a[-1]))
print(k-maximum) | # -*- coding: utf-8 -*-
"""
Created on Tue Apr 28 21:57:22 2020
"""
import sys
#import numpy as np
sys.setrecursionlimit(10 ** 9)
#def input():
# return sys.stdin.readline()[:-1]
mod = 10**9+7
S = input()
if S[2] == S[3] and S[4] == S[5]:
ans = 'Yes'
else:
ans = 'No'
print(ans)
| 0 | null | 42,597,913,291,862 | 186 | 184 |
N=int(input())
import sys
l=[i.rstrip().split() for i in sys.stdin.readlines()]
l=[list(map(int,i)) for i in l]
l=[[i-j,i+j] for i,j in l]
from operator import itemgetter
l.sort(key=itemgetter(1))
ans=N
end=l[0][1]
for i in range(N-1):
if l[i+1][0] < end:
ans-=1
else:
end=l[i+1][1]
print(ans) | n = int(input())
dat = []
for _ in range(n):
x, l =map(int, input().split())
dat.append([x-l, x+l])
dat.sort(key=lambda x: x[1])
#print(dat)
prevr = -99999999999999999
res = 0
for i in range(n):
if dat[i][0] >= prevr:
prevr = dat[i][1]
res += 1
print(res)
| 1 | 89,986,314,100,508 | null | 237 | 237 |
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)
| import sys
import collections
import bisect
def main():
n = int(input())
a = [str(i + 1)[0] + str(i + 1)[-1] for i in range(n)]
b = [str(i + 1)[-1] + str(i + 1)[0] for i in range(n)]
ac, bc = collections.Counter(a), collections.Counter(b)
print(sum(ac[i] * bc[i] for i in ac.keys()))
if __name__ == '__main__':
main()
| 1 | 86,794,458,118,336 | null | 234 | 234 |
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
n = I()
s = S()
rgb = [None for _ in range(n)]
rgb_acc = [None for _ in range(n)]
rgb_st = {"R","G","B"}
rgb_lst = ["R","G","B"]
for i, char in enumerate(s):
if char == "R":
rgb[i] = [1,0,0]
elif char == "G":
rgb[i] = [0,1,0]
else:
rgb[i] = [0,0,1]
rgb_acc[0] = rgb[0]
for i in range(1, n):
rgb_acc[i] = rgb_acc[i-1][:]
index = 0 if s[i]=="R" else 1 if s[i]=="G" else 2
rgb_acc[i][index] += 1
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
if s[i]!=s[j]:
ex = rgb_st - {s[i], s[j]}
ex = ex.pop()
index = 0 if ex=="R" else 1 if ex=="G" else 2
cnt = rgb_acc[n-1][index]-rgb_acc[j][index]
if j+1 <= 2*j-i < n:
if s[2*j-i] == ex:
cnt -= 1
ans += cnt
print(ans)
main() | import itertools
N=int(input())
P=tuple(map(int,input().split()))
Q=tuple(map(int,input().split()))
prm = list(itertools.permutations(range(1,N+1)))
i = 0
for t in prm:
i += 1
if t == P:
a = i
if t == Q:
b = i
print(abs(a-b))
| 0 | null | 68,273,480,156,170 | 175 | 246 |
k = int(input())
if k % 7 == 0:
l = 9*k // 7
else:
l = 9*k
if l % 2 == 0 or l % 5 == 0:
print(-1)
else:
pmo = 1
for i in range(1, l + 1):
mo = (pmo * 10) % l
if mo == 1:
print(i)
break
else:
pmo = mo | N = int(input())
alpha = [chr(ord("a") + i) for i in range(26)]
def dfs(n, s):
if len(s) == n:
print(s)
return
cnt = len(set(s))
cnt += 1
for a in alpha[:cnt]:
ns = s + a
dfs(n, ns)
dfs(N, "")
| 0 | null | 29,128,516,018,094 | 97 | 198 |
n, k = map(int, input().split())
lr = [list(map(int, input().split())) for _i in range(k)]
mod = 998244353
dp = [0]*(n+1)
dp[1] = 1
for p in range(2, n+1):
for i, j in lr:
dp[p] += dp[max(p-i, 0)] - dp[max(p-j-1, 0)]
dp[p] %= mod
dp[p] += dp[p-1]
print((dp[n]-dp[n-1])%mod) | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
A = LI()
d = {}
for x in A:
for i in range(2,int(math.sqrt(x))+1):
cnt = 0
while x % i == 0:
cnt += 1
x //= i
if cnt:
d[i] = max(d.get(i,0),cnt)
if x == 1: break
else:
d[x] = max(d.get(x,0),1)
m = 1
for i,x in d.items():
m = (m * i ** x) % MOD
ans = 0
for x in A:
ans += (m * pow(x,MOD-2,MOD)) % MOD
print(ans % MOD)
if __name__ == '__main__':
main() | 0 | null | 45,150,778,202,686 | 74 | 235 |
isExist = [False]*2001
n = int( raw_input() )
A = [ int( val ) for val in raw_input().rstrip().split( ' ' ) ]
for i in A:
for j in range( 2000-i, 0, -1 ):
if isExist[j]:
isExist[ i+j ] = True
isExist[i] = True
q = int( raw_input() )
M = [ int( val ) for val in raw_input().rstrip().split( ' ' ) ]
for i in range( 0, q ):
if isExist[ M[i] ]:
print( "yes" )
else:
print( "no" ) | N = int(input())
A = list(map(int, input().split()))
Q = int(input())
M = list(map(int, input().split()))
combinations = {}
def create_combinations(idx, sum):
combinations[sum] = 1
if idx >= N:
return
create_combinations(idx+1, sum)
create_combinations(idx+1, sum+A[idx])
return
create_combinations(0, 0)
for target in M:
if target in combinations.keys():
print("yes")
else:
print("no")
| 1 | 98,123,670,482 | null | 25 | 25 |
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
H, W, K = lr()
S = []
for i in range(H):
S.append([int(s) for s in sr()])
ans = 2000
idx = [0]*H
for div in range(1<<(H-1)):
g = 0
for i in range(H):
idx[i] = g
if div>>i&1:
g += 1
g += 1
c = [[0]*W for i in range(g)]
for i in range(H):
for j in range(W):
c[idx[i]][j] += S[i][j]
ok = True
for i in range(g):
for j in range(W):
if c[i][j] > K:
ok = False
if not ok:
continue
num = g-1
now = [0]*g
def add(j):
for i in range(g):
now[i] += c[i][j]
for i in range(g):
if now[i] > K:
return False
return True
for j in range(W):
if not add(j):
num += 1
now = [0]*g
add(j)
ans = min(ans, num)
print(ans)
resolve() | import sys
def input(): return sys.stdin.readline().rstrip()
def main():
H, W, K = map(int, input().split())
S = [tuple(map(int, list(input()))) for _ in range(H)]
ans = 10 ** 9
for bit in range(1 << (H-1)):
canSolve = True
order = [0] * (H + 1)
tmp_ans = 0
for i in range(H):
if bit & 1 << i:
order[i+1] = order[i] + 1
tmp_ans += 1
else:
order[i+1] = order[i]
sum_block = [0] * (H + 1)
for w in range(W):
one_block = [0] * (H + 1)
overK = False
for h in range(H):
h_index = order[h]
one_block[h_index] += S[h][w]
sum_block[h_index] += S[h][w]
if one_block[h_index] > K:
canSolve = False
if sum_block[h_index] > K:
overK = True
if not canSolve:
break
if overK:
tmp_ans += 1
sum_block = one_block
if tmp_ans >= ans:
canSolve = False
break
if canSolve:
ans = tmp_ans
print(ans)
if __name__ == '__main__':
main()
| 1 | 48,529,184,207,492 | null | 193 | 193 |
import sys
input_data = input()
input_numbers = input_data.split()
if __name__ == '__main__':
a = int(input_numbers[0])
b = int(input_numbers[1])
c = int(input_numbers[2])
if (a < b) and (b < c) :
print('Yes')
else :
print('No')
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from itertools import combinations_with_replacement
def main():
n, m, q = map(int, input().split())
qs = []
for _ in range(q):
abcd = tuple(map(int, input().split()))
qs.append(abcd)
A = tuple(combinations_with_replacement(range(1, m+1), n))
r = 0
for Ae in A:
t0 = 0
for qe in qs:
if Ae[qe[1]-1] - Ae[qe[0]-1] == qe[2]:
t0 += qe[3]
r = max(r, t0)
print(r)
if __name__ == '__main__':
main()
| 0 | null | 14,027,646,022,400 | 39 | 160 |
import math
N = int(input())
print(math.floor((N - 1)/2)) | n=int(input())
s=input()
ans=0
for i in range(10):
if str(i) in s[:-2]:
s1=s.index(str(i))
for j in range(10):
if str(j) in s[s1+1:-1]:
s2=s[s1+1:].index(str(j))+s1+1
for k in range(10):
if str(k) in s[s2+1:]:
ans+=1
print(ans)
| 0 | null | 141,395,051,708,970 | 283 | 267 |
N, M, K = map(int, input().split())
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
total = 0
Asum = sum(A)
nA = len(A)
Bsum = 0
ans = 0
for nB in range(len(B) + 1):
if nB != 0:
Bsum += B[nB-1]
if Bsum > K:
break
while Asum + Bsum > K:
nA -= 1
Asum -= A[nA]
ans = max(nA + nB, ans)
print(ans)
| import itertools
N,M,K=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
A_=[0]+list(itertools.accumulate(A))
B_=[0]+list(itertools.accumulate(B))
ans=0
j=M
for i in range(N+1):
a=A_[i]
K_a=K-a
while (j>=0 and B_[j]>K_a):
j-=1
if a+B_[j]<=K:
ans=max(ans,i+j)
print(ans)
| 1 | 10,727,176,587,712 | null | 117 | 117 |
def readinput():
a,b,n=list(map(int,input().split()))
return a,b,n
def main(a,b,n):
m=int(min(b,n)*a/b)+1
maxdif=0
for xx in range(0,m):
if b*xx%a==0:
x=b*xx//a
else:
x=int(b/a*xx)+1
maxdif=max(maxdif,int(a*x/b)-a*int(x/b))
return maxdif
if __name__=='__main__':
a,b,n=readinput()
ans=main(a,b,n)
print(ans)
| n = int(input())
iteration = n
ex = 0
count = 0
for i in range(1,n):
ex = iteration-i
#print(ex)
if ex <=i:
break
else:
count += 1
print(count) | 0 | null | 90,756,371,476,452 | 161 | 283 |
N = list(map(int, input().split()))
if sum(N) % 9: print('No')
else: print('Yes') | from random import choice
from random import random
from time import time
class Optimizer:
def __init__(self, C, S):
self.C = C
self.S = S
X = []
L = [-1] * 26
for i in range(365):
max_diff = -10**10
best_j = 0
for j in range(26):
memo = L[j]
L[j] = i
diff = self.S[i][j] - \
sum([self.C[jj] * (i - L[jj]) for jj in range(26)])
if diff > max_diff:
max_diff = diff
best_j = j
L[j] = memo
L[best_j] = i
X.append(best_j)
self.X = X
def calc_score(self):
score = 0
L = [-1 for j in range(26)]
A = [0 for j in range(26)]
for i in range(365):
score += self.S[i][self.X[i]]
A[self.X[i]] += (i - L[self.X[i]]) * \
(i - L[self.X[i]] - 1) // 2
L[self.X[i]] = i
for j in range(26):
A[j] += (365 - L[j]) * (365 - L[j] - 1) // 2
score -= self.C[j] * A[j]
return score
def optimize(self, temp, threp, interval, start_time, lim=1.8):
max_score = self.calc_score()
while True:
t = (time() - start_time) / 2
if random() < threp:
i = choice(range(365))
j = choice(range(26))
memo = self.X[i]
self.X[i] = j
else:
a = choice(range(interval))
i0 = choice(range(365 - a))
i1 = i0 + a
self.X[i0], self.X[i1] = self.X[i1], self.X[i0]
new_score = self.calc_score()
if new_score > max_score:
max_score = new_score
elif random() < pow(2.7, (new_score - max_score) / pow(2000, 1 - t)):
max_score = new_score
else:
try:
self.X[i0], self.X[i1] = self.X[i1], self.X[i0]
except BaseException:
self.X[i] = memo
if time() - start_time > lim:
break
return max(max_score + 10**6, 0)
if __name__ == "__main__":
d = int(input())
*C, = map(int, input().split())
S = [list(map(int, input().split())) for i in range(d)]
opt = Optimizer(C, S)
opt.optimize(400, 0.8, 10, time(), lim=1.8)
for x in opt.X:
print(x + 1)
| 0 | null | 7,079,632,999,008 | 87 | 113 |
def func(x):
return x + x**2 + x**3
if __name__=="__main__":
input = input()
print(func(int(input)))
| a = int(input())
result = a + a**2 + a**3
print(result) | 1 | 10,223,118,526,500 | null | 115 | 115 |
inputNum = []
for i in range(0, 10):
inputNum.append(int(raw_input()))
inputNum.sort(reverse=True)
for i in range(0, 3):
print inputNum[i] | N, K, C = map(int, input().split())
S = input()
right, left = [0 for _ in range(N)], [0 for _ in range(N)]
cnt = 0
work = 0
while True:
if work == K:
break
if S[cnt] != "x":
right[cnt] += 1
work += 1
cnt += C+1
else:
cnt += 1
S = list(reversed(S))
cnt = 0
work = 0
while True:
if work == K:
break
if S[cnt] != "x":
left[cnt] += 1
work += 1
cnt += C+1
else:
cnt += 1
left.reverse()
# print(right)
# print(left)
cnt1 = 0
cnt2 = 0
for i in range(N):
if right[i] == 1:
cnt1 += 1
if left[i] == 1:
cnt2 += 1
if right[i] == left[i] == 1 and cnt1 == cnt2:
print(i+1) | 0 | null | 20,245,980,960,252 | 2 | 182 |
import numpy as np
N = int(input())
S = [[] for I in range(0,N)]
for T in range(0,N):
A = int(input())
S[T] = np.zeros((A,2),dtype=int)
for TT in range(0,A):
S[T][TT,:] = np.array([int(X) for X in input().split()])
MAX = 0
for P in range(pow(2,N)-1,-1,-1):
Bin = [int(X) for X in list(('{:0'+str(N)+'b}').format(P,'b'))]
BIndex = [I for I,N in enumerate(Bin) if N==1]
Flag = True
for PT in BIndex:
for PTB in range(0,S[PT].shape[0]):
if S[PT][PTB,1]==0 and (S[PT][PTB,0]-1) in BIndex:
Flag = False
break
if S[PT][PTB,1]==1 and (S[PT][PTB,0]-1) not in BIndex:
Flag = False
break
if not Flag:
break
if Flag:
MAX = len(BIndex)
break
print(MAX) | import sys
class Card:
def __init__(self, card):
self.card = card
self.mark = card[0]
self.value = int(card[1])
def __str__(self):
return self.card
def print_cards(arr_print, arr_compare):
n = len(arr_print)
same = True
for i in range(n):
if arr_compare != None and arr_print[i].card != arr_compare[i].card: same = False
sys.stdout.write(str(arr_print[i]))
if i != n - 1:
sys.stdout.write(' ')
print()
return same
def swap(arr, i, j):
temp = arr[i]
arr[i] = arr[j]
arr[j] = temp
def bubble_sort(arr):
n = len(arr)
for i in range(0, n):
for j in range(n - 1, i, -1):
if arr[j].value < arr[j - 1].value:
swap(arr, j, j - 1)
def selection_sort(arr):
n = len(arr)
for i in range(n):
minj = i
for j in range(i, n):
if arr[j].value < arr[minj].value:
minj = j
if minj != i:
swap(arr, i, minj)
n = int(input())
arr = list(map(str, input().split()))
cards1 = [None] * n
cards2 = [None] * n
for i in range(n):
cards1[i] = Card(arr[i])
cards2[i] = Card(arr[i])
bubble_sort(cards1)
selection_sort(cards2)
print_cards(cards1, None)
print('Stable')
stable = print_cards(cards2, cards1)
if stable == True:
print('Stable')
else:
print('Not stable')
| 0 | null | 60,747,029,616,270 | 262 | 16 |
n=int(input())
a=list(map(int,input().split()))
d={}
for i in range(n):
if a[i] in d:
d[a[i]]+=1
else:
d[a[i]]=1
ans=0
D=list(d.values())
for i in range(len(D)):
s=D[i]*(D[i]-1)//2
ans+=s
for i in range(n):
print(ans-d[a[i]]+1) | n, k = map(int,input().split())
a = list(map(int,input().split()))
l = [0]*n
i=0
cnt=0
while l[i]==0:
l[i] = a[i]
i = a[i]-1
cnt += 1
start = i+1
i = 0
pre = 0
while i+1!=start:
i = a[i]-1
pre += 1
loop = cnt-pre
if pre+loop<k:
k=(k-pre)%loop+pre
i = 0
for _ in range(k):
i = a[i]-1
print(i+1) | 0 | null | 35,243,010,519,320 | 192 | 150 |
string = input()
if string == "ARC": print("ABC")
else: print("ARC") | N,K=map(int,input().split())
h=list(map(int, input().split()))
A=0
for i in h:
if i>=K:
A=A+1
print(A) | 0 | null | 101,222,074,540,950 | 153 | 298 |
x = [int(x) for x in input().split()]
if (x[0]==x[1]):
print('Yes')
else:
print('No') | n = int(input())
print((n + n ** 2 + n ** 3) //1) | 0 | null | 46,495,780,152,338 | 231 | 115 |
N = int(input())
S, T = input().split()
ans = ""
for p in range(N):
ans += S[p]
ans += T[p]
print(ans) | import sys
input = sys.stdin.readline
# sys.setrecursionlimit(100000)
def main():
N = int(input().strip())
return (N//2) + N % 2
if __name__ == "__main__":
print(main()) | 0 | null | 85,355,303,977,658 | 255 | 206 |
import math
n, d = map(int, input().split())
xy = [list(map(int, input().split())) for _ in range(n)]
count = 0
for i in range(n):
count = count + 1 if math.sqrt(xy[i][0]**2 + xy[i][1]**2) <= d else count
print(count)
| from math import factorial
N, M = map(int, input().split())
if N <= 1:
combN = 0
else:
combN = factorial(N) // (factorial(N - 2) * factorial(2))
if M <= 1:
combM = 0
else:
combM = factorial(M) // (factorial(M - 2) * factorial(2))
print(combN + combM)
| 0 | null | 25,586,307,960,100 | 96 | 189 |
weatherS = input()
p = weatherS[0] == 'R'
q = weatherS[1] == 'R'
r = weatherS[2] == 'R'
if p and q and r:
serial = 3
elif (p and q) or (q and r):
serial = 2
elif p or q or r:
serial = 1
else:
serial = 0
print(serial) | s=input()
print(('RRR'in s)+('RR'in s)+('R'in s)) | 1 | 4,831,127,215,710 | null | 90 | 90 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
K=int(input())
S=len(input())
def COMinit(n,MOD):
fac,finv,inv=[0]*max(2,n+1),[0]*max(2,n+1),[0]*max(2,n+1)
fac[0]=fac[1]=1
finv[0]=finv[1]=1
inv[1]=1
for i in range(2,(n+1)):
fac[i]=fac[i-1]*i%MOD
inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD
finv[i]=finv[i-1]*inv[i]%MOD
return fac,finv,inv
fac,finv,inv=COMinit(K+S,MOD)
def COM(n, k, MOD=MOD):
if n<k or n<0 or k<0:
return 0
return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD
ans=0
for i in range(K+1):
ans+=pow(26,i,MOD)*pow(25,K-i,MOD)*COM(K+S-i-1,S-1)
ans%=MOD
print(ans) | def COMinit():
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,max):
fac[i] = fac[i-1]*i%mod
inv[i] = mod - inv[mod%i]*(mod//i)%mod
finv[i] = finv[i-1]*inv[i]%mod
def COM(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k]*finv[n-k]%mod)%mod
mod = 10**9+7
K = int(input())
S = input()
N = len(S)
max = N+K
fac = [0] * max
finv = [0] * max
inv = [0] * max
COMinit()
modlist1 = []
modlist2 = []
a = 1
b = 1
for i in range(K+1):
modlist1.append(a)
modlist2.append(b)
a = a*26%mod
b = b*25%mod
ans = 0
for i in range(K+1):
x = COM(N+K-i-1,N-1)
y = modlist1[i]
z = modlist2[K-i]
xyz = ((x*y%mod)*z)%mod
ans = (ans+xyz)%mod
print(ans)
| 1 | 12,818,965,255,642 | null | 124 | 124 |
from collections import namedtuple
Task = namedtuple('Task', 'name time')
class Queue:
def __init__(self, n):
self.n = n
self._l = [None for _ in range(self.n + 1)]
self._head = 0
self._tail = 0
def enqueue(self, x):
self._l[self._tail] = x
self._tail += 1
if self._tail > self.n:
self._tail -= self.n
def dequeue(self):
if self.isEmpty():
raise IndexError("pop from empty queue")
else:
e = self._l[self._head]
self._l[self._head] = None
self._head += 1
if self._head > self.n:
self._head -= self.n
return e
def isEmpty(self):
return self._head == self._tail
def isFull(self):
return self._tail == self.n
if __name__ == '__main__':
n, q = map(int, input().split())
queue = Queue(n+1)
for _ in range(n):
name, time = input().split()
time = int(time)
queue.enqueue(Task(name=name, time=time))
now = 0
while not queue.isEmpty():
task = queue.dequeue()
t = task.time
if t <= q:
now += t
print(task.name, now)
else:
now += q
queue.enqueue(Task(task.name, t - q))
| a,b=map(int,input().split())
list=[[0 for i in range(2)] for j in range(a)]
for i in range(a):
list[i]=input().split()
n=0
s=0
while n!=a:
if int(list[n][1])>b:
list[n][1]=int(list[n][1])-b
list.append(list[n])
list.pop(n)
s+=b
else:
print(list[n][0],s+int(list[n][1]))
s+=int(list[n][1])
n+=1
| 1 | 43,016,713,794 | null | 19 | 19 |
def ALDS1_3A():
stk, RPexp = [], list(input().split())
for v in RPexp:
if v in '+-*':
n2, n1 = stk.pop(), stk.pop()
stk.append(str(eval(n1+v+n2)))
else:
stk.append(v)
print(stk.pop())
if __name__ == '__main__':
ALDS1_3A() | import math
n, d = map(int,input().split( ))
#print(n,d)
number = 0
for a in range(n):
x, y = map(int, input().split( ))
if math.sqrt(x**2 + y**2) <= d:
number += 1
print(number)
| 0 | null | 2,990,522,375,210 | 18 | 96 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
N = int(readline())
def enum_divisors(n):
# 約数列挙
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
return divisors
divs = enum_divisors(N)
ans = INF
for div1 in divs:
div2 = N // div1
score = (div1 + div2 - 2)
ans = min(score, ans)
print(ans)
if __name__ == '__main__':
main()
| N=int(input())
l=[]
for i in range(1,int(N**0.5)+1):
if N%i==0:
l.append([i,N/i])
L=len(l)
s=[0]*L
for j in range(L):
s[j]=l[j][0]+l[j][1]
print(int(min(s))-2) | 1 | 161,938,499,840,828 | null | 288 | 288 |
NM = input().split()
n = int(NM[0])
m = int(NM[1])
A = []
B = []
for i in range(n):
A.append([])
a = input().split()
for j in range(m):
A[i].append(int(a[j]))
for i in range(m):
b = int(input())
B.append(b)
out = []
for i in range(n):
sum = 0
for j in range(m):
sum = sum + A[i][j]*B[j]
out.append(sum)
for i in range(n):
print(out[i]) | H, W= map(int, input().split())
A=[]
b=[]
ans=[0 for i in range(H)]
for i in range(H):
A.append(list(map(int, input().split())))
for j in range(W):
b.append(int(input()))
for i in range(H):
for j in range(W):
ans[i]+=A[i][j]*b[j]
print(ans[i]) | 1 | 1,151,332,307,440 | null | 56 | 56 |
from itertools import repeat
from itertools import combinations
def rec(s, i, total, m):
if total == m:
return 1
if len(s) == i or total > m:
return 0
return rec(s, i + 1, total, m) + rec(s, i + 1, total + s[i], m)
def makeCache(s):
cache = {}
for i in range(len(s)):
comb = list(combinations(s, i))
for c in comb:
cache[sum(c)] = 1
return cache
def loop(s, m):
for i in range(len(s)):
comb = list(combinations(s, i))
for c in comb:
if sum(c) == m:
return 1
return 0
if __name__ == "__main__":
n = int(input())
a = [int (x) for x in input().split()]
q = int(input())
m = [int (x) for x in input().split()]
s = makeCache(a)
for i in m:
#print("yes") if rec(a, 0, 0, i) > 0 else print("no")
#print("yes") if loop(a, i) > 0 else print("no")
print("yes") if i in s else print("no")
| n=int(input())
a,b=input().split()
s=""
for i in range(n):
s+=a[i]+b[i]
print(s) | 0 | null | 56,171,117,637,310 | 25 | 255 |
ans = list(map(int,input().split()))
print(ans[2],ans[0],ans[1])
| x, y, z = input().split()
a, b, c = x, y, z
x = c
y = a
z = b
print(x+' '+y+' '+z) | 1 | 37,936,056,661,202 | null | 178 | 178 |
N,K=map(int, input().split())
a_ls=list(map(int, input().split()))
j=1
step=0
s=set([])
l=[]
loop_s=-1
loop_g=-1
while True:
s.add(j)
l+=[j]
j=a_ls[j-1] #update
if j in s:
loop_s=l.index(j)
loop_g=len(l)
break
#print(l)
#print(loop_s)
#print(loop_g)
if K<loop_s:
print(l[K])
elif (K+1-loop_s)%(loop_g-loop_s)!=0:
print(l[loop_s+(K+1-loop_s)%(loop_g-loop_s)-1])
else:
print(l[-1])
| N, K = map(int, input().split())
A = [0] + list(map(int, input().split()))
B = [-1 for i in range(N+1)]
B[1] = 0
n = 1
m = 0
while 1:
n = A[n]
m += 1
if m == K:
print(n)
break
if B[n] == -1:
B[n] = m
else:
a = (K - m) % (m - B[n])
for i in range(a):
n = A[n]
print(n)
break | 1 | 22,823,931,326,240 | null | 150 | 150 |
#coding:utf-8
#1_7_B 2015.4.5
while True:
n,x = map(int,input().split())
if n == x == 0:
break
count = 0
for i in range(1 , n + 1):
for j in range(1 , n + 1):
if i < j < (x - i - j) <= n:
count += 1
print(count) | n=int(input())
print((n*n*n)/27) | 0 | null | 24,179,002,665,412 | 58 | 191 |
n=int(input())
now=0
for i in range(1,n+1):
now+=(i+(i*(n//i)))*(n//i)//2
print(now) | def calc(X):
A = 1
B = 1
if X == 0:
return A,B
else:
l_bound = 1
h_bound = 200
for i in range(l_bound,h_bound):
for j in range(0,i+1):
if i ** 5 - j ** 5 == X:
A = i
B = j
return A,B
if i ** 5 + j ** 5 == X:
A = i
B = -j
return A,B
def resolve():
X = int(input())
A,B = calc(X)
print(str(A) + " " + str(B))
resolve() | 0 | null | 18,120,195,047,140 | 118 | 156 |
n = int(input())
p = input()
if n>=len(p):
print(p)
else:
print(p[:n] + '...') | #!/usr/bin/env python3
N, K = [int(s) for s in input().split()]
h = [int(s) for s in input().split()]
print(len(list(filter(lambda x: x >= K, h)))) | 0 | null | 99,270,497,242,592 | 143 | 298 |
A, V =map(int, input().split())
B, W =map(int, input().split())
T=int(input())
d=abs(B-A)
dv=V-W
if dv<=0:
print("NO")
elif d/dv > T:
print("NO")
else:
print("YES") | a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
print('YES' if abs(b-a)-(v-w)*t <= 0 else 'NO') | 1 | 15,095,010,810,582 | null | 131 | 131 |
n = int(input())
p = [input().split() for i in range(n)]
x = input()
ans = 0
f = False
for l in p:
if f:
ans+=int(l[1])
if l[0]==x:
f = True
print(ans) | n=int(input())
s=[]
t=[]
for i in range(n):
st,tt=input().split()
s.append(st)
t.append(int(tt))
x=str(input())
temp=0
ans=sum(t)
for i in range(n):
temp=temp+t[i]
if s[i]==x:
break
print(ans-temp) | 1 | 96,962,932,627,380 | null | 243 | 243 |
import math
def main():
"""
/|
b / | h
/ |
/??????|???_
<- a -->
??????a, ??????b, a??¨b??????????§?C(???)
C???????????????radian????±???????
??????1????????????: x
??????: h (b?????????????????¨????????????sin????????¨???????±???????
??¢???: S (??????)
L (x + a + b): ??????????????????????????¨??????
x = sqrt(a_ ** 2 + h ** 2)
??????a??????????????????h?????§???????????? a_ ??¨????????¨
a_ = a - b * cos(rad)
??? ??????????????¨?????????????????? ??§??°??°??£??????????????????
"""
a, b, C = map(int, input().split())
# ????§???¢????????? 0 < C < 180
rad = math.pi * C / 180
sin = math.sin(rad)
h = b * sin
S = a * h / 2
a_ = a - b * math.cos(rad)
len_d = math.sqrt(a_ ** 2 + h ** 2)
print("{:.8f}".format(S))
print("{:.8f}".format(a + b + len_d))
print("{:.8f}".format(h))
if __name__ == "__main__":
main() | import math
a,b,c=map(float,raw_input().split())
c = c / 180 * math.pi
print "%.10f" % float(a*b*math.sin(c)/2)
x = math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(c))
print "%.10f" % float(a + b + x)
print "%.10f" % float(b*math.sin(c)) | 1 | 177,373,473,012 | null | 30 | 30 |
import sys
N, R = map(int, sys.stdin.readline().split())
print(R if 10 <= N else R + 100 * (10 - N)) | # -*- coding: utf-8 -*-
n = int(input())
t_point, h_point = 0, 0
for i in range(n):
t_card, h_card = map(str, input().split())
if t_card == h_card:
t_point += 1
h_point += 1
elif t_card > h_card:
t_point += 3
elif t_card < h_card:
h_point += 3
print('{0} {1}'.format(t_point, h_point))
| 0 | null | 32,734,923,540,732 | 211 | 67 |
A=int(input())
B=int(input())
print(6-(A+B)) | A = int(input())
B = int(input())
abc = {1, 2, 3}
ab = {A, B}
print(list(abc-ab)[0]) | 1 | 110,234,274,467,670 | null | 254 | 254 |
n, q = map(int, input().split())
tasks = []
for _ in range(n):
ni, ti = input().split()
tasks.append((ni, int(ti)))
t = 0
while len(tasks) > 0:
ni, ti = tasks.pop(0)
if ti <= q:
t += ti
print(f'{ni} {t}')
else:
tasks.append((ni, ti - q))
t += q
| n = list(map(int,input()))
if sum(n)/9 == sum(n)//9:
print("Yes")
else:
print("No")
| 0 | null | 2,201,542,373,408 | 19 | 87 |
# ITP1_10_B
import math
a, b, c = map(float, input().split())
s = a * b * math.sin(math.radians(c)) / 2
l = a + b + math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(math.radians(c)))
h = b * math.sin(math.radians(c))
print(s)
print(l)
print(h)
| import math
data = list(map(float, input().split()))
a, b, theta = data[0], data[1], data[2]/180*math.pi
data[1] = (a**2+b**2-2*a*b*math.cos(theta)) ** 0.5 + a + b
data[2] = b * math.sin(theta)
data[0] = a * data[2] / 2
for i in range(3):
print(data[i])
| 1 | 178,931,557,960 | null | 30 | 30 |
N = int(input(""))
a = input("").split(" ")
a = [int(i) for i in a]
m = 1000
list_ = []
for j in range(0, N-1):
if a[j] < a[j + 1]:
n = m // a[j]
k = (a[j + 1] - a[j]) * n
m = m + k
print(m) | K = int(input())
if K % 2 == 0 or K % 5 == 0:
print(-1)
else:
i = 1
r = 7 % K
while(True):
if r == 0:
print(i)
break
r = (r * 10 + 7) % K
i += 1
| 0 | null | 6,776,603,183,758 | 103 | 97 |
N = int(input())
s = 1
t = 0
while N > 26**s + t:
t += 26**s
s += 1
N -= t
ans = []
for i in range(s):
c = 0
while N > 26**(s-i-1):
N -= 26**(s-i-1)
c += 1
ans.append(chr(97+c))
print("".join(ans)) | import collections
n = int(input())
A = list(map(int, input().split()))
q = int(input())
CNT = collections.Counter(A)
ANS = []
ans = sum(A)
for i in range(q):
b, c = map(int, input().split())
t = CNT[b]
ans +=(c - b) * t
ANS.append(ans)
CNT[c] += t
CNT[b] = 0
for i in ANS:
print(i) | 0 | null | 12,166,275,223,960 | 121 | 122 |
from sys import exit
def main():
N = int(input())
a = list(map(int,input().split()))
index = -1
num = 1
for i in range(index+1, N):
if a[i] != num:
continue
elif a[i] == num:
index = i
num += 1
if index != -1:
print(N-(num-1))
exit()
#indexに更新がなければ-1のまま
print(index)
main() | x = int(input())
balance = 100
years = 0
while True:
years += 1
balance += balance // 100
if balance >= x:
print(years)
exit(0) | 0 | null | 70,998,387,895,710 | 257 | 159 |
def main():
T1,T2 = map(int,input().split())
A1,A2 = map(int,input().split())
B1,B2 = map(int,input().split())
move = T1*(A1-B1) + T2*(A2-B2)
mid = T1*(A1-B1)
if move==0:
return -1
if move*mid > 0:
return 0
if move < 0:
move *= -1
else:
mid *= -1
if mid%move == 0:
return 2*(mid//move)
else:
return 2*(mid//move)+1
if __name__ == "__main__":
ans = main()
if ans==-1:
print("infinity")
else:
print(ans)
| a,b=input().split()
a=int(a)
b=int(b)
if a==b:
print("Yes")
else:
print("No") | 0 | null | 107,371,802,888,420 | 269 | 231 |
R, C, K = map(int, input().split())
xy = [[0] * (C + 1) for _ in range(R + 1)]
for _ in range(K) :
r, c, v = map(int, input().split())
xy[r - 1][c - 1] = v
dp = [[[0] * (C + 1) for _ in range(R + 1)] for _ in range(4)]
for cy in range(R + 1) :
for cx in range(C + 1) :
if cx < C :
dp[0][cy][cx + 1] = max(dp[0][cy][cx + 1], dp[0][cy][cx])
dp[1][cy][cx + 1] = max(dp[1][cy][cx + 1], dp[0][cy][cx] + xy[cy][cx], dp[1][cy][cx])
dp[2][cy][cx + 1] = max(dp[2][cy][cx + 1], dp[1][cy][cx] + xy[cy][cx], dp[2][cy][cx])
dp[3][cy][cx + 1] = max(dp[3][cy][cx + 1], dp[2][cy][cx] + xy[cy][cx], dp[3][cy][cx])
if cy < R :
dp[0][cy + 1][cx] = max(dp[i][cy][cx] for i in range(3)) + xy[cy][cx]
dp[0][cy + 1][cx] = max(dp[0][cy + 1][cx], dp[3][cy][cx])
print(max(dp[i][-1][-1] for i in range(4))) | from itertools import combinations_with_replacement
n, m, q = map(int, input().split())
list_ABCD = [ list(map(int,input().split(" "))) for _ in range(q)]
list_N = [i for i in range(1, m+1)]
ans = 0
for l in combinations_with_replacement(list_N, n):
score = 0
for a, b, c, d in list_ABCD:
if l[b-1] - l[a-1] == c:
score += d
ans = max(ans, score)
print(ans) | 0 | null | 16,679,653,610,048 | 94 | 160 |
D, T, S = (int(d) for d in input().split())
if T * S >= D:
print("Yes")
else:
print("No") | import numpy as np
import queue
H,W=map(int,input().split())
S=list()
for i in range(H):
S.append(input())
ans=0
for i in range(H):
for j in range(W):
if S[i][j]==".":
L=[[-1]*W for i in range(H)]
L[i][j]=0
q=queue.Queue()
q.put([i,j])
while not q.empty():
r=q.get()
for k,l in [[1,0],[0,-1],[0,1],[-1,0]]:
if r[0]+k>=0 and r[0]+k<H and r[1]+l>=0 and r[1]+l<W and S[r[0]+k][r[1]+l]=="." and L[r[0]+k][r[1]+l]==-1:
L[r[0]+k][r[1]+l]=L[r[0]][r[1]]+1
q.put([r[0]+k,r[1]+l])
ans=max(ans,max(list(map(lambda x:max(x),L))))
print(ans)
| 0 | null | 49,188,919,459,188 | 81 | 241 |
from collections import deque
s = list(input())
q = int(input())
d = deque()
for i in s:
d.append(i)
c = 1
for _ in range(q):
t = list(input().split())
if t[0] == '1':
c *= -1
else:
if t[1] == '1':
if c == 1:
d.appendleft(t[2])
else:
d.append(t[2])
else:
if c == 1:
d.append(t[2])
else:
d.appendleft(t[2])
print(''.join(list(d)[::c]))
| def main():
N = input()
S, T = input().split()
ans = ""
for s, t in zip(S, T):
ans += s + t
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 84,930,232,363,950 | 204 | 255 |
N,K = map(int, input().split())
A_list = sorted(list(map(int, input().split())))
if K == 1:
print(0)
exit()
MOD = 10**9 + 7
fact = [0] * (N+1)
fact_inv = [0] * (N+1)
inv = [0] * (N+1)
fact[0] = fact[1] = 1
fact_inv[0] = fact_inv[1] = 1
inv[1] = 1
for i in range(2, N):
fact[i] = fact[i-1] * i % MOD
inv[i] = MOD - inv[MOD%i] * (MOD//i) % MOD # //で良いのかな?
fact_inv[i] = fact_inv[i-1] * inv[i] % MOD
def combo(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fact[n] * (fact_inv[k] * fact_inv[n-k] % MOD) % MOD
def main():
min_sum = 0
max_sum = 0
for i in range(N-K+1):
cmb = combo(N-i-1, K-1)
min_sum -= A_list[i] * cmb
max_sum += A_list[N-i-1] * cmb
min_sum %= MOD
max_sum %= MOD
print((max_sum+min_sum + MOD )%MOD)
if __name__ == "__main__":
main()
| n, k = [int(x) for x in input().split()]
a_list = [int(x) for x in input().split()]
a_list.sort()
mod = 10 ** 9 + 7
temp_list = [1] * (n + 1)
for i in range(1, n + 1):
temp_list[i] = i * temp_list[i - 1] % mod
i_temp_list = [1] * (n + 1)
i_temp_list[-1] = pow(temp_list[-1], mod - 2, mod)
for i in range(n, 0, -1):
i_temp_list[i - 1] = i_temp_list[i] * i % mod
y = k - 1
ans = 0
for i in range(k - 1, n):
x = i
num = temp_list[x] * i_temp_list[y] * i_temp_list[x - y] % mod
ans += a_list[i] * num % mod
for i in range(n - k + 1):
x = n - 1 - i
num = temp_list[x] * i_temp_list[y] * i_temp_list[x - y] % mod
ans -= a_list[i] * num % mod
ans %= mod
print(ans) | 1 | 96,020,512,472,220 | null | 242 | 242 |
N = int(input())
S = []
for _ in range(N):
S.append(input())
ac = 0
wa = 0
tle = 0
re = 0
for s in S:
if s == "AC":
ac += 1
if s == "WA":
wa += 1
if s == "TLE":
tle += 1
if s == "RE":
re += 1
print("AC x ",ac)
print("WA x ",wa)
print("TLE x ",tle)
print("RE x ",re) | n = int(input())
result = [input() for i in range(n)]
print('AC x ' + str(result.count("AC")))
print('WA x ' + str(result.count("WA")))
print('TLE x ' + str(result.count("TLE")))
print('RE x ' + str(result.count("RE"))) | 1 | 8,635,235,145,640 | null | 109 | 109 |
K,N = map(int,input().split())
A = list(map(int,input().split()))
min_distance = 10000000
distance = 0
for i in range(N):
if i == 0:
distance = A[N-1] - A[0]
elif i == N-1:
distance = (K-A[i])+A[i-1]
else:
distance = (K-A[i+1])+A[i]
if distance < min_distance:
min_distance = distance
print(min_distance) | K, N = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
ans = 0
del_A = []
for i in range(N):
if(i==(N-1)):
del_A.append(A[0]+K-A[i])
else:
del_A.append(A[i+1]-A[i])
print(sum(del_A)-max(del_A)) | 1 | 43,449,934,497,252 | null | 186 | 186 |
from sys import stdin
INF = 1000000007
def merge(A, l, m, r):
global count
L = A[l:m] + [INF]
R = A[m:r] + [INF]
li = 0
ri = 0
for j in range(l, r):
count += 1
if L[li] <= R[ri]:
A[j] = L[li]
li += 1
else:
A[j] = R[ri]
ri += 1
def mergeSort(A, l, r):
if r-l > 1:
mid = l + (r-l)//2
mergeSort(A, l, mid)
mergeSort(A, mid, r)
merge(A, l, mid, r)
n = int(stdin.readline().rstrip())
S = [int(x) for x in stdin.readline().rstrip().split()]
count = 0
mergeSort(S, 0, n)
print(*S)
print(count)
| count = 0
INFTY = 10 ** 10
def merge(A, left, mid, right):
global count
n1 = mid - left;
n2 = right - mid;
L = []
R = []
for i in range(n1):
L.append(A[left + i])
for i in range(n2):
R.append(A[mid + i])
L.append(INFTY)
R.append(INFTY)
i = 0
j = 0
for k in range(left, right):
count = count + 1
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 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)
import sys
n = raw_input()
for line in sys.stdin:
items = line.strip().split()
items = map(int, items)
mergeSort(items, 0, len(items))
print " ".join(map(str, items))
print count | 1 | 110,035,370,702 | null | 26 | 26 |
import numpy as np
from numba import jit
N, K = map(int, input().split())
A = np.array(list(map(int, input().split())), dtype=np.int64)
# 高速化
@jit
def imo(a, n):
imos = np.zeros(n+1, dtype=np.int64)
for i in range(n):
imos[max(0, i-a[i])] += 1
imos[min(n, i+a[i])+1] -= 1
# 累計和はnumpyの方が高速
immo = np.zeros(n+1, dtype=np.int64)
immo = np.cumsum(imos)
return immo[:n]
for _ in range(min(K, 41)):
A = imo(A, N)
print(*A) | def main():
n, k = map(int, input().split())
a = list(map(int, input().split()))
op = 0
while True:
new = [0 for _ in range(n + 1)]
for i in range(n):
new[max(0, i - a[i])] += 1
new[min(n, i + a[i] + 1)] -= 1
for i in range(1, n + 1):
new[i] += new[i - 1]
a = new[:-1]
op += 1
if op == k or all(aa == n for aa in a):
break
print(" ".join(map(str, a)))
if __name__ == '__main__':
main()
| 1 | 15,463,710,344,380 | null | 132 | 132 |
N = int(input())
A = list(map(int,input().split()))
Ans = 1
if 0 in A:
Ans = 0
else:
for i in range(0,N):
Ans *= A[i]
if Ans > 1000000000000000000:
Ans = -1
break
print(Ans)
| n = int(input())
A = list(map(int, input().split(' ')))
res = 1
for a in A:
res = min(res*a, 10**18 + 1)
if res == 10**18 + 1: print(-1)
else: print(res) | 1 | 16,246,234,093,472 | null | 134 | 134 |
n,K = map(int, input().split())
mod = 10**9 + 7
def modcomb(n,a,mod):
cnt = 1
for i in range(a):
cnt *= (n-i)
cnt *= pow(i+1,mod-2,mod)
cnt %= mod
# print(cnt)
return cnt
def modconb(n,mod):
# テーブルを作る
fac = [0]*(n+1)
finv = [0]*(n+1)
inv = [0]*(n+1)
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,n+1):
fac[i] = fac[i-1]*i % mod
inv[i] = mod - inv[mod%i] * (mod//i) % mod
finv[i] = finv[i-1] * inv[i] %mod
return fac,finv
# return(fac[n]*(finv[k]*finv[n-k]%mod)%mod)
cnt = 0
if n-1 >= K:
fac1,finv1 = modconb(n,mod)
for k in range(K+1):
c1 = fac1[n]*(finv1[k]*finv1[n-k]%mod)%mod
c2 = fac1[n-1]*(finv1[k]*finv1[n-1-k]%mod)%mod
cnt += c1*c2
cnt %= mod
print(cnt%mod)
else:
cnt1 = modcomb(2*(n-1),n-1,mod)
cnt2 = modcomb(2*(n-1),n,mod)
ans = (cnt1+cnt2)%mod
print(ans) | N, K = map(int, input().split())
MOD = 10**9 + 7
MAX_N = 10**6 + 5
fact = [0]*(MAX_N)
fact_inv = [0]*(MAX_N)
fact[0] = 1
for i in range(MAX_N-1):
fact[i+1] = fact[i]*(i+1) % MOD
fact_inv[-1] = pow(fact[-1], MOD-2, MOD)
for i in range(MAX_N-2, -1, -1):
fact_inv[i] = fact_inv[i+1]*(i+1) % MOD
def comb(n, k):
return fact[n]*fact_inv[k] % MOD * fact_inv[n-k] % MOD
if K >= N:
print(comb(2*N-1, N-1))
exit()
ans = 1
for i in range(1, K+1):
ans += comb(N, i)*comb(N-1, i) % MOD
ans %= MOD
print(ans)
| 1 | 67,278,010,614,748 | null | 215 | 215 |
N = int(input())
S = input()
i = 0
count = 1
con_s = 0
for i in range(N-1):
if S[i] in S[i+1]:
pass
else:
count += 1
print(count) | n = int(input())
s = input()
ans = [s[0]]
for i in range(1,n):
if ans[-1] != s[i] :
ans.append(s[i])
print(len(ans))
| 1 | 169,556,337,739,360 | null | 293 | 293 |
a,b,c,k = map(int,input().split())
ans = min(a,k)
k -= ans
if k == 0:
print(ans)
exit(0)
k -= min(b,k)
if k == 0:
print(ans)
exit(0)
ans -= min(c,k)
print(ans) | import sys
ans=0
A, B, C, K = (int(x) for x in input().split())
if A>K:
print(K)
sys.exit(0)
else:
K-=A
ans+=A
if B>K:
print(ans)
sys.exit(0)
else:K-=B
if C>K:
print(ans-K)
sys.exit()
else:
ans-=C
print(ans) | 1 | 21,922,047,862,104 | null | 148 | 148 |
a,b = input().split()
a = int(a)
b = int(b)
sign = "=="
if (a < b) : sign = "<"
if (a > b) : sign = ">"
print("a",sign,"b") | X=int(input())
i=1
while True:
if (X*i)%360==0:
print(i)
exit()
i+=1
| 0 | null | 6,765,930,620,340 | 38 | 125 |
n, x, m = [int(x) for x in input().split()]
A = [x]
while len(A) < n:
a = (A[-1] * A[-1]) % m
if a not in A:
A.append(a)
else:
i = A.index(a)
loop_len = len(A) - i
print(sum(A[:i]) + sum(A[i:]) * ((n - i) // loop_len) + sum(A[i:i + ((n - i) % loop_len)]))
break
else:
print(sum(A))
| n, x, m = map(int, input().split())
mn = min(n, m)
S = set()
A = []
a = x
ans = 0
for i in range(mn):
if a in S: break
S.add(a)
A.append(a)
ans += a
a = a*a%m
if a == 0:
print(ans)
exit()
if len(A) >= mn:
print(ans)
exit()
st_len = 0
while st_len < len(A) and a != A[st_len]: st_len += 1
st = sum(A[:st_len])
cyc_sum = sum(A[st_len:])
cyc_len = len(A) - st_len
cyc_num = (n - st_len) // cyc_len
cyc = cyc_sum * cyc_num
ed_len = (n - st_len) % cyc_len
ed = sum(A[st_len:][:ed_len])
print(st + cyc + ed)
| 1 | 2,768,298,525,268 | null | 75 | 75 |
import sys
import math
import bisect
from collections import defaultdict,deque
# input = sys.stdin.readline
def inar():
return [int(el) for el in input().split()]
# def find(a,b,c):
# gc=math.gcd(a,b)
# return math.gcd(gc,c)
def main():
n=int(input())
string=input()
r=[]
g=[]
b=[]
for i in range(n):
if string[i]=="R":
r.append(i)
elif string[i]=="G":
g.append(i)
else:
b.append(i)
ans=0
r.sort()
g.sort()
b.sort()
# print(r)
# print(g)
# print(b)
# print(len(b))
# ans1=0
# fir=[]
# for i in range(len(r)):
# for j in range(len(g)):
# for k in range(len(b)):
# ls=[r[i],g[j],b[k]]
# ls.sort()
# if ls[1]-ls[0]!=ls[2]-ls[1]:
# ans1+=1
# fir.append(ans1)
# # print(ans1)
# print("-------------------check---------------")
# are=[]
for i in range(len(r)):
for j in range(len(g)):
ans+=len(b)
chota=min(g[j],r[i])
bada=max(g[j],r[i])
diff=bada-chota
left=bisect.bisect_left(b,bada+diff)
right=bisect.bisect_left(b,chota-diff)
lol=(bada+chota)
if lol%2==0:
beech=lol//2
ind=bisect.bisect_left(b,beech)
if ind<len(b) and b[ind]==beech:
ans-=1
if (left<len(b) and b[left]==bada+diff):
ans-=1
if (right<len(b) and b[right]==chota-diff):
ans-=1
# are.append(ans)
print(ans)
# for i in range(len(are)):
# print(are[i],fir[i])
if __name__ == '__main__':
main()
| n = int(input())
s = input()
r = s.count('R')
g = s.count('G')
b = s.count('B')
cnt = 0
for i in range(n):
j = 1
while i + 2*j <= n-1:
if s[i] != s[i+j] and s[i+j] != s[i+2*j] and s[i+2*j] != s[i]:
cnt += 1
j += 1
print(r*g*b-cnt) | 1 | 36,103,945,466,120 | null | 175 | 175 |
N = int(input())
A = list(int(x) for x in input().split())
ans = 0
for i in range(N):
if i == N - 1:
break
if A[i] > A[i+1]:
sa = A[i] - A[i+1]
A[i+1] += sa
ans = ans + sa
print(ans)
| A,B,M = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
x = []
y = []
c = []
for _ in range(M):
X,Y,Z = map(int,input().split())
x.append(X)
y.append(Y)
c.append(Z)
mini = min(a) + min(b)
for i in range(M):
rei = a[x[i]-1]
den = b[y[i]-1]
coop = c[i]
if rei + den - coop < mini:
mini = rei + den - coop
print(mini)
| 0 | null | 29,214,710,043,166 | 88 | 200 |
import sys
input=sys.stdin.readline
inf=10**9+7
n,m,l=map(int,input().split())
D=[[inf]*(n+1) for _ in range(n+1)]
for _ in range(m):
a,b,c=map(int,input().split())
D[a][b]=c
D[b][a]=c
for k in range(1,n+1):
for i in range(1,n+1):
for j in range(1,n+1):
D[i][j]=min(D[i][j],D[i][k]+D[k][j])
DD=[[inf]*(n+1) for _ in range(n+1)]
for x in range(1,n+1):
for y in range(1,n+1):
if D[x][y]<=l:
DD[x][y]=1
for k in range(1,n+1):
for i in range(1,n+1):
for j in range(1,n+1):
DD[i][j]=min(DD[i][j],DD[i][k]+DD[k][j])
q=int(input())
for _ in range(q):
s,t=map(int,input().split())
if DD[s][t]==inf:
print(-1)
else:
print(DD[s][t]-1) | N, M, L = map(int, input().split())
dist = [[10**12] * N for _ in range(N)]
for i in range(N):
dist[i][i] = 0
for _ in range(M):
a, b, c = map(int, input().split())
if c <= L:
dist[a-1][b-1] = dist[b-1][a-1] = c
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
old_dist = [row[:] for row in dist]
for i in range(N):
for j in range(N):
if old_dist[i][j] <= L:
dist[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
Q = int(input())
for _ in range(Q):
start, end= map(int, input().split())
if dist[start-1][end-1] < 10**12:
print(dist[start-1][end-1] - 1)
else:
print(-1) | 1 | 173,430,268,180,668 | null | 295 | 295 |
while 1:
a = raw_input()
if a =='0':
break
sum = 0
for i in a:
sum += int(i)
print sum | import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
h, w, k = list(map(int, readline().split()))
a = [list(str(readline().rstrip().decode('utf-8'))) for _ in range(h)]
no = 0
is_f = True
for i in range(h):
if a[i].count("#") != 0:
row_f = True
no += 1
for j in range(w):
if a[i][j] == "#":
if not row_f:
no += 1
else:
row_f = False
a[i][j] = no
if is_f:
is_f = False
if i != 0:
for j in range(i - 1, -1, -1):
for k in range(w):
a[j][k] = a[i][k]
else:
for j in range(w):
a[i][j] = a[i-1][j]
for i in range(h):
print(*a[i])
if __name__ == '__main__':
solve()
| 0 | null | 72,744,151,959,512 | 62 | 277 |
from collections import deque
n,q = list(map(int, input().split()))
P = deque([[p,int(t)] for p,t in [input().split() for _ in range(n)]])
time = 0
while len(P) > 0:
pi = P.popleft()
if pi[1] > q:
P.append([pi[0],pi[1]-q])
time += q
else:
time += pi[1]
print(pi[0],time) | s1 = ''
try:
while True:
t = input()
if t == '':
break
s1 += t
except EOFError:
pass
n = [0] * 26
s = s1.lower()
for i in range(len(s)):
j = ord(s[i]) - 97
if j >= 0 and j < 26:
n[j] += 1
for i in range(26):
print('%s : %d' %(chr(i + 97),n[i]))
| 0 | null | 864,008,423,300 | 19 | 63 |
MOD=10**9+7
N=int(input())
dp=[0]*(N+1)
dp[0]=1
for i in range(N+1):
for j in range(i-2):
dp[i]+=dp[j]
dp[i]%=MOD
print(dp[N]) | n = int(input())
s = str(input())
ans = n
for i in range(1,n):
if s[i-1] == s[i]:
ans -= 1
print(ans) | 0 | null | 86,757,889,600,860 | 79 | 293 |
mountains = []
for x in range(10):
mountains.append(int(raw_input()))
mountains.sort()
mountains.reverse()
print mountains[0]
print mountains[1]
print mountains[2] | from collections import Counter
s = input()
n = len(s)
digits = [int(c) for c in s[::-1]]
a = [0] * (n + 1)
p = 2019
for i, digit in enumerate(digits):
a[i + 1] = (digit * pow(10, i, p) + a[i]) % p
counter = Counter(a)
ans = 0
for count in counter.values():
ans += count * (count - 1) // 2
print(ans) | 0 | null | 15,384,377,812,372 | 2 | 166 |
# 配るDP、もらうDP
n, k = map(int, input().split())
mod = 998244353
kukan = []
for _ in range(k):
# 区間の問題は扱いやすいように[ ) の形に直せるなら直す
l, r = map(int, input().split())
l -= 1
kukan.append([l, r])
dp = [0 for i in range(n)]
dp[0] = 1
# 区間のL, Rは数字が大きいため、その差一つ一つを考えると時間がない！
# それゆえにL, Rの端を考えればいいようにするためにそこまでの累和を考える
ruiseki = [0 for i in range(n + 1)]
ruiseki[1] = 1
for i in range(1, n):
for l, r in kukan:
l = i - l
r = i - r
l, r = r, l
# print(l, r)
if r < 0:
continue
elif l >= 0:
dp[i] += (ruiseki[r] - ruiseki[l]) % mod
else:
dp[i] += (ruiseki[r]) % mod
ruiseki[i + 1] = (ruiseki[i] + dp[i])
# print(ruiseki, dp)
print(dp[-1] % mod)
| n,k=map(int,input().split())
k_list=[]
for i in range(k):
l,r=map(int,input().split())
k_list.append([l,r])
dp=[0]*(n+1)
dp[1]=1
dpsum=[0]*(n+1)
dpsum[1]=1
for i in range(1,n):
dpsum[i]=dp[i]+dpsum[i-1]
for j in range(k):
l,r=k_list[j]
li=i+l
ri=i+r+1
if li<=n:
dp[li]+=dpsum[i]
dp[li]=dp[li]%998244353
if ri<=n:
dp[ri]-=dpsum[i]
dp[ri]=dp[ri]%998244353
print(dp[n])
| 1 | 2,694,541,287,918 | null | 74 | 74 |
# -*- coding: utf-8 -*-
str = raw_input()
s = []
for c in str:
s.append(c.lower() if c.isupper() else c.upper())
print ''.join(s) | import math
n = int(input())
top = int(math.sqrt(n))
a = 1
for x in range(1,top+1):
if n % x == 0:
a = x
a_pair = n // a
print(a + a_pair -2)
| 0 | null | 81,445,078,391,082 | 61 | 288 |
n, x, y = map(int, input().split())
x -= 1
y -= 1
def main():
ans = {}
for i in range(1, n):
ans[i] = 0
for i in range(0, n - 1):
for j in range(i + 1, n):
ans[solve(i, j)] += 1
for k in range(1, n):
print(ans[k])
def solve(i, j):
"""
最短距離を計算する
O(1)
"""
dist = min(abs(i - j), abs(x - i) + abs(y - j) + 1, abs(y -i) + abs(x - j) + 1)
return dist
if __name__ == '__main__':
main() | n,x,y = map(int,input().split())
d = [0]*(n)
for i in range(1,n):
for j in range(i+1,n+1):
c = min(abs(j-i), abs(x-i)+1+abs(j-y), abs(y-i)+1+abs(j-x))
d[c] += 1
for i in range(1,n):
print(d[i]) | 1 | 43,993,503,963,356 | null | 187 | 187 |
a=int(input())
b=a//3
c=a//5
d=a//15
z=0
y=0
w=0
v=0
for x in range(a+1):
z=z+x
for x in range(b+1):
y=y+x*3
for x in range(c+1):
w=w+x*5
for x in range(d+1):
v=v+x*15
print(z-y-w+v) | import numpy as np
def cumsum(x):
return list(np.cumsum(x))
def cumsum_number(N,K,x):
ans=[0]*(N-K+1)
number_cumsum = cumsum(x)
number_cumsum.insert(0,0)
for i in range(N-K+1):
ans[i]=number_cumsum[i+K]-number_cumsum[i]
return ans
"""
int #整数
float #小数
#for
for name in fruits: #fruitの頭から操作
print(name)
#リスト
list0 = [] #リスト生成
list0 = [1,2,3,4] #初期化
list0 = [0]*10 #[0,0,0,0,0,0,0,0,0,0]
list1= [i for i in range(10)] #>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list1 = list(map(int, input().split())) # 複数の入力をリストに入れる
number=[int(input()) for i in range(int(input()))] #複数行の入力をリストに
list1 = list1 + [6, 7, 8] #リストの追加
list2.append(34) #リストの追加 最後に（）内が足される
list.insert(3,10) #リストの追加 任意の位置（追加したい位置,追加したい値）
len(list4) #リストの要素数
max(sa) #list saの最小値
list5.count(2) #リスト(文字列も可）内の2の数
list1.sort() #並び替え小さい順
list1.sort(reverse=True) #並び替え大きい順
set(list1) #list1内の重複している要素を削除し、小さい順に並べる
sum([2,3, ,3]) #リストの合計
abs(a) #aの絶対値
max(a,b) min(a,b) #最大値 最小値
text1 = text1.replace("34","test") #text1内の"34"を"test"に書き換える(文字列内の文字を入れ替える)
exit(0) #強制終了
cumsum(リスト) #累積和をリストで返す
cumsum_number(N,K,x) #N個の数が含まれるリストx内のK個からなる部分和をリストで返す
"""
N=int(input())
ans=0
for j in range(N):
if (j+1)%3!=0 and (j+1)%5!=0:
ans += j+1
print(ans)
| 1 | 34,802,540,633,554 | null | 173 | 173 |
#!/usr/bin/env python3
n, k, *h = map(int, open(0).read().split())
print(sum(sorted(h)[-k-1::-1]))
| N, K = map(int, input().split())
H = map(int, input().split())
if K >= N:
print(0)
exit()
H = list(H)
H.sort()
print(sum(x for x in H[0 : N - K])) | 1 | 79,015,084,059,688 | null | 227 | 227 |
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
n = ni()
s = input()
def wid(w):
return ord(w)-ord("A")
def ws(wid):
return chr(wid+ord("A"))
ans = ""
for i in range(len(s)):
id = (wid(s[i])+n)%26
ans+=ws(id)
print(ans)
| # %%
x = input()
if x[0]=="7" or x[1]=="7" or x[2]=="7":
ans = "Yes"
else:
ans = "No"
print(ans)
# %%
| 0 | null | 84,293,913,429,518 | 271 | 172 |
def main():
N,K=map(int,input().split())
res=0
MOD=10**9+7
for i in range(K,N+2):
MAX=(N+(N-i+1))*i//2
MIN=(i-1)*i//2
res+=MAX-MIN+1
res%=MOD
print(res%MOD)
if __name__=="__main__":
main() | import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
N, M = map(int, input().split())
ans = N * (N - 1) // 2 + M * (M - 1) // 2
print(ans)
if __name__ == '__main__':
solve()
| 0 | null | 39,522,652,843,740 | 170 | 189 |
H,N = map(int,input().split())
AB = [tuple(map(int,input().split())) for _ in range(N)]
INF = float("inf")
dp0 = [INF]*(H+1)
dp1 = [0]*(H+1)
dp0[0] = 0
for i in range(N):
a,b = AB[i]
dp1[H] = dp0[H]
for h in range(H-1, -1, -1):
dp1[h] = min(dp0[h], dp1[h+1])
for h in range(H+1):
dp1[h] = min(dp1[h], dp1[max(h-a,0)]+b)
t = dp1
dp1 = dp0
dp0 = t
print(dp0[H]) | from math import factorial
n,a,b=map(int,input().split())
mod=10**9+7
nCa=1
nCb=1
tmp=n
for i in range(a):
nCa*=tmp
tmp-=1
nCa%=mod
nCa=nCa*pow(factorial(a),mod-2,mod)%mod
tmp=n
for i in range(b):
nCb*=tmp
tmp-=1
nCb%=mod
nCb=nCb*pow(factorial(b),mod-2,mod)%mod
print(((pow(2,n,mod))-nCa-nCb-1)%mod) | 0 | null | 73,409,976,903,898 | 229 | 214 |
n,r = input().split()
n = int(n)
r = int(r)
if n >= 10:
i = r
else:
i = r + 100 * (10 - n)
print(i) | K = int(input())
S = input()
if len(S) <= K:
print(S)
else:
s = ""
for i in range(K):
s += S[i]
s += "..."
print(s) | 0 | null | 41,628,564,044,718 | 211 | 143 |
A=int(input())
l=list(map(int,input().split()))
right=l[0]
left=sum(l[1:])
ans=left-right
for i in range(A-2):
right+=l[i+1]
left-=l[i+1]
ans=min(ans,abs(right-left))
print(ans) | import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
def gcd(*numbers): reduce(math.gcd, numbers)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
count = 0
ans = 0
N = k()
A = l()
S = sum(A)
minx = S
sum = 0
for x in A:
sum += x
minx = min(minx, abs(sum-(S-sum)))
print(minx)
| 1 | 142,327,958,288,320 | null | 276 | 276 |
N=int(input())
S=input()
ans=""
for i in range(len(S)):
ans+=chr(ord("A")+(ord(S[i])-ord("A")+N)%26)
print(ans) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(input())
s = input()
ans = ""
for c in s:
ans += chr((ord(c)+n-ord("A"))%26 + ord("A"))
print(ans) | 1 | 134,461,164,056,832 | null | 271 | 271 |
import collections
N=int(input())
A=list(map(int,input().split()))
D = collections.Counter(A)
s=0
for i in D:
s+=D[i]*(D[i]-1)//2
for i in range(N):
print(s-(D[A[i]]-1)) | from collections import Counter
n = int(input())
A = list(map(int,input().split()))
Acount = Counter(A)
total = 0
for key in Acount.keys():
total += Acount[key] * (Acount[key] - 1) // 2
for i in range(n):
tmp = total
tmp -= Acount[A[i]]*(Acount[A[i]]-1) // 2
tmp += (Acount[A[i]]-1)*(Acount[A[i]]-2) // 2
print(tmp) | 1 | 47,766,333,331,948 | null | 192 | 192 |
N, M = map(int, input().split())
a = [2*10**5+1] + sorted(map(int, input().split()), reverse=True)
def solve(x):
count = 0
j = N
for i in range(1, N+1):
while a[i] + a[j] < x:
j -= 1
count += j
return count
left, right = 0, 2*10**5+1
while left < right - 1:
mid = (left + right) // 2
if solve(mid) >= M:
left = mid
else:
right = mid
acc = a[:]
acc[0] = 0
for i in range(N):
acc[i+1] += acc[i]
ans = 0
j = N
for i in range(1, N+1):
while a[i] + a[j] < left+1:
j -= 1
ans += a[i]*j + acc[j]
M -= j
if M:
ans += left * M
print(ans) | import bisect
N, M = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
B = [0] * N
B[-1] = A[-1]
for i in range(N - 2, -1, -1):
B[i] = B[i+1]+A[i]
def C(mid):
tmp = 0
for a in A:
pos = bisect.bisect_right(A, mid - a)
tmp += N-pos
return tmp > M
lb = 0
rb = 10**6
while rb - lb > 1:
happy = (lb + rb) // 2
if C(happy):
lb = happy
else:
rb = happy
ans = 0
cnt = 0
for a in A:
pos = bisect.bisect_right(A, rb - a)
if pos == N:
continue
ans += B[pos]+(N-pos)*a
cnt += N - pos
ans += (M-cnt)*rb
print(ans)
| 1 | 107,699,138,495,700 | null | 252 | 252 |
import sys
sys.setrecursionlimit(10**9)
n,m = list(map(int,input().split()))
d = {}
for i in range(m):
fr, to = list(map(int,input().split()))
d[fr] = d.get(fr, []) + [to]
d[to] = d.get(to, []) + [fr]
visited = [0 for i in range(n+1)]
def connect(node, i):
visited[node] = i
if node in d:
for neig in d[node]:
if visited[neig] == 0:
connect(neig, i)
ans = 1
for key in range(1,n+1):
if visited[key] == 0:
connect(key, ans)
ans += 1
print(max(visited)-1)
| s=input()
n=len(s)
p=n//2
t=1
for i in range(p):
if s[i]==s[p-1-i]:
t=1
else:
t=0
break;
x=1
for i in range(p):
if s[p+1+i]==s[n-1-i]:
x=1
else:
x=0
break
y=1
for i in range(n):
if s[i]==s[n-1-i]:
y=1
else:
y=0
break
if (t==1 and x==1 and y==1):
print('Yes')
else:
print('No') | 0 | null | 24,331,454,307,198 | 70 | 190 |
N = int(input())
S = list(map(int,input().split()))
ans = 0
for x in range(N-1):
for y in range(x+1,N):
ans += S[x]*S[y]
print(ans) | N = int(input())
S = str(input())
count = 1
for i in range(N-1):
if S[i]!=S[i+1]:
count += 1
print(count) | 0 | null | 168,830,062,931,332 | 292 | 293 |
n=input()
m=len(n)
li=[]
for i in range(m):
li.append(n[i])
for i in range(len(li)):
if li[i]=="?":
li[i]="D"
else:
pass
print("".join(li)) | # https://atcoder.jp/contests/abc163/tasks/abc163_d
def main():
MOD = 10**9 + 7
n, k = [int(i) for i in input().strip().split()]
table = [0] * (n + 2)
table[1] = 1
for i in range(2, n + 1):
table[i] = table[i - 1] + i
ans = 0
for i in range(k, n + 1):
_min = table[i - 1]
_max = table[n] - table[n - i]
ans += _max - _min + 1
ans %= MOD
print((ans + 1) % MOD)
if __name__ == "__main__":
main()
| 0 | null | 25,870,744,459,370 | 140 | 170 |
import string
from itertools import zip_longest
turn = int(input())
dic = {s: i for i, s in enumerate(string.ascii_lowercase)}
t_s, h_s = 0, 0
for _ in range(turn):
t, h = input().split()
if t == h:
t_s += 1
h_s += 1
for t_c, h_c in zip_longest(t, h, fillvalue='a'):
if dic[t_c] > dic[h_c]:
t_s += 3
break
elif dic[t_c] < dic[h_c]:
h_s += 3
break
print(t_s, h_s)
| from math import sqrt
x = int(input())
while True:
f = 1
s = int(sqrt(x))
for i in range(2, s+1):
if x % i == 0:
f = 0
break
if f == 1:
print(x)
break
x += 1 | 0 | null | 53,785,083,098,278 | 67 | 250 |
n = int(input())
print(input().count("ABC")) | n=int(input())
a=list(map(int,input().split()))
count=0
total=0
for i in range(n):
if a[i]%2==0:
count+=1
if a[i]%3==0 or a[i]%5==0:
total+=1
if count==total:
print("APPROVED")
else:
print("DENIED") | 0 | null | 83,877,489,173,916 | 245 | 217 |
N, P = map(int, input().split())
S = input()
ans = 0
if P == 2 or P == 5 :
for i in range(N) :
if int(S[i])%P == 0 :
ans += i+1
print(ans)
exit()
modP = [0 for _ in range(P)]
modP[0] = 1
now = 0
t = 1
for i in range(N) :
now += int(S[-1-i]) * t
now %= P
modP[now] += 1
t = t * 10 % P
for r in modP :
ans += r*(r-1)//2
print(ans)
| import sys
input = sys.stdin.readline
N, P = map(int, input().split())
S = list(input().rstrip())
if P in {2, 5}:
ans = 0
for i, s in enumerate(S):
if int(s) % P == 0:
ans += i+1
else:
ans = 0
T = [0]*P
T[0] = 1
tmp = 0
k = 1
for s in reversed(S):
tmp = (tmp + k * int(s)) % P
k = k * 10 % P
ans += T[tmp]
T[tmp] += 1
print(ans) | 1 | 58,382,207,100,282 | null | 205 | 205 |
import numpy as np
H, N = map(int, input().split())
A = []
B = []
for i in range(N):
a, b = map(int, input().split())
A.append(a)
B.append(b)
A = np.array(A)
B = np.array(B)
DP = np.zeros(H + 1)
for i in range(1, H + 1):
DP[i] = np.amin(DP[np.maximum(i - A, 0)] + B)
print(int(DP[-1]))
| a = int(input())
res = a > 29 and 'Yes' or 'No'
print(res)
| 0 | null | 43,488,065,119,600 | 229 | 95 |
from itertools import product
n = int(input())
al = []
for _ in range(n):
curr_al = []
a = int(input())
for i in range(a):
x,y = map(int, input().split())
curr_al.append((x,y))
al.append(curr_al)
pattern = 2
ite = product(range(pattern),repeat=n)
ans = 0
for it in ite:
a_01_l = list(it)
curr_ans = a_01_l.count(1)
# print('-----')
# print(a_01_l)
for i, curr_it in enumerate(it):
if curr_it == 1:
check = True
for a in al[i]:
if a_01_l[a[0]-1] != a[1]:
check = False
if not check:
break
else:
# print('ok')
ans = max(curr_ans,ans)
print(ans)
| n = int(input())
d = dict()
for i in range(n):
a = int(input())
for j in range(a):
l = d.get(i, [])
p, t = list(map(int, input().split(' ')))
l.append((p-1, t))
d[i] = l
# d[i] に i番の人の証言のlistがあるので 全パターン(=2^15)で矛盾しないか試す？
def get_bit_array(num):
res = []
while num > 0:
res.append(num%2)
num //= 2
while len(res) < n:
res = res + [0]
return res[::-1]
def valid(tfs):
for i in range(len(tfs)):
honest = tfs[i]
if not honest: # 嘘つきは無視する
continue
for (person, tf) in d.get(i, []): # 合ってる？
if tfs[person] != tf:
return False
return True
ans = 0
def f(num):
global ans
if num >= 2**n:
return
tfs = get_bit_array(num) # tfs = [1,0,1,0,...0] true or flase
total = sum(tfs)
if valid(tfs):
ans = max(ans, total)
for i in range(int(2**n)):
f(i)
print(ans)
| 1 | 122,004,953,897,878 | null | 262 | 262 |
nm = input().split()
n, m = map(int, nm)
A = [[int(i) for i in input().split()] for j in range(n)]
b = [int(input()) for i in range(m)]
for row in A:
s = 0
for i, elm in enumerate(row):
s += (elm*b[i])
print(s) | from collections import deque
n=int(input())-10
q=deque(range(1,10))
while n>=0:
a=str(q.popleft())
a=int(a+a[-1])
for i in range(a-1,a+2):
if str(i)[-2]==str(a)[-1]:
q.append(i)
n-=1
print(q[n])
#print(q,n) | 0 | null | 20,687,719,114,688 | 56 | 181 |
import math
while True:
n=int(input())
if n==0:break
else:
s = list(map(int, input().split())) #入力の値が横並びの時使う
x=sum(s)
y=x/n
a=0
for i in range(n):
z=(s[i]-y)**2
a+=z
b=math.sqrt(a/n)
print(format(b, '.8f'))
| import statistics
while input() != "0":
print("{0:.6f}".format(statistics.pstdev(map(float, input().split())))) | 1 | 193,633,582,836 | null | 31 | 31 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [aa-1 for aa in a]
check = [0 for i in range(n)]
count = 0
point = 0
check[0] = 1
path = [0]
for i in range(min(n, k)):
if i == 0 or check[point] == 0:
check[point] = i+1
point = a[point]
path.append(point)
else:
break
cycle_len = len(path)-check[point]
pre = check[point]
if pre > k:
print(path[k])
else:
k -= pre
k %= cycle_len
print(path[pre+k]+1)
| from math import log2
n,k = map(int, input().split())
al = list(map(int, input().split()))
logk = int(log2(k))+1
db = [ [0]*n for _ in range(logk) ]
for ni in range(n):
db[0][ni] = al[ni]-1
for ki in range(logk-1):
for ni in range(n):
db[ki+1][ni] = db[ki][db[ki][ni]]
now = 0
for i in range(logk):
if k&(1<<i) > 0:
now = db[i][now]
print(now+1)
| 1 | 22,564,773,054,008 | null | 150 | 150 |
N, M = map(int, input().split())
A = list(map(int, input().split()))
w = sum(A)
ans = N - w
if ans >= 0:
print(ans)
else:
print(-1) | a, n = input().split()
a = int(a)
n = int(n)
p = list(map(int, input().split()))
c = 0
for i in range(n):
c += p[i]
if c > a:
print(-1)
else:
print(a-c)
| 1 | 31,914,821,853,888 | null | 168 | 168 |
def insertion_sort(a, g, cnt):
for i in range(g, len(a)):
v = a[i]
j = i - g
while j >= 0 and a[j] > v:
a[j+g] = a[j]
j = j - g
cnt += 1
a[j+g] = v
return cnt
n = int(input())
g = [1]
t = 1
cnt = 0
while 1:
t = 3 * t + 1
if t < n and len(g) < 100:
g += [t]
else:
g = g[::-1]
break
a = [int(input()) for _ in range(n)]
for i in range(0, len(g)):
cnt = insertion_sort(a, g[i], cnt)
print(len(g))
print(*g)
print(cnt)
for i in a: print(i)
| def insertionSort(arr,step):
count = 0
for i in range(step, len(arr)):
j = i
while j >= step and arr[j] < arr[j-step]:
count += 1
t = arr[j]
arr[j] = arr[j-step]
arr[j-step] = t
j -= step
return count
def shellSort(arr):
gaps = [776591, 345152, 153401, 68178, 30301, 13467, 5985, 2660, 1182, 525, 233, 103, 46, 20, 9, 4, 1]
m = 0
count = 0
for step in gaps:
if step > len(arr):
continue
m += 1
count += insertionSort(arr, step)
print(m)
print(" ".join(map(str, gaps[len(gaps)-m:])))
print(count)
for num in arr:
print(num)
arr = list()
for _ in range(int(input())):
arr.append(int(input()))
shellSort(arr)
| 1 | 31,495,475,880 | null | 17 | 17 |
N=int(input())
D=[{} for _ in range(N+1)]
for i in range(1,N+1):
A=int(input())
for k in range(A):
p,x=map(int,input().split())
D[i][p]=x
Max=0
for x in range(2**N):
y=x
B=["*"]*(N+1)
for i in range(N):
B[i+1]=y%2
y>>=1
Flag=True
for i in range(1,N+1):
if B[i]==1:
for k in D[i]:
Flag&=(B[k]==D[i][k])
if Flag:
Max=max(Max,B.count(1))
print(Max)
| n = int(input())
nn = n**2
nnn = n**3
print(n+nn+nnn) | 0 | null | 65,793,911,781,158 | 262 | 115 |
s = list(str(input()))
q = int(input())
from collections import deque
s = deque(s)
cnt = 0
for i in range(q):
query = list(map(str, input().split()))
if len(query) == 1:
cnt += 1
else:
t, f, c = query
if f == '1':
if cnt%2 == 0:
s.appendleft(c)
else:
s.append(c)
else:
if cnt%2 == 0:
s.append(c)
else:
s.appendleft(c)
s = list(s)
if cnt%2 == 1:
s.reverse()
print(''.join(s))
| from collections import deque
s = list(input())
Q = int(input())
r = False
q = deque(s)
for _ in range(Q):
query = list(map(str, input().split()))
if query[0] == '1':
r = not r
else:
f,c = query[1],query[2]
if f == '1':
if not r:
q.appendleft(c)
else:
q.append(c)
else:
if not r:
q.append(c)
else:
q.appendleft(c)
ans = list(q)
if r: ans = ans[::-1]
print(''.join(ans))
| 1 | 57,249,565,111,340 | null | 204 | 204 |
class Node:
def __init__(self):
self.distime = 0
self.fintime = 0
def input_data(self, nodes):
data = input().split()
self.number = int(data[0])
self.v = [nodes[int(x) - 1] for x in data[2:]]
@property
def status(self):
return bool(self.distime) + bool(self.fintime)
class Stack:
def __init__(self, size):
self.size = size
self.N = [None for _ in range(size)]
self.top = 0
def is_emtpy(self):
return self.top == 0
def is_full(self):
return self.top == self.size
def front(self):
return self.N[self.top - 1]
def push(self, x):
if self.is_full():
raise OverflowError
self.N[self.top] = x
self.top += 1
def pop(self):
if self.is_emtpy():
raise IndexError
self.top -= 1
return self.N[self.top]
def visit(node: Node):
global t
stack.push(node)
t += 1
node.distime = t
while not stack.is_emtpy():
u: Node = stack.front()
try:
v = next(i for i in u.v if i.status == 0)
except StopIteration:
stack.pop()
t += 1
u.fintime = t
else:
if v.status == 0:
stack.push(v)
t += 1
v.distime = t
n = int(input())
stack = Stack(n)
nodes = [Node() for _ in range(n)]
[node.input_data(nodes) for node in nodes]
t = 0
for node in nodes:
if node.status == 0:
visit(node)
nodes.sort(key=lambda i: i.number)
for node in nodes:
print(f"{node.number} {node.distime} {node.fintime}")
| 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) | 0 | null | 18,153,538,528,752 | 8 | 175 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.