code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
def f(s):
a=[-c]
for i,s in enumerate(s,1):
if s<'x'and a[-1]+c<i:a+=i,
return a[1:k+1]
n,s=open(0)
n,k,c=map(int,n.split())
for a,b in zip(f(s[:n]),f(s[-2::-1])[::-1]):
if a==n+1-b:print(a) | n,k=map(int,input().split())
h=[int(x) for x in input().rstrip().split()]
h.sort(reverse=True)
for i in range(min(k,n)):
h[i]=0
print(sum(h))
| 0 | null | 60,024,818,091,480 | 182 | 227 |
N=int(input())
X=input()
c=X.count('1')
r1=int(X,2)%(c-1) if c>1 else 0
r2=int(X,2)%(c+1)
d=[0]*(N+1)
for i in range(N):
d[i+1]=d[(i+1)%bin(i+1).count('1')]+1
for i in range(N):
if X[i]=='0':
n=(r2+pow(2,N-i-1,c+1))%(c+1)
else:
if c==1:
print(0)
continue
n=(r1-pow(2,N-i-1,c-1))%(c-1)
print(d[n]+1) | N,D = map(int,input().split())
ans = 0
for i in range(N):
X1,Y1 = map(int,input().split())
if X1*X1+Y1*Y1 <= D*D:
ans += 1
print(ans) | 0 | null | 7,105,457,872,520 | 107 | 96 |
temperature = int(input())
if temperature >= 30:
print('Yes')
else:
print('No') | import sys
sys.setrecursionlimit(10**6)
x = int(input())
if x >= 30:
print('Yes')
else:
print('No') | 1 | 5,786,798,840,302 | null | 95 | 95 |
n = int(input())
a = list(map(int, input().split()))
INF = 1001001001001001
c = n//2
dp = [[-INF]*3 for _ in range(c+1)]
dp[0][0] = 0
for i in range(c+1):
for j in range(3):
for k in range(3):
if i+1<=c and j+k<3 and 2*i+j+k<n:
dp[i+1][j+k] = max(dp[i+1][j+k], dp[i][j]+a[2*i+j+k])
ans = -INF
for i in range(3):
ans = max(ans,dp[c][i])
print(ans) | N = int(input())
A = list(map(int,input().split()))
K = 2 if N%2 else 1
INF = float('inf')
dp = [[[-INF]*2 for _ in range(K+1)] for _ in range(N+1)]
dp[0][K][0] = 0 #dp[i][can_skip][must_skip]
for i,a in enumerate(A):
for k in range(K,-1,-1):
dp[i+1][k][0] = max(dp[i+1][k][0], dp[i][k][1])
dp[i+1][k][1] = max(dp[i+1][k][1], dp[i][k][0] + a)
if k:
dp[i+1][k-1][0] = max(dp[i+1][k-1][0], dp[i][k][0])
print(max(max(row) for row in dp[-1][:2])) | 1 | 37,495,917,373,538 | null | 177 | 177 |
N = int(input())
A = list(map(int,input().split()))
dic = {}
for a in A:
if a not in dic:
dic[a]=1
else:
print('NO');exit()
print('YES') | n = int(input())
num_list = list(map(int, input().split()))
sets = set(num_list)
if len(num_list) == len(sets):
ans = 'YES'
else:
ans = 'NO'
print(ans) | 1 | 73,908,908,144,890 | null | 222 | 222 |
h, w = map(int, input().split())
hd, hm, wd, wm = h // 2, h % 2, w // 2, w % 2
s = hd * wd * 2 + hm * wd + wm * hd + hm * wm
if h == 1 or w == 1:
s = 1
print(s)
| n=int(input())
if n%2:
a=list(map(int,input().split()))
s=[[a[0],0,0],[0,a[1],0],[a[0]+a[2],0,a[2]]]+[[0,0,0]for i in range(3,n)]
for i in range(3,n):
if i%2:
s[i][1]=max(s[i-2][1],s[i-3][0])+a[i]
else:
s[i][0]=s[i-2][0]+a[i]
s[i][2]=max([s[i-2][2],s[i-3][1],s[i-4][0]])+a[i]
print(max([s[-1][2],s[-2][1],s[-3][0]]))
else:
a=list(map(int,input().split()))
s=[a[0],a[1]]+[0 for i in range(2,n)]
for i in range(2,n):
if i%2:
s[i]=max([s[i-2],s[i-3]])+a[i]
else:
s[i]=s[i-2]+a[i]
print(max(s[-2:])) | 0 | null | 43,985,243,162,448 | 196 | 177 |
n = input()
s = input().split()
q = input()
t = input().split()
ans = 0
for c1 in t:
for c2 in s:
if c1 == c2:
ans += 1
break
print(ans) | # Circle Pond
R = int(input())
print(R*2 * 3.14159265)
| 0 | null | 15,774,245,164,980 | 22 | 167 |
import sys
SUITS = ['S', 'H', 'C', 'D']
exist_cards = {suit:[] for suit in SUITS}
n = input()
for line in sys.stdin:
suit, number = line.split()
exist_cards[suit].append(int(number))
for suit in SUITS:
for i in range(1, 14):
if i not in exist_cards[suit]:
print(suit, i) | N,R = list(map(int,input().split()))
ans=R
if N < 10:
ans += 100*(10-N)
print(ans) | 0 | null | 32,345,671,374,148 | 54 | 211 |
#coding:utf-8
from copy import deepcopy
n = int(input())
A = list(input().split())
B = deepcopy(A)
def BubbleSort(A,N):
for i in range(N):
for j in range(N-1,i,-1):
if A[j][1] < A[j-1][1]:
A[j], A[j-1] = A[j-1], A[j]
def SelectionSort(A,N):
for i in range(N):
minj = i
for j in range(i,N):
if A[j][1] < A[minj][1]:
minj = j
A[i], A[minj] = A[minj], A[i]
BubbleSort(A,n)
SelectionSort(B,n)
A = " ".join([data for data in A])
B = " ".join([data for data in B])
print(A)
print("Stable")
print(B)
if A == B:
print("Stable")
else:
print("Not stable")
| class Card:
def __init__(self, inf):
self.num = int(inf[1])
self.inf = inf
n, card = int(input()), [Card(i) for i in input().split()]
card1 = card[:]
for i in range(n-1):
for j in range(n-1, i, -1):
if card[j].num < card[j-1].num:
card[j], card[j-1] = card[j-1], card[j]
print(" ".join([i.inf for i in card]))
print("Stable")
for i in range(n-1):
for j in range(i+1, n):
if j == i+1:
idx = j
elif card1[idx].num > card1[j].num:
idx = j
if card1[i].num > card1[idx].num:
card1[i], card1[idx] = card1[idx], card1[i]
print(" ".join([i.inf for i in card1]))
if card == card1:
print("Stable")
else:
print("Not stable")
| 1 | 25,661,054,098 | null | 16 | 16 |
a,b=map(int,input().split())
ans=a-b*2
if a<=b*2:
ans=0
print(ans) |
import random
import copy
import time
def evaluateSatisfaction(d, c, s, ans):
score = 0
last = [-1 for i in range(26)]
for i in range(d):
score += s[i][ans[i]]
last[ans[i]] = i
for j in range(26):
if j != ans[i] or True:
score -= c[j]*(i - last[j])
return score
def valuationFunction(d,c,s,contestType,day,last):
gain = s[day][contestType]
#78 = (1/2) * ((13*13) - 13)
lost = c[contestType] * (78)
return gain - lost
def Input():
d = int(input())
c = list(map(int, input().split()))
s = [list(map(int, input().split())) for i in range(d)]
#s[3][25] = contest(25+1) of day(3+1)
return d, c, s
def evolution(d, c, s, ans):
score_before = evaluateSatisfaction(d, c, s, ans)
ans_after = copy.copy(ans)
idx1 = random.randint(0,d-1)
idx2 = random.randint(0,d-1)
tmp = ans_after[idx1]
ans_after[idx1] = ans_after[idx2]
ans_after[idx2] = tmp
score_after = evaluateSatisfaction(d,c,s,ans_after)
if score_after > score_before:
return ans_after
else:
return ans
if __name__ == "__main__":
d, c, s = Input()
#print("val =", evaluateSatisfaction(d, c, s, [1, 17, 13, 14, 13]))
#calc start
t1 = time.time()
ans = [0 for i in range(d)]
last = [-1 for i in range(26)]
for i in range(d):
evalValueList = [0 for j in range(26)]
for j in range(26):
evalValueList[j] = valuationFunction(d, c, s, j,i,last)
max_idx = 0
max = evalValueList[0]
for j in range(26):
if (max < evalValueList[j]):
max_idx = j
max = evalValueList[j]
ans[i] = max_idx
last[ans[i]] = i
#ans = [1, 2, 3, 4, 5]
t2 = time.time()
while(float(t2-t1) < 1.0):
ans = evolution(d, c, s, ans)
#print("ans = ",evaluateSatisfaction(d,c,s,ans))
t2 = time.time()
for x in ans:
print(x + 1)
#print(evaluateSatisfaction(d,c,s,ans)) | 0 | null | 87,815,083,092,672 | 291 | 113 |
L, R, d = map(int, input().split())
a = 1
ans = 0
while a*d <= R:
if a*d >= L:
ans += 1
a += 1
print(ans) | def get_ints():
return map(int, input().split())
def get_list():
return list(map(int, input().split()))
l, r, d = get_ints()
c = 0
for i in range(l, r + 1):
if i % d == 0:
c += 1
print(c) | 1 | 7,536,797,655,410 | null | 104 | 104 |
N, K = map(int, input().split())
P = list(map(int, input().split()))
C = list(map(int, input().split()))
seen = []
roots = []
candidates = []
for i in range(N):
if i+1 in seen:
continue
root = [i+1]
seen.append(i+1)
to = P[i]
while(root[0] != to):
root.append(to)
seen.append(to)
to = P[to-1]
roots.append(root)
for root in roots:
length = len(root)
eachMoveBests = [None] * length
for i in range(length):
score = 0
to = P[root[i]-1]
for j in range(len(root)):
score += C[to-1]
to = P[to-1]
if eachMoveBests[j] == None or score > eachMoveBests[j]:
eachMoveBests[j] = score
# 周回スコア
aroundScore = eachMoveBests[len(eachMoveBests)-1]
if length < K and aroundScore > 0:
for i in range(len(eachMoveBests)):
if K-i-1 % length == 0:
candidates.append(aroundScore * ((K-i-1) // length))
else:
candidates.append(aroundScore * ((K-i-1) // length) + eachMoveBests[i])
else:
candidates.append(max(eachMoveBests[:K]))
print(max(candidates))
| import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n, k = map(int, input().split())
P = list(map(lambda x : int(x) - 1, input().split()))
C = list(map(int, input().split()))
# doubling table
nexts = [P]
vals = [C]
totals = [C]
for _ in range(60):
next, val, total = nexts[-1], vals[-1], totals[-1]
nnext, nval, ntotal = [0] * n, [0] * n, [0] * n
for i in range(n):
nnext[i] = next[next[i]]
nval[i] = val[i] + val[next[i]]
ntotal[i] = max(total[i], val[i] + total[next[i]])
nexts.append(nnext)
vals.append(nval)
totals.append(ntotal)
# answer
ans = -INF
for now in range(n):
score = 0
for d in range(59, -1, -1):
if k >> d & 1:
ans = max(ans, score + totals[d][now])
score += vals[d][now]
now = nexts[d][now]
print(ans)
resolve() | 1 | 5,376,456,407,698 | null | 93 | 93 |
cards = [[False for i in range(13)] for j in range(4)]
pattern = ["S", "H", "C", "D"]
cnt = int(input())
for i in range(cnt):
ch,rank = input().split()
rank = int(rank)
cards[pattern.index(ch)][rank-1] = True
for i in range(4):
for j in range(13):
if cards[i][j] == False:
print(pattern[i], j+1)
| n = int(raw_input())
temp = ''
S = ['S']
D = ['D']
H = ['H']
C = ['C']
for i in range(n):
temp = str(raw_input())
if temp[0] == 'S':
S.append(temp)
elif temp[0] == 'H':
H.append(temp)
elif temp[0] == 'C':
C.append(temp)
elif temp[0] == 'D':
D.append(temp)
def find(X):
frag = 0
for i in range(1, 14):
for j in range(1, len(X)):
if X[j] == X[0][0] + ' ' + str(i):
frag = 1
break
if frag == 0:
print X[0][0] + ' ' + str(i)
frag = 0
find(S)
find(H)
find(C)
find(D) | 1 | 1,034,332,578,762 | null | 54 | 54 |
#bubble
N=int(input())
A=[int(i) for i in input().split()]
fl=1
C=0
while fl==1:
fl=0
for j in range(N-1):
if A[N-1-j]<A[N-2-j]:
t=A[N-1-j]
A[N-1-j]=A[N-2-j]
A[N-2-j]=t
C+=1
fl=1
for j in range(N):
A[j]=str(A[j])
print(" ".join(A))
print(C) | import math
ans = []
while True:
data = input().split()
a = int(data[0])
b = data[1]
c = int(data[2])
if b == '+':
ans += [a+c]
elif b == '-':
ans += [a-c]
elif b == '*':
ans += [a*c]
elif b == '/':
ans += [math.floor(a/c)]
elif b == '?':
break
else:
break
for output in ans:
print(output)
| 0 | null | 351,918,819,252 | 14 | 47 |
def print_rectangle(h, w):
"""
h: int
w: int
outputs rectangle using '#'
>>> print_rectangle(3, 4)
####
####
####
>>> print_rectangle(5, 6)
######
######
######
######
######
>>> print_rectangle(2, 2)
##
##
"""
for i in range(h):
print('#' * w)
if __name__ == '__main__':
#import doctest
#doctest.testmod()
while True:
(h, w) = [int(i) for i in input().split(' ')]
if h == 0 and w == 0:
break
print_rectangle(h, w)
print() | def main(A,B,C,K):
ans=False
while K >= 0:
if A < B:
if B < C:
ans=True
return ans
else:
C = C * 2
else:
B = B * 2
K=K-1
return ans
A,B,C=map(int, input().split())
K=int(input())
ans=main(A,B,C,K)
print('Yes' if ans else 'No') | 0 | null | 3,798,165,849,968 | 49 | 101 |
import numpy as np
import math
from decimal import *
#from numba import njit
def getVar():
return map(int, input().split())
def getArray():
return list(map(int, input().split()))
def getNumpy():
return np.array(list(map(int, input().split())), dtype='int64')
def factorization(n):
d = {}
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
d.update({i: cnt})
if temp!=1:
d.update({temp: 1})
if d==[]:
d.update({n:1})
return d
def main():
N = int(input())
d = factorization(N)
count = 0
for v in d.values():
i = 1
while(v >= i):
v -= i
i += 1
count += 1
print(count)
main() | N=int(input())
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
l=prime_factorize(N)
L=set(l)
z=0
for j in L:
i=1
while i*(i+1)//2<=l.count(j):
i+=1
z+=i-1
print(z) | 1 | 16,963,402,786,678 | null | 136 | 136 |
N, S=list(map(int,input().split()))
A=list(map(int,input().split()))
A=[0]+A
dp=[[0 for j in range(S+1)] for i in range(N+1)]
dp[0][0]=1
for i in range(1,N+1):
for j in range(S+1):
dp[i][j]=(dp[i][j]+2*dp[i-1][j]) %998244353 # x[i]を入れないが、大きい方に入れるか入れないかが二通り
for j in range(S-A[i]+1):
dp[i][j+A[i]]=(dp[i][j+A[i]]+dp[i-1][j]) %998244353 # x[i]を入れる
print(dp[N][S]) | import numpy as np
N, S = [int(_) for _ in input().split()]
A = [int(_) for _ in input().split()]
mod = 998244353
coef = np.zeros(3001, dtype=int)
coef[0] = 1
for a in A:
coef2 = coef[:-a].copy()
coef *= 2
coef[a:] += coef2
coef %= mod
print(coef[S])
| 1 | 17,595,902,665,120 | null | 138 | 138 |
a,b = list(map(int, input().split()))
print('%i %i %10.8f' %(a//b, a%b, a/b)) | [a,b] = map(int, input().split())
print("%d %d %f" % (a // b, a % b, a / b)) | 1 | 598,571,255,100 | null | 45 | 45 |
x, k, d = map(int, input().split())
x = abs(x)
if x > k*d:
print(x-k*d)
else:
p = x//d
c = k-p
if (c%2 == 0):
print(abs(x-p*d))
else:
print(abs(d-abs(x-p*d)))
| X,k,d = map(int,input().split())
x = abs(X)
if x >= k*d:
print(x - d*k)
else:
e = x//d
k -= e
x %= d
if k % 2 == 0:
print(x)
else:
print(d-x)
| 1 | 5,204,929,110,990 | null | 92 | 92 |
from collections import defaultdict
N, P = map(int,input().split())
S = input()
if P==5:
ans = 0
for i,m in enumerate(S):
if m == '5' or m == '0':
ans += i+1
elif P==2:
ans = 0
for i,m in enumerate(S):
if int(m) % 2 ==0:
ans += i+1
else:
S = S[::-1]
primdic = defaultdict(int)
before = 0
for i in range(0,N):
now = (int(S[i])*pow(10,i,P)+before)%P
primdic[now] += 1
before = now
# 文字なしの時はあまり0なので
primdic[0] += 1
ans = 0
for value in primdic.values():
ans += value*(value-1)//2
print(ans) | import sys
import heapq
from collections import defaultdict
stdin = sys.stdin
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def naa(N): return [na() for _ in range(N)]
def ns(): return stdin.readline().rstrip() # ignore trailing spaces
N, K = na()
A_array = na()
cusum = 0
mod_array = [0]
for i, a in enumerate(A_array):
cusum = (cusum + a) % K
mod = (cusum + K - (i+1)) % K
mod_array.append(mod)
# print(mod_array)
ans = 0
mod_queue = []
cnt_dic = defaultdict(int)
for i, v in enumerate(mod_array):
heapq.heappush(mod_queue, (i, 1, v))
while(len(mod_queue)):
i, q, v = heapq.heappop(mod_queue)
if q == 1:
ans += cnt_dic[v]
cnt_dic[v] += 1
if i + K <= N:
heapq.heappush(mod_queue, (i+K-0.5, 2, v))
else:
cnt_dic[v] -= 1
# print(i, v, q, ans)
print(ans)
| 0 | null | 97,541,565,571,492 | 205 | 273 |
a, b = tuple(map(int, input().split()))
print(round(a * b)) | x, y = [int(x) for x in input().split()]
print(x*y)
| 1 | 15,793,362,598,780 | null | 133 | 133 |
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
def main():
n=int(input())
a=list(map(int,input().split()))
mod=pow(10,9)+7
lcma={}
for ai in a:
f=factorization(ai)
for fi in f:
if fi[0] in lcma:
lcma[fi[0]]=max(lcma[fi[0]],fi[1])
else:
lcma[fi[0]]=fi[1]
l=1
for k,v in lcma.items():
l*=pow(k,v,mod)
l%=mod
ans=0
for ai in a:
ans+=l*pow(ai,mod-2,mod)
ans%=mod
print(ans)
main()
| import math
from functools import reduce
def lcm_base(x, y):
return (x * y) // math.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
N = int(input())
A = list(map(int,input().split()))
ans = 0
lcm = lcm_list(A)
for i in range(N):
ans += lcm//A[i]
print(ans%1000000007) | 1 | 87,604,407,379,082 | null | 235 | 235 |
from math import ceil
n=int(input())
s=100000
for i in range(n):
s +=(s*0.05)
s=int(int(ceil(s/1000)*1000))
print(s) | import sys
import math
def main():
n = int(input().rstrip())
r = 1.05
digit = 3
a = 100000
for i in range(n):
a = math.ceil(a*r/10**digit)*10**digit
print(a)
if __name__ == '__main__':
main() | 1 | 1,095,395,252 | null | 6 | 6 |
n = int(input())
ai = list(map(int, input().split()))
# n=3
# ai = np.array([1, 2, 3])
# ai = ai[np.newaxis, :]
#
# ai2 = ai.T.dot(ai)
# ai2u = np.triu(ai2, k=1)
#
# s = ai2u.sum()
l = len(ai)
integ = [ai[0]] * len(ai)
for i in range(1, len(ai)):
integ[i] = integ[i-1] + ai[i]
s = 0
for j in range(l):
this_s = integ[-1] - integ[j]
s += ai[j] * this_s
ans = s % (1000000000 + 7)
print(ans)
| input()
a = list(map(int, input().split()))
c = 1000000007
print(((sum(a)**2-sum(map(lambda x: x**2, a)))//2)%c) | 1 | 3,809,103,384,658 | null | 83 | 83 |
from collections import deque
N, D, A = map(int, input().split())
mons = []
for _ in range(N):
X, H = map(int, input().split())
mons.append((X, (H + A - 1) // A))
mons.sort()
ans = 0
q = deque([])
tot = 0
for x, h in mons:
while q:
x0, h0 = next(iter(q))
if x - 2 * D <= x0:
break
tot -= h0
q.popleft()
h = max(0, h - tot)
ans += h
tot += h
q.append((x, h))
print(ans)
| import bisect
import math
N, D, A = map(int, input().split())
cusum = [0] * (N+1)
X = []
XH =[]
for i in range(N):
xi, hi = map(int, input().split())
X += [xi]
XH += [(xi, hi)]
X = sorted(X)
XH = sorted(XH)
cusumD = 0
ans = 0
for i, (xi, hi) in enumerate(XH):
cusumD -= cusum[i]
hi = max(0, hi-cusumD)
r = bisect.bisect_right(X, xi+2*D)
b = int(math.ceil(hi/A))
d = b * A
ans += b
cusumD += d
cusum[r] += d
print(ans)
| 1 | 82,113,444,797,332 | null | 230 | 230 |
n = int(input())
my_cards = {input() for _ in range(n)}
lost_cards = (
"{} {}".format(s, i)
for s in ('S', 'H', 'C', 'D')
for i in range(1, 13 + 1)
if "{} {}".format(s, i) not in my_cards
)
for card in lost_cards:
print (card) | import sys
i = 1
while(1):
a = raw_input()
if('0'==a):
break
else:
print "Case %d: %s" % (i, a)
i += 1 | 0 | null | 772,655,110,000 | 54 | 42 |
#!/usr/bin/env python
n = int(input())
arr = [int(i) for i in input().split(' ')]
parr = [0]*n
parr[n-1] = arr[n-1]
ans = 0
mod = int(10**9+7)
for j in range(n-2, -1, -1):
parr[j] = arr[j] + parr[j+1]
ans += arr[j] * parr[j+1]
ans = ans % mod
print(ans)
| 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,797,717,058,212 | null | 83 | 83 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n = list(map(int, list(readline().rstrip().decode())[::-1]))
a = 0
b = 10000
for x in n:
memo = min(a + x, b + x)
b = min(a + 11 - x, b + 9 - x)
a = memo
print(min(a, b))
| x, y, z = map(int, raw_input().split())
cnt = 0
for i in range(x, y+1):
if z%i == 0:
cnt += 1
print cnt | 0 | null | 35,661,899,098,782 | 219 | 44 |
cnt = int(input())
taro = 0
hanako = 0
for i in range(cnt):
li = list(input().split())
if li[0]>li[1]:
taro +=3
elif li[0]==li[1]:
taro +=1
hanako +=1
else:
hanako +=3
print(taro,hanako)
| n = int(input())
ans = 0
for i in range(1,n+1):
if (i % 3 == 0) or (i % 5 == 0):
pass
else:
ans += i
print(ans) | 0 | null | 18,561,376,635,326 | 67 | 173 |
def main():
N, T = list(map(int, input().split(' ')))
foods = [list(map(int, input().split(' '))) for _ in range(N)]
# 食べ物は食べる時間の昇順に並べ替え、短い方を優先して食べるようにしておく。
foods.sort(key=lambda food: food[0])
# dp[n][t]: n個目までの食べ物のうち、時刻tまでに食べきる場合に得られるおいしさの合計の最大値。
dp = [[0 for _ in range(T + 1)] for _ in range(N + 1)]
for i, food in enumerate(foods):
n = i + 1
A, B = food
for t in range(T + 1):
val = dp[n - 1][t]
if t - A >= 0 and dp[n - 1][t - A] + B > val:
val = dp[n - 1][t - A] + B
dp[n][t] = val
# これを求める
# max_n {dp[n - 1][T - 1] + (n個目の食べ物のおいしさ)}
ans = 0
for n in range(1, N + 1):
v = dp[n - 1][T - 1] + foods[n - 1][1]
ans = max(ans, v)
print(ans)
if __name__ == '__main__':
main()
| import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,t = list(map(int, input().split()))
ab = [None]*n
for i in range(n):
ab[i] = tuple(map(int, input().split()))
ab.sort()
dp = [[0]*(t) for _ in range(n)]
for i in range(1, n):
a,b = ab[i-1]
for j in range(t-1, 0, -1):
dp[i][j] = dp[i-1][j]
if j>=a and dp[i][j]<dp[i-1][j-a]+b:
dp[i][j] = dp[i-1][j-a]+b
ans = max((dp[i][t-1] + ab[i][1]) for i in range(n))
print(ans) | 1 | 151,154,098,149,902 | null | 282 | 282 |
a, b, c = map(int, input().split())
if 4 * a * b < (c - a - b) ** 2 and a + b < c:
print('Yes')
else: print('No') | S = input()
length = len(S)
print("x"*length) | 0 | null | 62,403,811,242,306 | 197 | 221 |
N = int(input())
D = [input().split() for i in range(N)]
cnt=0
for i in range(N):
if D[i][0] == D[i][1]:
cnt+=1
if cnt == 3:
print("Yes")
exit()
else:
cnt=0
print("No") | n=int(input())
G=[[0,[],0,-1]]
for i in range(n):
v=[int(j) for j in input().split(" ")]
u=v.pop(0)
k=v.pop(0)
G.append([k,v,0,-1])
distance=0
dis_list=[1]
G[1][3]=0
G[1][2]=1
while len(dis_list)!=0:
distance+=1
dis_list_cash=[]
for i in dis_list:
k=G[i][0]
v=G[i][1]
for j in range(k):
if G[v[j]][2]==0:
G[v[j]][2]=1
G[v[j]][3]=distance
dis_list_cash.append(v[j])
dis_list=dis_list_cash
for i in range(1,n+1):
print(str(i)+" "+str(G[i][3])) | 0 | null | 1,242,517,890,848 | 72 | 9 |
#E
N,K = map(int,input().split())
A = list(map(int,input().split()))
F = list(map(int,input().split()))
A.sort(reverse=True)
F.sort()
left = 0
right = 10**12
while True:
mid = (left+right)//2
if right - left <= 1:
count = 0
for i in range(N):
a = left//F[i]
count+=max(0,A[i]-a)
if count <= K:
ans = left
else:
ans = right
break
count = 0
for i in range(N):
a = mid//F[i]
count+=max(0,A[i]-a)
if count <= K:
right = mid
else:
left = mid
print(ans)
| #!/usr/bin/env python3
S = input()
total = 0
for i in range(len(S)):
if "R" * (i + 1) in S:
total = i + 1
ans = total
print(ans)
| 0 | null | 85,133,476,203,402 | 290 | 90 |
N, K = map(int, input().split())
P = list(map(int, input().split()))
C = list(map(int, input().split()))
P = [None] + P
C = [None] + C
all_max = C[1]
for st in range(1, N + 1):
p = P[st]
scores = [C[p]]
while p != st and len(scores) < K:
p = P[p]
scores.append(C[p])
num_elem = len(scores)
all_sum = sum(scores)
q, r = divmod(K, num_elem)
max_ = scores[0]
temp = scores[0]
max_r = scores[0]
temp_r = scores[0]
for x in range(1, num_elem):
if x < r:
temp_r += scores[x]
max_r = max(max_r, temp_r)
temp += scores[x]
max_ = max(max_, temp)
temp_max = scores[0]
if all_sum > 0 and q > 0:
if r > 0:
temp_max = max(all_sum * (q - 1) + max_, all_sum * q + max_r)
else:
temp_max = all_sum * (q - 1) + max_
else:
temp_max = max_
all_max = max(all_max, temp_max)
print(all_max)
| N,K=map(int,input().split())
P=list(map(int,input().split()))
C=list(map(int,input().split()))
dummy=set()
loop=[]
X=set(range(N))
while len(dummy)!=N:
a=[]
k=min(X-dummy)
a.append(k)
dummy.add(k)
l=P[k]-1
while l!=k:
a.append(l)
dummy.add(l)
l=P[l]-1
loop.append(a)
ans=-(10**300)
for l in loop:
temp=0
s=len(l)
ssum=0
k=0
for i in range(s):
ssum+=C[l[i]]
if ssum>0:
temp+=((K-1)//s)*ssum
k=K-((K-1)//s)*s
else:
k=min(K,s)
kmax=-(10**300)
for ii in range(s):
tempscore=temp
for jj in range(1,k+1):
tempscore+=C[l[(ii+jj)%s]]
if tempscore>kmax:
kmax=tempscore
if kmax>ans:
ans=kmax
print(ans)
| 1 | 5,348,092,917,440 | null | 93 | 93 |
n, m, k = map(int, input().split())
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return ''.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
uf = UnionFind(n)
from collections import defaultdict
direct_f = defaultdict(int)
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
direct_f[a] += 1
direct_f[b] += 1
uf.union(a, b)
ans = [uf.size(i) - direct_f[i] - 1 for i in range(n)]
for i in range(k):
c, d = map(int, input().split())
c -= 1
d -= 1
if uf.same(c,d):
ans[c] -= 1
ans[d] -= 1
print(*ans) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M ,K = map(int, input().split())
ndic = {i:set() for i in range(1,N+1)}
bdic = {i:set() for i in range(1,N+1)}
uf = UnionFind(N+1)
rlt = []
for _ in range(M):
a,b = map(int, input().split())
ndic[a].add(b)
ndic[b].add(a)
uf.union(a,b)
for _ in range(K):
a,b = map(int, input().split())
bdic[a].add(b)
bdic[b].add(a)
for i in range(1,N+1):
tmp = uf.size(i)
for a in bdic[i]:
if uf.find(a) == uf.find(i):
tmp -= 1
tmp -= len(ndic[i])
rlt.append(tmp-1)
print(" ".join(map(str, rlt))) | 1 | 61,699,665,771,868 | null | 209 | 209 |
A,B = map(int,input().split())
C,D = map(int,input().split())
if C - A == 1:
print(1)
else:
print(0) | x = []
y = []
for i in range(2):
x1,y1=[int(i) for i in input().split()]
x.append(x1)
y.append(y1)
if x[0]!=x[1]:
print(1)
else:
print(0)
| 1 | 124,306,511,357,662 | null | 264 | 264 |
def main():
# S = input()[-1:0:-1]
S = input()[::-1]
MOD = 2019
# dp = [0]*(len(S)+1)
# dp[0] = 0
dic = [0]*2019
dic[0] = 1
ten = 1
pre = 0
for i, s in enumerate(S):
# dp[i] = (dp[i-1] + ten*int(s)) % MOD
pre = (pre + ten*int(s)) % MOD
dic[pre] += 1
ten *= 10
ten %= MOD
sum_ = 0
# for sup in dp:
# dic[sup] += 1
for v in dic:
sum_ += v*(v-1)//2
print(sum_)
if(__name__ == '__main__'):
main()
| S = list(str(input()))
S.reverse()
mod = 2019
rem = [0]*mod
num = 0
rem[num] += 1
d = 1
ans = 0
for s in S:
num += int(s) * d
num %= mod
d *= 10
d %= mod
rem[num] += 1
for r in rem:
ans += r*(r-1)//2
print(ans) | 1 | 30,720,691,338,228 | null | 166 | 166 |
from collections import deque
S = deque(input())
Q = int(input())
flip = 0
for _ in range(Q):
q = input().split()
if q[0] == "1":
flip += 1
flip %= 2
else:
if (int(q[1]) - 1 + flip)%2 == 0:
S.appendleft(q[2])
else:
S.append(q[2])
S = list(S)
if flip == 0:
print(*S, sep="")
else:
print(*S[::-1], sep="") | from collections import deque
import sys
flg1 = 1
s = input()
ll = deque()
lr = deque()
for _ in range(int(input())):
q = sys.stdin.readline().rstrip()
if q == "1":
flg1 *= -1
else:
q = list(q.split())
flg2 = 1 if q[1] == "1" else -1
if flg1 * flg2 == 1:
ll.appendleft(q[2])
else:
lr.append(q[2])
ans = "".join(ll) + s + "".join(lr)
print((ans[::-1], ans)[flg1 == 1]) | 1 | 57,454,247,830,282 | null | 204 | 204 |
str = input()
n = int(input())
for i in range(n):
args = input().split()
command = args[0]
s = int(args[1])
e = int(args[2])
if command == 'print':
print(str[s:e + 1])
if command == 'reverse':
str = str[0:s] + str[s:e + 1][::-1] + str[e + 1:]
if command == 'replace':
str = str[0:s] + args[3] + str[e + 1:] | s = raw_input()
n = int(raw_input())
for i in range(n):
message = raw_input().split(" ")
a, b = int(message[1]), int(message[2])
if message[0] == "print":
print(s[a:b+1])
elif message[0] == "reverse":
s = s[:a] + s[a:b+1][::-1] + s[b+1:]
elif message[0] == "replace":
s = s[:a] + message[3] + s[b+1:] | 1 | 2,055,099,356,060 | null | 68 | 68 |
A, B, M = map(int, input().split())
la = list(map(int, input().split()))
lb = list(map(int, input().split()))
prm_min = min(la) + min(lb)
lcost = list()
for i in range(M):
x, y, c = map(int, input().split())
lcost.append(la[x-1] + lb[y-1] - c)
print(min(min(lcost), prm_min)) | # https://atcoder.jp/contests/abc168/tasks/abc168_a
N = int(input())
last_num = int(str(N)[-1])
if last_num in {2, 4, 5, 7, 9}:
print('hon')
elif last_num in {0, 1, 6, 8}:
print('pon')
else:
print('bon') | 0 | null | 36,732,351,352,772 | 200 | 142 |
A, B = map(int, input().split())
if A == B:
print('Yes')
else:
print('No') | n, m = [int(i) for i in input().split()]
print('Yes' if n == m else 'No') | 1 | 83,484,542,017,500 | null | 231 | 231 |
def proc(a, b, op):
if op == '+':
return a + b
if op == '-':
return a - b
if op == '*':
return a * b
if op == '/':
return a // b
while True:
a, op, b = input().split()
if op == '?':
break
print(proc(int(a), int(b), op)) | import sys
ri = lambda: int(sys.stdin.readline())
rl = lambda: list(map(int, sys.stdin.readline().split()))
a = ri()
li = sorted(rl(), reverse=True)
cnt = 0
for i in range(a-2):
for j in range(i+1, a-1):
left = j+1
right = a
lii = li[i]
lij = li[j]
if lii >= lij + li[j+1]:
continue
while right-left > 1:
t = (left + right)//2
lit = li[t]
if lii < lij + lit:
left = t
else:
right = t
cnt += left-j
print(cnt)
| 0 | null | 86,514,517,873,520 | 47 | 294 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from copy import deepcopy
def make_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)
# divisors.sort()
return divisors
n = int(readline())
ans = len(make_divisors(n - 1))
for check in make_divisors(n):
if check == 1:
continue
nn = deepcopy(n)
while nn % check == 0:
nn //= check
if nn % check == 1:
ans += 1
print(ans - 1)
| n = int(input())
div = []
div2 = []
ans = 0
for i in range(1,10**6+1):
if n%i == 0:
div+=[i,n//i]
if (n-1)%i == 0:
div2+=[i,(n-1)//i]
div = set(div)
div2 = set(div2)
# print(div)
a = [1]
for i in div:
if i > 1:
t = n
while t:
if t%i == 0:
t = t//i
else:
if t%i == 1:
ans += 1
a += [i]
break
# for i in div2:
# if i > 1:
# t = n-1
# while t:
# if t == 1:
# ans += 1
# a += [i]
# t //= i
# # if n%(i-1) == 1:
# # ans += 1
# # a += [i-1]
# print(ans)
# print(a)
# print(div)
# print(div2)
for i in div2:
a+=[i]
a = set(a)
# print(a)
print(len(a)-1) | 1 | 41,464,809,597,680 | null | 183 | 183 |
def right(a,b,a1,a2,a3,a4,a5,a6):
b1=a6
b2=a5
b3=a4
b4=a3
b5=a2
b6=a1
if a>b:
tmp_a=a
a=b
b=tmp_a
if [a,b]==[a1,a2]:
right_side=[a3,b3]
elif [a,b]==[a1,a3]:
right_side=[a5,b5]
elif [a,b]==[a1,a4]:
right_side=[a2,b2]
elif [a,b]==[a1, a5]:
right_side=[a4,b4]
elif [a,b]==[a2, a3]:
right_side=[a1,b1]
elif [a, b]==[a2, a4]:
right_side=[a6,b6]
elif [a,b]==[a2,a6]:
right_side=[a3,b3]
elif [a,b]==[a3, a5]:
right_side=[a1,b1]
elif [a,b]==[a3, a6]:
right_side=[a5,b5]
elif [a, b]==[a4, a5]:
right_side=[a6,b6]
elif [a,b]==[a4,a6]:
right_side=[a2,b2]
elif [a,b]==[a5,a6]:
right_side=[a4,b4]
return right_side
initial=list( map(int,input().split()))
num_of_q=int(input())
for i in range(0, num_of_q):
a=list(map(int, input().split()))
flag=0
if a[0]>a[1]:
flag=1
answer=right(*a,*initial)
print(answer[flag])
| #ITP1_11-B Dice 2
rep=[
[1,2,4,3,1],
[2,0,3,5,2],
[0,1,5,4,0],
[0,4,5,1,0],
[0,2,5,3,0],
[1,3,4,2,1]
]
d = input().split(" ")
q = int(input())
dic={}
for i in range(6):
dic.update({d[i]:i})
for i in range(q):
a,b = input().split(" ")
for j in range(4):
top=dic[a]
front = dic[b]
if(d[rep[top][j]]==d[front]):
print(d[rep[top][j+1]]) | 1 | 259,339,011,170 | null | 34 | 34 |
l = [int(i) for i in input().split()]
l.sort()
print(str(l[0])+' '+str(l[1])+' '+str(l[2])) | import string
L = string.split(raw_input())
L.sort()
print (L[0]), (L[1]), (L[2]) | 1 | 418,328,962,688 | null | 40 | 40 |
H,N = map(int,input().split())
Q = []
for _ in range(N):
a,b = map(int,input().split())
Q.append((a,b))
INF = float("inf")
dp = [INF]*(H+1)
dp[0] = 0
for i in range(H+1):
for a,b in Q:
if i+a>=H:
dp[H] = min(dp[H],dp[i]+b)
else:
dp[i+a] = min(dp[i+a],dp[i]+b)
print(dp[-1]) | n=int(input());l=list(map(int,input().split()));p=[0]*n;d=[0]*n
for i in range(n):p[i]=l[i]+p[i-2];d[i]=max(p[i-1]if i&1else d[i-1],l[i]+d[i-2])
print(d[-1]) | 0 | null | 59,570,909,026,270 | 229 | 177 |
import math
N=int(input())
a=1
sum=N
flag=True
while flag:
if a>math.sqrt(N):
break
if N%a==0:
b=N//a
if sum>a+b-2:
sum=a+b-2
a+=1
print(sum) | import sys
nums = sorted( [ int( val ) for val in sys.stdin.readline().split( " " ) ] )
print( "{:d} {:d} {:d}".format( nums[0], nums[1], nums[2] ) ) | 0 | null | 80,565,873,821,860 | 288 | 40 |
while True:
a = input()
if "?" in a:
break
print(eval(a.replace("/", "//"))) | import fractions
from functools import reduce
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
N, M = map(int, input().split())
A = list(map(int, input().split()))
for i in range(N):
A[i] = A[i] // 2
p = 0
de_2 = 0
x = A[0]
while (p == 0):
if x % 2 == 0:
x = x // 2
de_2 += 1
else:
p = 1
de = 2 ** de_2
for i in range(1, N):
if A[i] % de == 0:
if A[i] % (de * 2) != 0:
continue
else:
print("0")
quit()
else:
print("0")
quit()
lcm = lcm_list(A)
p = M // lcm
if p % 2 == 0:
ans = p // 2
else:
ans = (p + 1) // 2
print(ans)
| 0 | null | 51,271,722,325,362 | 47 | 247 |
mark = ["S","H","C","D"]
numbers = ["1","2","3","4","5","6","7","8","9","10","11","12","13"]
cardlist = {}
for m in mark:
for n in numbers:
key = m + " " + n
cardlist[key] = 0
n = int(input())
for _ in range(n):
card = input()
cardlist[card] = 1
for card in cardlist:
if cardlist[card] == 0:
print(card)
| #coding:utf-8
N = int(input())
buff = [y for x in range(N) for y in [input().split()]]
data = [(x[0], int(x[1])) for x in buff]
S = [x for x in data if x[0]=="S"]
H = [x for x in data if x[0]=="H"]
D = [x for x in data if x[0]=="D"]
C = [x for x in data if x[0]=="C"]
ansS = [("S", x) for x in range(1,14) if ("S", x) not in S]
ansH = [("H", x) for x in range(1,14) if ("H", x) not in H]
ansD = [("D", x) for x in range(1,14) if ("D", x) not in D]
ansC = [("C", x) for x in range(1,14) if ("C", x) not in C]
ans = ansS + ansH + ansC + ansD
[print(str(x[0]) + " " + str(x[1])) for x in ans] | 1 | 1,047,936,473,510 | null | 54 | 54 |
from sys import stdin
input = stdin.readline
r, c, k = map(int, input().split())
vals = [[0]*c for _ in range(r)]
for _ in range(k):
x, y, v = map(int, input().split())
vals[x-1][y-1] = v
dp = [[0]*4 for j in range(c)]
for j in range(c):
if j > 0:
for k in range(4):
dp[j][k] = dp[j-1][k]
if vals[0][j] > 0:
for k in reversed(range(3)):
if dp[j][k+1] < dp[j][k] + vals[0][j]:
dp[j][k+1] = dp[j][k] + vals[0][j]
for i in range(1, r):
tmp = [[max(dp[j]), 0, 0, 0] for j in range(c)]
for j in range(c):
if j > 0:
for k in range(4):
if tmp[j][k] < tmp[j-1][k]:
tmp[j][k] = tmp[j-1][k]
if vals[i][j] > 0:
for k in reversed(range(3)):
if tmp[j][k+1] < tmp[j][k] + vals[i][j]:
tmp[j][k+1] = tmp[j][k] + vals[i][j]
dp = tmp
print(max(dp[-1])) | n = int(input())
a = list(map(int, input().split()))
x = 0
for a_i in a:
x ^= a_i
for a_i in a:
print(x ^ a_i) | 0 | null | 9,040,568,219,368 | 94 | 123 |
r, c = map(int, input().split())
mat = [list(map(int, input().split())) for i in range(r)]
for row in mat:
row.append(sum(row))
print(*row)
colSum = [sum(col) for col in zip(*mat)]
print(*colSum) | import numpy as np
N = input()
K = int(input())
n = len(N)
dp0 = np.zeros((n, K+1), np.int64)
dp1 = np.zeros((n, K+1), np.int64)
dp0[0, 0] = 1
dp0[0, 1] = int(N[0]) - 1
dp1[0, 1] = 1
for i, d in enumerate(N[1:]):
dp0[i+1] += dp0[i]
dp0[i+1, 1:] += dp0[i, :-1] * 9
if int(d) == 0:
dp1[i+1] = dp1[i]
elif int(d) == 1:
dp0[i+1] += dp1[i]
dp1[i+1, 1:] = dp1[i, :-1]
elif int(d) >= 2:
dp0[i+1] += dp1[i]
dp0[i+1, 1:] += dp1[i, :-1] * (int(d) - 1)
dp1[i+1, 1:] = dp1[i, :-1]
print(dp0[-1, K] + dp1[-1, K])
| 0 | null | 38,781,036,951,522 | 59 | 224 |
def count(n, d):
return n // d
def main():
L, R, d = map(int, input().split())
ans = count(R, d) - count(L - 1, d)
print(ans)
if __name__ == '__main__':
main()
| L, R, d = map(int, input().split())
count = 0
for i in range(101):
if d * i >= L and d * i <= R:
count += 1
if d * i > R:
break
print(count) | 1 | 7,634,523,812,850 | null | 104 | 104 |
N = int(input())
A = [int(a) for a in input().split()]
cum_A = [0] * N
cum_A[0] = A[0]
for i in range(1, N):
cum_A[i] = cum_A[i - 1] + A[i]
ans = 0
for i in range(N - 1):
inner_sum = cum_A[-1] - cum_A[i]
ans += A[i] * inner_sum
print(ans % (10**9 + 7))
| # python3
# -*- coding: utf-8 -*-
import sys
import math
import bisect
from fractions import gcd
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
INF = float('inf')
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
lmtx = lambda h: [list(map(int, lmis())) for _ in range(h)]
sys.setrecursionlimit(1000000000)
def lcm(a, b):
return (a * b) // gcd(a, b)
# main
n = ii()
alist = lmis()
asum = sum(alist[1:n])
sum = 0
for i in range(n-1):
sum += alist[i] * asum
asum -= alist[i+1]
print(sum % 1000000007)
| 1 | 3,805,075,985,350 | null | 83 | 83 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
s = input()
ans = 0
if s == 'SUN':
ans = 7
elif s == 'MON':
ans = 6
elif s == 'TUE':
ans = 5
elif s == 'WED':
ans = 4
elif s == 'THU':
ans = 3
elif s == 'FRI':
ans = 2
elif s == 'SAT':
ans = 1
print(ans)
if __name__ == '__main__':
solve()
|
def main():
s = input()
week = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
ind = week.index(s)
print(7 - (ind % 7))
if __name__ == "__main__":
main()
| 1 | 132,943,986,559,630 | null | 270 | 270 |
import collections
n,x,y = map(int,input().split())
h = [[] for _ in range(n+1) ]
for i in range(1,n+1):
if i+1<n+1:
h[i].append(i+1)
if i-1>0:
h[i].append(i-1)
h[x].append(y)
h[y].append(x)
k = [0]*n
for i in range(1,n+1):
q = collections.deque([i])
step = [-1]*(n+1)
step[i] = 0
while q:
now = q.popleft()
for hh in h[now]:
if step[hh] == -1:
q.append(hh)
step[hh] = step[now]+1
k[step[now]+1] += 1
for i in range(1,n):
print(k[i]//2) | from sys import stdin,stdout
def INPUT():return list(int(i) for i in stdin.readline().split())
def inp():return stdin.readline()
def out(x):return stdout.write(x)
import math
import random
J=998244353
########################################################
n,k=INPUT()
A=[]
for i in range(k):
x,y=INPUT()
A.append([x,y])
A.sort()
s,e=-1,-1
S=[]
for i in range(len(A)):
if i==0:
S.append([A[i][0],A[i][1]])
else:
if A[i][0]>S[-1][1]:
S.append([A[i][0],A[i][1]])
else:
S[-1][1]=A[i][1]
cum=[0]*(n+1)
dp=[0]*(n+1)
dp[1]=1
cum[1]=1
for i in range(2,n+1):
for ele in S:
x=ele[0]
y=ele[1]
dp[i]=(dp[i]+cum[max(i-x,0)]-cum[max(0,i-y-1)])%J
cum[i]=(cum[i-1]+dp[i])%J
print(dp[n])
| 0 | null | 23,309,658,049,330 | 187 | 74 |
str=input()
print(str.swapcase())
| def convert(s):
o = ord(s)
if o >= 65 and o <= 90:
return s.lower()
elif o >= 97 and o <= 122:
return s.upper()
return s
def main():
strings = input()
answer = ""
for s in strings:
s = s
answer += convert(s)
print(answer)
if __name__ == "__main__":
main() | 1 | 1,506,855,072,132 | null | 61 | 61 |
N = int(input())
S = input()
cnt = 0
for i in range(N):
if S[i:i+3] == "ABC":
cnt += 1
print(cnt) | from collections import defaultdict,deque
graph = defaultdict(list)
N, *AB = map(int, open(0).read().split())
for a, b in zip(*[iter(AB)] * 2):
graph[a].append(b)
stack = deque([1])
C = [0] * (N + 1)
while stack:
v = stack.popleft()
c = 0
for w in graph[v]:
c += 1 + (c + 1 == C[v])
C[w] = c
stack.append(w)
print(max(C))
print("\n".join(str(C[b]) for b in AB[1::2])) | 0 | null | 117,912,336,084,224 | 245 | 272 |
def resolve():
D = int(input())
# 各コンテストタイプの満足度の下がりやすさ
c = list(map(int, input().split()))
# 各日程に各コンテストを開催した時の満足度増加量
s = []
for i in range(D):
s.append(list(map(int, input().split())))
# 最後に各コンテストを開催した日
l = [-1] * 26
# 満足度
v = 0
for d in range(D):
# この日に開催されるコンテストタイプ
t = int(input())-1
l[t] = d
# 増加分加算
v += s[d][t]
# 不満足分減算
for i in range(26):
v -= c[i] * (d - l[i])
print(v)
resolve() | import collections
n=int(input())
a= list(map(int, input().split()))
aa=list(set(a))
sortaa=sorted(aa,reverse=True)
c = collections.Counter(a)
comf=[]
for i in range(len(aa)):
if i == 0:
comf.extend([sortaa[i] for ii in range(2*c[sortaa[i]]-1)])
else:
comf.extend([sortaa[i] for ii in range(2*c[sortaa[i]])])
print(sum(comf[:n-1])) | 0 | null | 9,603,970,964,698 | 114 | 111 |
N, K = map(int, input().split())
Hlist = list(map(int, input().split()))
Hlist = sorted(Hlist)[::-1]
#user K super attack for largest K enemy
remainHlist = Hlist[K:]
attackTimes = sum(remainHlist)
print(attackTimes) | n = int(input())
output = ""
for i in range(1,n+1):
if i % 3 == 0:
output += " %s" % (i,)
continue
elif i % 10 == 3:
output += " %s" % (i,)
continue
x = i
while x > 1:
x = int(x/10)
if x % 10 == 3:
output += " %s" % (i,)
break
print(output) | 0 | null | 40,198,944,547,300 | 227 | 52 |
n = input()
hon = [2, 4, 5, 7, 9]
pon = [0, 1, 6, 8]
if int(n[-1]) in hon:
print("hon")
elif int(n[-1]) in pon:
print("pon")
else:
print("bon") | N = input()
money = 100000
for i in range(N):
money = int(money *1.05)
if money % 1000 != 0:
money = (money // 1000 + 1) * 1000
print money | 0 | null | 9,594,939,113,056 | 142 | 6 |
n, k = map(int, input().split())
l = list(map(int, input().split()))
cnt = 0;
for i in l:
if i >= k:
cnt += 1;
print(cnt) | S=list(input())
s=0
f=0
g=0
h=0
for i in range(len(S)):
if S[i]==">":
g=0
f+=1
if h>=f:
s+=f-1
else:
s+=f
else:
f=0
g+=1
s+=g
h=g
print(s)
| 0 | null | 167,822,149,497,630 | 298 | 285 |
n = int(input())
a = list(map(int,input().split()))
di = 10**9+7
##試し割り
import math
import collections
def trial_division_prime(n, prime_list,prime_count):
tmp=collections.Counter()
for i in prime_list:
if i * i > n:
break
while n % i == 0:
n /= i
tmp[i] += 1
if n > 1:
tmp[int(n)] += 1
for num,rui in tmp.items():
if prime_count[num]<rui:
prime_count[num]=rui
else:
continue
return prime_count
##ふるい
import itertools
def eratosthenes_sieve(n):
table = [0] * (n + 1)
prime_list = []
for i in range(2, n + 1):
if table[i] == 0:
prime_list.append(i)
for j in range(i + i, n + 1, i):
table[j] = 1
return prime_list
lis = eratosthenes_sieve(int(math.sqrt(max(a))+1))
prime_count = collections.Counter()
for i in a:
cnt = trial_division_prime(i,lis,prime_count)
#print(cnt)
lcm=1
for s,t in prime_count.items():
lcm=(lcm*pow(s,t,di))%di
#print(lcm)
su = 0
for i in a:
div = pow(i,di-2,di)
su = (su+(lcm*div)%di)%di
print(su)
| N=int(input())
A=list(map(int,input().split()))
def f(x):
if x==1:
return dict()
y=x
r=dict()
for i in range(2,int(x**0.5)+1):
if y%i==0:
r[i]=0
while y%i==0:
r[i]+=1
y=y//i
if y==1:
break
if y!=1:
r[y]=1
return r
B=[f(A[i]) for i in range(N)]
def g(X):
if len(X)==1:
return X[0]
a,b=g(X[:len(X)//2]),g(X[len(X)//2:])
c=list(set(a.keys())|set(b.keys()))
for i in range(len(c)):
a[c[i]]=max(a.get(c[i],0),b.get(c[i],0))
return a
G=g(B)
X=1
mod=10**9+7
P=0
Y=list(G.keys())
for i in range(len(Y)):
X=X*pow(Y[i],G[Y[i]],mod)%mod
for i in range(N):
P=(P+X*pow(A[i],mod-2,mod))%mod
print(P) | 1 | 87,802,700,226,978 | null | 235 | 235 |
from collections import deque
n=int(input())
arr=[[] for _ in range(n)]
for i in range(n-1):
a,b=map(int,input().split())
arr[a-1].append([b-1,i])
arr[b-1].append([a-1,i])
que=deque([0])
ans=[0]*(n-1)
par=[0]*n
par[0]=-1
while que:
x=que.popleft()
p=par[x]
color=1
for tup in arr[x]:
if p==color:
color+=1
if ans[tup[1]]==0:
ans[tup[1]]=color
par[tup[0]]=color
color+=1
que.append(tup[0])
print(max(ans))
print(*ans,sep='\n') | import queue
n = int(input())
e = []
f = [{} for i in range(n)]
for i in range(n-1):
a,b = map(int, input().split())
a-=1
b-=1
e.append([a,b])
f[a][b]=0
f[b][a]=0
k = 0
for i in range(n-1):
k = max(k,len(f[i]))
q = queue.Queue()
q.put(0)
used = [[0] for i in range(n)]
while not q.empty():
p = q.get()
for key,c in f[p].items():
if c == 0:
if used[p][-1]<k:
col = used[p][-1]+1
else:
col = 1
f[p][key] = col
f[key][p] = col
used[p].append(col)
used[key].append(col)
q.put(key)
print(k)
for a,b in e:
print(max(f[a][b],f[b][a]))
| 1 | 135,945,522,916,220 | null | 272 | 272 |
from math import *
a, b, x = map(int, input().split())
areatotal = a*a*b
if areatotal / 2 == x: print(45.0)
elif x > areatotal/2:
left = 0.0
right = 90.0
while right-left > 0.00000001:
current = (right+left)/2
if a**2 * tan(radians(current)) / 2 * a < (areatotal - x):
left = current
else:
right = current
print(left)
else:
left = 0.0
right = 90.0
while right-left > 0.00000001:
current = (right+left)/2
if b**2 * tan(radians(90-current))/2*a > x:
left = current
else:
right = current
print(left)
| """
keyword: ラジアン, 度
最大限傾けたとき、水と接している面は横から見ると台形ないし三角形となる
水と接している面の面積 x/a が a*b/2 より大きい場合は台形となり、それ以下の場合は三角形となる
・台形の場合
最大限傾けたとき、水と接している台形の上辺の長さをhとすると
(h+b)*a/2 = x/a
h = 2*x/(a**2) - b
求める角度をthetaとすると
tan(theta) = (b-h)/a
theta = arctan((b-h)/a)
・三角形の場合
最大限傾けたとき、水と接している三角形の底辺の長さをhとすると
h*b/2 = x/a
h = 2*x/(a*b)
求める角度をthetaとすると
tan(theta) = b/h
theta = arctan(b/h)
"""
import sys
sys.setrecursionlimit(10**6)
a,b,x = map(int, input().split())
import numpy as np
if x/a > a*b/2:
h = 2*x/(a**2) - b
theta = np.arctan2(b-h, a) # radian表記なので戻り値の範囲は[-pi/2, pi/2]
theta = np.rad2deg(theta)
else:
h = 2*x/(a*b)
theta = np.arctan2(b, h)
theta = np.rad2deg(theta)
print(theta) | 1 | 163,204,995,886,712 | null | 289 | 289 |
# coding: utf-8
from collections import defaultdict
def main():
N = int(input())
dic = defaultdict(int)
max_p = 0
for i in range(N):
dic[input()] += 1
d = dict(dic)
l = []
for key, value in d.items():
l.append([key, value])
if max_p < value: max_p = value
l.sort(key=lambda x: (-x[1], x[0]), reverse=False)
for i, j in l:
if j == max_p:
print(i)
else:
break
if __name__ == "__main__":
main()
| A,B,C=map(int,input().split())
K=int(input())
count=0
if B<=A:
while B<=A:
B*=2
count+=1
if count>K:
print('No')
else:
C*=2**(K-count)
if C>B:
print('Yes')
else:
print('No') | 0 | null | 38,485,960,771,170 | 218 | 101 |
from bisect import *
n,m,k = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
# Aの累積和を保存しておく
# 各Aの要素について、Bが何冊読めるか二分探索する。
# 計算量: AlogB
A.insert(0, 0)
for i in range(1,len(A)):
A[i] += A[i-1]
for i in range(1, len(B)):
B[i] += B[i-1]
ans = 0
for i in range(len(A)):
rest_time = k - A[i]
if rest_time >= 0:
numb = bisect_right(B, rest_time)
anstmp = i + numb
ans = max(ans, anstmp)
print(ans) | N = int(input())
print((10 ** N - 2 * (9 ** N) + 8 ** N) % (10 ** 9 + 7))
| 0 | null | 6,951,456,214,700 | 117 | 78 |
from math import gcd
N = int(input())
A = list(map(int,input().split()))
g = A[0]
for i in range(1,N):
g = gcd(g,A[i])
if g>1:
print("not coprime")
exit()
MAXN = 10**6 + 9
D = [i for i in range(MAXN+1)]
p = 2
while(p*p <=MAXN):
if D[p]==p:
for q in range(2*p,MAXN+1,p):
if D[q]==q:
D[q]=p
p+=1
st = set()
for a in A:
tmp = set()
while(a>1):
tmp.add(D[a])
a //=D[a]
for p in tmp:
if p in st:
print("setwise coprime")
exit()
st.add(p)
print("pairwise coprime")
| N, M, K = map(int, input().split(' '))
A_ls = [0] + list(map(int, input().split(' ')))
for i in range(len(A_ls) - 1):
A_ls[i + 1] += A_ls[i]
B_ls = [0] + list(map(int, input().split(' ')))
for i in range(len(B_ls) - 1):
B_ls[i + 1] += B_ls[i]
b_cnt,result = M, 0
for a_cnt in range(N + 1):
if A_ls[a_cnt] > K:
break
while A_ls[a_cnt] + B_ls[b_cnt] > K:
b_cnt -= 1
result = max(result, a_cnt + b_cnt)
print(result) | 0 | null | 7,418,085,183,718 | 85 | 117 |
import sys
import math
import time
sys.setrecursionlimit(int(1e6))
if False:
dprint = print
else:
def dprint(*args):
pass
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
dprint("n, k = ", n, k)
lx = int(0) # NG
rx = int(1e9) # OK
#ans = 0
while ((rx-lx)>1):
x = (rx + lx) // 2
dprint("lx, x, rx = ", lx, x, rx)
n = 0
for i in range(len(A)):
#n += math.ceil(A[i] / x) - 1
n += (A[i]-1) // x
if n > k: break
dprint("n = ", n)
if n <= k:
dprint(" smaller x")
rx = x
else:
dprint(" cut less, bigger x")
lx = x
#ans = math.ceil(rx)
print(rx)
| N, K = map(int, input().split())
*A, = map(int, input().split())
def f(t):
return sum(i//t if i!=t else 0 for i in A)<=K if t else all(i<=t for i in A)
l, r = -1, 10**10
while r-l>1:
m = (r+l)//2
if f(m):
r = m
else:
l = m
print(r)
| 1 | 6,512,175,278,826 | null | 99 | 99 |
N=int(input())
S=list(input() for _ in range(N))
from collections import Counter
cnt=Counter(S)
max_cnt=cnt.most_common()[0][1]
ans=[name for name, cnt in cnt.items() if cnt==max_cnt]
print(*sorted(ans), sep="\n") | N = int(input())
a = []
for i in range(N):
a.append(input())
a = sorted(a)
count = 0
count_list=[]
b = []
for i,k in enumerate(a):
if i == 0:
continue
if k == a[i-1]:
count+=1
else:
count_list.append(count)
b.append(a[i-1])
count = 0
if i==N-1:
count_list.append(count)
b.append(a[i])
maxi = 0
maxi_list =[]
for i,k in enumerate(count_list):
if maxi <k:
maxi_list.clear()
maxi_list.append(b[i])
maxi = k
elif maxi == k:
maxi_list.append(b[i])
else:
continue
for i in maxi_list:
print(i)
| 1 | 70,137,247,472,600 | null | 218 | 218 |
X, Y = tuple(map(int, input().split()))
# Calculate prize for "Coding Contest"
prize_code = 0;
if X == 1:
prize_code = 300000;
elif X == 2:
prize_code = 200000;
elif X == 3:
prize_code = 100000;
# Calculate prize for "Robot Maneuver"
prize_device = 0;
if Y == 1:
prize_device = 300000;
elif Y == 2:
prize_device = 200000;
elif Y == 3:
prize_device = 100000;
# Calculate prize for "two victories"
prize_both = 0
if X == 1 and Y == 1:
prize_both = 400000
# Calculate the sum and print the answer
prize_total = prize_code + prize_device + prize_both
print(prize_total) | X,Y = (int(i) for i in input().split())
def get_money(Z):
if Z == 3:
return(100000)
elif Z == 2:
return(200000)
elif Z == 1:
return(300000)
else:
return(0)
x = get_money(X)
y = get_money(Y)
if X == 1 and Y == 1:
z = 400000
else:
z = 0
ans = x + y + z
print(ans) | 1 | 140,808,781,223,712 | null | 275 | 275 |
def selectionSort(a, n):
count = 0
for i in range(0, n):
minj = i
for j in range(i, n):
if a[j] < a[minj]:
minj = j
a[i], a[minj] = a[minj], a[i]
if i != minj:
count += 1
return count
def main():
n = int(input())
a = [int(x) for x in input().split(' ')]
count = selectionSort(a, n)
print(' '.join([str(x) for x in a]))
print(count)
if __name__ == '__main__':
main() | n = int(input())
ans = float('inf')
for i in range(1, int(n**0.5)+1):
if n%i == 0:
j = n//i
ans = min(ans, i-1+j-1)
print(ans) | 0 | null | 80,984,222,706,750 | 15 | 288 |
n = list(map(int, input().split(' ')))
m = list(map(int, input().split(' ')))
if n[0] >= sum(m):
print(n[0] - sum(m))
else:
print(-1)
| H, W = [int(_) for _ in input().split()]
if H == 1 or W == 1:
ans = 1
else:
ans = (H // 2) * (W // 2) * 2
if H % 2 == 1:
ans += W // 2
if W % 2 == 1:
ans += H // 2
if H % 2 == 1 and W % 2 == 1:
ans += 1
print(ans)
| 0 | null | 41,501,406,518,190 | 168 | 196 |
def ceil(n):
if n%1000:
return (1+n//1000)*1000
else:
return n
def debt(n):
if n==0: return 100000
return int(ceil(debt(n-1)*1.05))
print(debt(int(input())))
| N,M = map(int,input().split())
d,ans,wrong = [0]*N,0,0
for _ in range(M):
p,s = input().split()
p = int(p)-1
if d[p] != -1:
if s == "WA":
d[p] += 1
else:
wrong += d[p]
d[p] = -1
ans += 1
print(ans,wrong) | 0 | null | 46,493,582,940,140 | 6 | 240 |
S = input()
K = int(input())
N = len(S)
#全て同じ文字の時
if len(set(S)) == 1:
print(N*K//2)
exit()
#隣合う文字列が何個等しいか
cycle = 0
tmp = S[0]
cnt = 1
for i in range(1, N):
if tmp != S[i]:
cycle += cnt//2
tmp = S[i]
cnt = 1
else:
cnt += 1
cycle += cnt//2
if S[0] == S[-1]:
i = 0
a = 0
tmp = S[0]
while S[i] == tmp:
i += 1
a += 1
j = N-1
b = 0
tmp = S[-1]
while S[j] == tmp:
j -= 1
b += 1
print((cycle*K) - (a//2 + b//2 - (a+b)//2)*(K-1))
else:
print(cycle*K) | import collections
s = str(input())
k = int(input())
ans = 0
#if s[0] == s[-1]:
# ans += k
tmp = ''
tmp_num = 0
check = ''
check_num = 0
if len(collections.Counter(s).keys()) == 1:
ans = len(s)*k//2
else:
for i, w in enumerate(s):
if i == 0:
tmp += w
tmp_num += 1
continue
if tmp[-1] == w:
tmp += w
tmp_num += 1
elif tmp[-1] != w:
if check_num == 0:
check = tmp
check_num = 1
ans += (tmp_num // 2) * k
#print('ans', ans)
tmp = w
tmp_num = 1
if i == len(s)-1:
if len(tmp) == 1:
if check[0] == tmp and (len(tmp)%2 == 1 and len(check)%2 == 1):
ans += k-1
else:
#print(check, tmp)
if check[0] == tmp[-1] and (len(tmp)%2 == 1 and len(check)%2 == 1):
ans += k-1
ans += (tmp_num // 2) * k
#print('last', ans)
print(ans)
| 1 | 175,382,579,933,990 | null | 296 | 296 |
import sys
input = sys.stdin.readline
def read():
N, K, S = map(int, input().strip().split())
return N, K, S
def solve(N, K, S):
ans = [0 for i in range(N)]
for i in range(K):
ans[i] = S
for i in range(K, N):
ans[i] = S % 10**9 + 1
print(*ans)
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print("%s" % str(outputs))
| INF = float("inf")
N, K = map(int, input().split())
P = list(map(int, input().split()))
C = list(map(int, input().split()))
ans = -INF
for s in range(N):
### STEP1
cum = []
i = P[s] - 1 #s-> i
cum.append(C[i])
while i != s:
i = P[i] - 1
cum.append(cum[-1] + C[i])
# STEP2
if K <= len(cum):
#1週未満しかできない
score = max(cum[:K])
elif cum[-1] <= 0:
#一周以上できるが、ループしたら損する場合
score = max(cum)
else:
# K//Length - 1回だけループし、最後は最適に止まる
score1 = cum[-1] * (K//len(cum) - 1)
score1 += max(cum)
#ループをK//length回だけループする場合
score2 = cum[-1]*(K//len(cum))
resi = K % len(cum) #残り進める回数
if resi != 0:
#まだ進めるなら
score2 += max(0, max(cum[:resi]))
score = max(score1, score2)
ans = max(ans, score)
print(ans)
| 0 | null | 48,211,003,611,028 | 238 | 93 |
while True:
m,f,r = map(int,raw_input().split())
if m == -1 and f == -1 and r == -1:
break
if m == -1 or f == -1:
print('F')
elif m+ f >= 80:
print('A')
elif m + f >= 65 and m + f < 80:
print('B')
elif m + f >= 50 and m + f < 65 or r >= 50:
print('C')
elif m + f >= 30 and m + f < 50:
print('D')
elif m + f <= 29:
print('F') | m = []
f = []
r = []
while(1):
a,b,c = map(int,raw_input().split())
if a == -1 and b == -1 and c == -1:
break
else:
m.append(a)
f.append(b)
r.append(c)
for i in range(len(m)):
if m[i] == -1 or f[i] == -1:
print "F"
elif m[i] + f[i] >= 80:
print "A"
elif m[i] + f[i] >= 65:
print "B"
elif m[i] + f[i] >= 50 or r[i] >= 50:
print "C"
elif m[i] + f[i] >= 30:
print "D"
else:
print "F"
| 1 | 1,221,987,215,472 | null | 57 | 57 |
#C
N=int(input())
A=[int(x) for x in input().split()]
P=[0 for i in range(N+1)]
P[N]=[A[N],A[N]]
for i in range(N-1,-1,-1):
MIN,MAX=P[i+1]
mi=int(A[i]+(MIN+MIN%2)/2)
ma=A[i]+MAX
P[i]=[mi,ma]
if P[0][0]==1:
Q=[0 for i in range(N+1)]
Q[0]=1
cnt=1
for i in range(N):
Q[i+1]=min((Q[i]-A[i])*2,P[i+1][1])
cnt+=Q[i+1]
print(cnt)
else:
print("-1") | S = input()
h = S / 3600
S %= 3600
m = S / 60
s = S % 60
print("%d:%d:%d" % (h, m, s)) | 0 | null | 9,565,015,117,618 | 141 | 37 |
N = input()
L = len(N)
# dp[i][j]: 紙幣の最小枚数
# i: 決定した桁数
# j: 1枚多めに渡すフラグ
dp = [[float("inf")] * 2 for _ in range(L + 1)]
# 初期条件
dp[0][0] = 0
dp[0][1] = 1
# 貰うDP
for i in range(L):
n = int(N[i])
dp[i + 1][0] = min(dp[i][0] + n, dp[i][1] + (10 - n))
dp[i + 1][1] = min(dp[i][0] + (n + 1), dp[i][1] + (10 - (n + 1)))
print(dp[L][0]) | def main():
a,b = map(int,input().split())
if a > b:
print('a > b')
elif a < b:
print('a < b')
elif a == b:
print('a == b')
else:
print('error')
if __name__=="__main__":
main()
| 0 | null | 35,819,858,029,640 | 219 | 38 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
def is_ok(L):
count = 0
for a in A:
count += a // L
if a % L == 0:
count -= 1
return count <= K
ng = 0
ok = max(A)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
print(ok)
| debt = 100000.0
a = int(input())
for i in range(a):
debt = debt * 1.05
if(debt % 1000):
debt = (debt // 1000) * 1000 + 1000
print(int(debt))
| 0 | null | 3,209,689,626,260 | 99 | 6 |
from sys import stdin
def stdinput():
return stdin.readline().strip()
from collections import deque
def main():
n ,q = map(int, stdinput().split())
ps = deque()
for _ in range(n):
p, t = stdinput().split()
t = int(t)
ps.append([p, t])
ctime = 0
while len(ps) > 0:
p = ps.popleft()
if p[1] <= q:
ctime += p[1]
print(f'{p[0]} {ctime}')
else:
ctime += q
p[1] -= q
ps.append(p)
if __name__ == '__main__':
main()
| def main():
X = int(input())
c = 600
k = 8
while True:
if X < c:
print(k)
break
c += 200
k -= 1
if __name__ == '__main__':
main() | 0 | null | 3,327,710,345,400 | 19 | 100 |
(W,H,x,y,r)=map(int,raw_input().split())
if r<=x and r<=y and x<=W-r and y<=H-r : print "Yes"
else : print "No" | ins = input().split()
w = int(ins[0])
h = int(ins[1])
x = int(ins[2])
y = int(ins[3])
r = int(ins[4])
if x - r >= 0 and y - r >= 0 and x + r <= w and y + r <= h:
print("Yes")
else:
print("No") | 1 | 457,611,400,928 | null | 41 | 41 |
# -*- coding: utf-8 -*-
x=int(input())
a=360
b=x
r=a%b
while r!=0:
a=b
b=r
r=a%b
lcm=x*360/b
k=int(lcm/x)
print(k) | n=int(input())
s=input()
ans=""
for i in range(len(s)):
num=ord(s[i])+n
if num>90:
num-=26
ans+=chr(num)
print(ans) | 0 | null | 73,894,387,883,734 | 125 | 271 |
def main():
n = int(input())
A = list(map(int, input().split()))
B = [0] * (n+1)
if n == 0:
x = A[0]
if x == 1:
print(1)
else:
print(-1)
exit()
# Adが葉の個数、Bdが葉でないものの個数
# A0 + B0 = 1
# Bd ≤ Ad+1 + Bd+1 ≤ 2Bd --> B[d-1] - A[d] ≤ B[d] ≤ 2B[d-1] - A[d]
# Bd ≤ Ad+1 + Ad+2 + · · · + AN = s - (A1 + ... + Ad)
# now_s :葉の数
now_s = sum(A)
s = now_s
for i in range(n+1):
if i == 0:
B[i] = 1 - A[i]
else:
now_s -= A[i]
B[i] = min(now_s, 2 * B[i - 1] - A[i])
#print(A,B,now_s)
if B[i] < 0:
print(-1)
exit()
print(sum(B) + s)
if __name__ == "__main__":
main()
| # Problem D - Sum of Divisors
# input
N = int(input())
# initialization
count = 0
# count
for j in range(1, N+1):
M = N // j
count += j * ((M * (M+1)) // 2)
# output
print(count)
| 0 | null | 14,917,300,935,942 | 141 | 118 |
x = list(map(lambda a : int(a),input().split(" ")))
if x[0] < x[1]:
print("a < b")
elif x[0] > x[1]:
print("a > b")
else:
print("a == b") | from functools import reduce
print(reduce(lambda a, b: 'a {} b'.format('<' if a < b else (
'>' if a > b else '==')),
map(int, input().split()))) | 1 | 355,418,173,740 | null | 38 | 38 |
n = int(input())
graph = [-1] + [list(map(int, input().split())) for _ in range(n)]
seen = [False]*(n+1)
seen[0] = True
d = [-1]*(n+1)
f = [-1]*(n+1)
time = 0
def dfs(v):
global time
time += 1
d[v] = time
seen[v] = True
k = graph[v][1]
if k > 0:
for i in range(k):
w = graph[v][i+2]
if seen[w] is False:
dfs(w)
time += 1
f[v] = time
v = 0
while v <= n:
if seen[v] is False:
dfs(v)
v += 1
for i in range(1, n+1):
print(i, d[i], f[i])
| p =input()
if p[len(p) - 1] == 's':
print(p+'es')
else:
print(p+'s')
| 0 | null | 1,203,516,082,058 | 8 | 71 |
N=int(input())
if N==1:
print("a")
exit()
from collections import deque
from collections import Counter
abc="abcdefghijklmnopqrstuvwxyz"
ans=["a"]
for i in range(1,N):
d=deque(ans)
ans=[]
while d:
temp=d.popleft()
temp2=list(temp)
cnt=Counter(temp2)
L=len(cnt)
for j in range(L+1):
ans.append(temp+abc[j])
for a in ans:
print(a)
| import sys
from collections import deque
input = sys.stdin.readline
def dfs(N):
alphabet = "abcdefghij"
stack = deque(["a"])
while stack:
s = stack.pop()
if len(s) == N:
print(s)
continue
for suffix in reversed(alphabet[:len(set(s)) + 1]):
stack.append("".join((s, suffix)))
def main():
N = int(input())
dfs(N)
if __name__ == "__main__":
main()
| 1 | 52,438,523,452,952 | null | 198 | 198 |
n=input()
r='No'
for i in range(len(n)):
if n[i]=='7': r='Yes'
print(r)
| H, W, K = map(int, input().split())
S = [list(map(int, list(input()))) for _ in range(H)]
ans = H*W
def countWhite(ytop, ybottom, xleft, xright):
ret = sum([sum(s[xleft:xright]) for s in S[ytop:ybottom]])
return ret
for h_div in range(1 << H-1):
count = 0
cut = [0]
for i in range(H):
if h_div >> i & 1:
cut.append(i+1)
count += 1
cut.append(H)
if count > ans:
continue
left = 0
# ここどんなふうに縦に切っても条件を満たさない場合がある
for right in range(1, W+1):
white = 0
for i in range(len(cut)-1):
white = max(white, countWhite(cut[i], cut[i+1], left, right))
if white > K:
if left == right - 1: # 条件を満たす縦の切り方がなかった場合
break
left = right - 1
count += 1
if count > ans:
break
else:
if count < ans:
ans = count
print(ans) | 0 | null | 41,441,199,018,028 | 172 | 193 |
a, b, c, d = map(int, input().split(" "))
while True:
c -= b
if c <= 0:
print("Yes")
break
a -= d
if a <= 0:
print("No")
break | num = list(map(int, input().split()))
class Dice:
def __init__(self, num):
self.state = {}
for i in range(1,6+1):
self.state[i] = num[i-1]
self.reversed_state = {}
for key,val in zip(self.state.keys(), self.state.values()):
self.reversed_state[val] = key
def search_side(self, x,y):
a = self.reversed_state[x]
b = self.reversed_state[y]
if str(a)+str(b) in '12651':
side = self.state[3]
elif str(b)+str(a) in '12651':
side = self.state[4]
elif str(a)+str(b) in '13641':
side = self.state[5]
elif str(b)+str(a) in '13641':
side = self.state[2]
elif str(a)+str(b) in '23542':
side = self.state[1]
elif str(b)+str(a) in '23542':
side = self.state[6]
return side
dice = Dice(num)
q = int(input())
for _ in range(q):
x,y = map(int, input().split())
ans = dice.search_side(x,y)
print(ans)
| 0 | null | 15,051,222,043,072 | 164 | 34 |
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
s = input().rstrip()
n = len(s)
print('x'*n)
| list = input().split(" ")
a = int(list[0])
b = int(list[1])
print(a * b) | 0 | null | 44,369,360,170,450 | 221 | 133 |
N, K = map(int, input().split())
d = [0 for i in range(K)]
A = []
for i in range(K):
d[i] = int(input())
A.append(list(map(int, input().split())))
candy = [0 for i in range(N)]
for i in range(K):
for j in range(d[i]):
candy[A[i][j]-1] += 1
print(candy.count(0)) | #B
N, K=map(int,input().split())
d=[]
A=[]
for i in range(K):
di=int(input())
Ai=list(map(int,input().split()))
d.append(di)
A.append(Ai)
A_all=[]
for i in A:
for j in i:
A_all.append(j)
A_set=list(set(A_all))
print(N-len(A_set)) | 1 | 24,624,428,467,278 | null | 154 | 154 |
operand = input().split()
stack = []
for op in operand:
if op.isdigit():
stack.append(op)
else:
val1 = stack.pop()
val2 = stack.pop()
stack.append(str(eval("("+val2+")" + op + "("+val1+")")))
print (stack[0]) | n=int(input())
a=list(map(int,input().split()))
q=int(input())
m=list(map(int,input().split()))
l=[]
for i in range(2**n):
sub=0
for j in range(n):
if (i>>j)&1==1:
sub+=a[j]
l.append(sub)
for i in m:
if i in l:
print("yes")
else:
print("no")
| 0 | null | 71,851,276,240 | 18 | 25 |
import sys
n,m=map(int,input().split())
if n==3:
ans=["1","0","0"]
elif n==2:
ans=["1","0"]
else:
ans=["0"]
cnt=[0,0,0]
for i in range(m):
s,c=map(int,input().split())
if s==1 and c==0 and n!=1:
print(-1)
sys.exit()
elif ans[s-1]!=str(c):
if cnt[s-1]==0:
ans[s-1]=str(c)
cnt[s-1]=1
else:
print(-1)
sys.exit()
print("".join(ans))
| N,M=map(int, input().split())
A=[list(map(int, input().split())) for _ in range(M)]
A = sorted(A, reverse=False, key=lambda x: x[0])
if M==0:
if N==3:
print(100)
exit(0)
elif N==2:
print(10)
exit(0)
elif N==1:
print(0)
exit(0)
if N!=1 and A[0][0]==1 and A[0][1]==0:
print(-1)
exit(0)
i=1
j=len(A)
while i<j:
if A[i][0]==A[i-1][0] and A[i][1]==A[i-1][1]:
A.pop(i)
j-=1
continue
elif A[i][0]==A[i-1][0] and A[i][1]!=A[i-1][1]:
print(-1)
exit(0)
i+=1
ans=[None]*N
for i,j in A:
ans[i-1]=j
for i in range(len(ans)):
if ans[i]==None:
if i==0:
ans[i]=1
else:
ans[i]=0
print(''.join(map(str,ans))) | 1 | 60,771,879,108,290 | null | 208 | 208 |
#!/usr/bin/env python3
def inp():
n, m = map(int, input().split())
return n - 1, m - 1
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def rem(cand, p, q):
cand[p] += 1
cand[q] += 1
n, m, k = map(int, input().split())
UF = UnionFind(n)
non_cand = [1] * n
for _ in range(m):
a, b = inp()
UF.union(a, b)
rem(non_cand, a, b)
for _ in range(k):
c, d = inp()
if UF.same(c, d):
rem(non_cand, c, d)
ans = [UF.size(i) - non_cand[i] for i in range(n)]
print(*ans) | N = int(input())
X = input()
val = int(X,2)
C = X.count("1")
if C==1:
for i in range(N):
if X[i]=='1':
print(0)
elif i==N-1:
print(2)
else:
print(1)
exit()
# xをpopcountで割ったあまりに置き換える
def f(x):
if x==0: return 0
return 1 + f(x % bin(x).count("1"))
# 初回のpopcountでの割り方は、(C+1) or (C-1)
Y = val%(C+1)
if C-1 != 0:
Z = val%(C-1)
else:
Z = 0
for i in range(N):
if X[i] == "1":
if Z - 1 == 0:
print(0)
continue
k = (Z - pow(2,N-i-1,C-1)) % (C-1)
else:
k = (Y + pow(2,N-i-1,C+1)) % (C+1)
print(f(k)+1) | 0 | null | 34,817,554,577,828 | 209 | 107 |
s=input()
n=len(s)
k=int(input())
if s[0]==s[n-1]:
d=1
ans=0
for i in range(1,n):
if s[i-1]==s[i] and d==1:
ans+=1
d=0
elif s[i-1]==s[i] and d==0:
d=1
elif s[i-1]!=s[i]:
d=1
if d==0:
print(ans*k)
else:
ans2=0
for i in range(n):
if s[i-1]==s[i] and d==1:
ans2+=1
d=0
elif s[i-1]==s[i] and d==0:
d=1
elif s[i-1]!=s[i]:
d=1
if d==1:
print(ans+ans2*(k-1))
else:
if k%2==0:
print((ans+ans2)*k//2)
else:
print((ans+ans2)*(k//2)+ans)
elif s[0]!=s[n-1]:
d=1
ans=0
for i in range(1,n):
if s[i-1]==s[i] and d==1:
ans+=1
d=0
elif s[i-1]==s[i] and d==0:
d=1
elif s[i-1]!=s[i]:
d=1
print(ans*k) | import sys
from collections import Counter
input = sys.stdin.readline
def main():
a = input().strip()
n = int(input())
l = len(a)
b = Counter(a)
if len(b) == 1:
c = (n * l) // 2
print(c)
exit()
su = 0
ans = []
for i in range(1, l):
if a[i] == a[i - 1]:
su += 1
else:
ans.append(su + 1)
su = 0
ans.append(su + 1)
rev = 0
for j in ans:
rev += j // 2
if a[0] == a[-1]:
dif = ans[0]//2 + ans[-1]//2 - (ans[0]+ans[-1])//2
print(rev*n - dif*(n - 1))
else:
print(rev*n)
if __name__ == '__main__':
main()
| 1 | 175,039,082,456,898 | null | 296 | 296 |
i=1
while True:
n=int(input())
if n!=0:
print("Case %d: %d"%(i,n))
i=i+1
else:
break | n = int(input())
j_list = [input() for x in range(n)]
print("AC x",j_list.count("AC"))
print("WA x",j_list.count("WA"))
print("TLE x",j_list.count("TLE"))
print("RE x",j_list.count("RE")) | 0 | null | 4,628,846,385,582 | 42 | 109 |
import sys
def input(): return sys.stdin.readline().strip()
def main():
N, M = map(int, input().split())
S = input()
def isOK(index):
return S[index] == "0"
ans = []
now = N
while now:
for step in range(min(now, M), -1, -1):
if step == 0:
print(-1)
exit()
if isOK(now-step):
ans.append(step)
now -= step
break
print(*ans[::-1], sep=" ")
if __name__ == "__main__":
main() | n,m=map(int,input().split())
l=list(input())
l=l[::-1]
now=0
ans=[]
while now<n:
num=min(n-now,m)#進める最大
b=True
for i in range(num):
num1=num-i
if l[now+num1]!="1":
ans.append(str(num1))
now+=num1
b=False
break
if b:
now=n+1
if b:
print(-1)
else:
ans=ans[::-1]
print(" ".join(ans)) | 1 | 138,731,604,882,432 | null | 274 | 274 |
N = int(input())
if N % 2 == 0 :
print(0.5)
else : print( (N+1)//2 /N) | print(-(-int(input()) // 2)) | 0 | null | 117,984,755,632,842 | 297 | 206 |
from sys import stdout
import bisect
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
DBG = True # and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
def f(x):
sm = 0
for i in range(n-1,-1,-1):
j = bisect.bisect_left(a,x-a[i])
sm += n-j
if sm>=m:
return True
return False
n,m = inm()
a = inl()
a.sort()
acc = [0]*(n+1)
for i in range(n-1,-1,-1):
acc[i] = acc[i+1]+a[i]
mn = 2*min(a)
mx = 2*max(a)+1
while mx-mn>=2:
mid = (mx+mn)//2
if f(mid):
mn = mid
else:
mx = mid
# mn is the m-th
# sum and cnt upto mn+1
sm = cnt = 0
for i in range(n):
j = bisect.bisect_left(a,mx-a[i])
sm += acc[j]+(n-j)*a[i]
cnt += n-j
print(sm+mn*(m-cnt))
| n = int(input())
s,t = input().split()
for i in range(n):
print(s[i]+t[i],end="") | 0 | null | 110,023,243,699,762 | 252 | 255 |
import sys
sys.setrecursionlimit(10 ** 9)
if __name__ == '__main__':
n = int(input())
tree = [[] for i in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
tree[a - 1].append([b - 1, i])
ans = 0
for i in tree:
ans = max(ans, len(i))
ans = [0] * (n - 1)
def solve(cur_index, color):
cnt = 1
for to, j in tree[cur_index]:
if cnt == color:
cnt += 1
ans[j] = cnt
solve(to, cnt)
cnt += 1
solve(0, 0)
print(max(ans))
print(*ans, sep="\n") | n=int(input())
edges=[[] for i in range(1+n)]
e={}
for i in range(n-1):
"""#weighted->erase_,__,___=map(int,input().split())
edges[_].append((__,___))
edges[__].append((_,___))
"""
_,__=map(int,input().split())
edges[_].append(__)
edges[__].append(_)
e[(_,__)]=i
e[(__,_)]=i
"""
"""#weighted->erase
f=max(len(j)for j in edges)
print(f)
ret=[0]*(n-1)
from collections import deque
dq=deque([(1,1)])
#pop/append/(append,pop)_left/in/len/count/[]/index/rotate()(右へnずらす)
while dq:
a,c=dq.popleft()
for to in edges[a]:
if ret[e[(a,to)]]:continue
ret[e[(a,to)]]=c
c=c%f+1
dq.append((to,c))
print(*ret,sep="\n") | 1 | 136,089,476,216,688 | null | 272 | 272 |
r, c = map(int, input().split())
table = []
for _ in range(r):
table.append(list(map(int, input().split())))
for row in range(r):
print(' '.join(map(str, table[row])), sum(table[row]), sep=' ')
# print(' '.join(map(str, [sum(table[:][col]) for col in range(c)])), sum(table), sep=' ')
col_sum = [sum([table[row][col] for row in range(r)]) for col in range(c)]
print(' '.join(map(str, col_sum)), sum(col_sum), sep=' ')
| h,w,k=map(int,input().split())
cho=[]
for _ in range(h):
a=list(input())
for f in range(w):
a[f]=int(a[f])
cho.append(a)
ans=1000000000009
for i in range(2**(h-1)):
cut=0
cut_n=[]
b=[]
for j in range(h-1):
if (i>>j)&1:
cut_n.append(j+1)
cut+=1
if len(cut_n)==0:
ok=1
dp=0
for i in range(w):
wa=0
for j in range(h):
wa+=cho[j][i]
if dp+wa>k:
cut+=1
dp=wa
else:
dp+=wa
if wa>k:
ok+=1
break
if ok==1:
ans=min(ans,cut)
else:
st=0
for t in range(len(cut_n)):
if t==len(cut_n)-1:
b.append(cut_n[t]-st)
b.append(h-cut_n[t])
else:
b.append(cut_n[t]-st)
st=cut_n[t]
dp=[0 for _ in range(len(b))]
ok=1
for y in range(w):
for g in dp:
if g>k:
ok+=1
break
st=0
ch=0
c=[]
for e in range(len(b)):
p=b[e]
temp=0
for q in range(p):
temp+=cho[st+q][y]
dp[e]+=cho[st+q][y]
c.append(temp)
st+=p
for g in dp:
if g>k:
ch+=1
if ch!=0:
cut+=1
dp=c
for last in c:
if last>k:
ok+=1
if ok==1:
ans=min(ans,cut)
print(ans)
| 0 | null | 25,012,160,152,420 | 59 | 193 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.