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
|
|---|---|---|---|---|---|---|
import sys
read = sys.stdin.read
#readlines = sys.stdin.readlines
from collections import defaultdict
def main():
k = int(input())
if k % 2 == 0:
print(-1)
sys.exit()
rems = defaultdict(int)
n = 7 % k
next_digit = 70 % k
r = 1
while True:
if n == 0:
print(r)
sys.exit()
elif rems[n]:
print(-1)
sys.exit()
else:
rems[n] = 1
n += next_digit
n = n % k
next_digit = (next_digit * 10) % k
r += 1
if __name__ == '__main__':
main()
|
k = int(input())
mod = 7 % k
counter = 1
memo = 1
mod_map = set()
mod_map.add(mod)
while mod != 0:
mod = ((mod * 10) % k + 7) % k
if mod not in mod_map:
mod_map.add(mod)
else:
counter = -1
break
counter += 1
if mod == 0:
break
print(counter)
| 1 | 6,127,702,004,632 | null | 97 | 97 |
# import itertools
# import math
# import sys
# sys.setrecursionlimit(500*500)
# import numpy as np
# N = int(input())
# S = input()
# n, *a = map(int, open(0))
N, X, Y = map(int, input().split())
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
# S = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 1)
# 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
cnt = [0] * N
for i in range(1, N + 1):
for j in range(i + 1, N + 1):
k = min([j - i, abs(X - i) + abs(Y - j) + 1, abs(Y - i) + abs(X - j) + 1])
cnt[k] += 1
for i in range(1, N):
print(cnt[i])
|
N = int(input())
A = list(map(int, input().split()))
if 0 in A:
ans = 0
else:
ans = 1
max_limit = 10 ** 18
for i in range(N):
if ans * A[i] > max_limit:
ans = -1
break
else:
ans *= A[i]
print(str(ans))
| 0 | null | 29,931,835,070,982 | 187 | 134 |
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
ans = 'YES' if abs(B - A) <= (V - W) * T else 'NO'
print(ans)
|
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if a < b:
if a + v * t >= b + w * t:
print("YES")
else:
print("NO")
else:
if a - v * t <= b - w * t:
print("YES")
else:
print("NO")
| 1 | 15,174,822,264,900 | null | 131 | 131 |
x=int(input())
for i in range(1001):
for j in range(100*i,105*i+1):
if x==j:
print(1)
exit(0)
print(0)
|
# Binary Indexed Tree (Fenwick Tree)
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
self.el = [0]*(n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.bit[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i-1)
def lower_bound(self,x):
w = i = 0
k = 1<<((self.n).bit_length())
while k:
if i+k <= self.n and w + self.bit[i+k] < x:
w += self.bit[i+k]
i += k
k >>= 1
return i+1
def alph_to_num(s):
return ord(s)-ord('a')
def solve():
N = int(input())
S = list(map(alph_to_num,list(input())))
Q = int(input())
bits = [BIT(N) for _ in range(26)]
for i in range(N):
bits[S[i]].add(i+1,1)
ans = []
for _ in range(Q):
x,y,z = input().split()
y = int(y)
if x=='1':
z = alph_to_num(z)
bits[S[y-1]].add(y,-1)
S[y-1] = z
bits[z].add(y,1)
if x=='2':
z = int(z)
ans.append(sum([bits[i].get(y,z)>0 for i in range(26)]))
return ans
print(*solve(),sep='\n')
| 0 | null | 94,822,593,785,890 | 266 | 210 |
K = int(input())
count =1
x = 7%K
for i in range(0,K+1):
if x== 0:
print(count)
break
count+=1
x = (x*10+7)%K
if i== K:
print(-1)
|
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 7 01:25:53 2020
@author: saito
"""
# %% import phase
#from collections import deque
# %% define phase
# %% input phase
K = int(input())
# %% process phase
r = 0
answer = -1
h = []
for cnt in range(K):
r = (10*r+7) % K
if r == 0:
answer = cnt + 1
break
# %%output phase
print(answer)
| 1 | 6,116,916,180,210 | null | 97 | 97 |
import math
def insertionsort(A, n, g):
cnt = 0
for i in range(g, n):
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
def shellsort(A, n):
G = []
gap = 1
while gap <= math.ceil(n / 3):
G.append(gap)
gap = gap * 3 + 1
G = G[::-1]
m = len(G)
print(m)
print(*G)
cnt = 0
for i in range(m):
cnt += insertionsort(A, n, G[i])
print(cnt)
n = int(input())
A = []
for i in range(n):
A.append(int(input()))
shellsort(A, n)
for i in range(n):
print(A[i])
|
N = int(input())
clips = [input().split() for _ in range(N)]
X = input()
ans = 0
for i,title in enumerate(clips):
if X in title:
for j in range(i+1, N):
ans += int(clips[j][1])
break
print(ans)
| 0 | null | 48,493,850,601,602 | 17 | 243 |
import heapq
import sys
input = sys.stdin.readline
n = int(input())
s = [input() for _ in range(n)]
t = []
p = []
for i in range(n):
k = 0
m = 0
for c in s[i]:
if c == '(':
k += 1
elif c == ')':
k -= 1
m = min(k, m)
if k >= 0:
t.append((-m, k))
else:
k = 0
m = 0
for c in s[i][::-1]:
if c == ')':
k += 1
elif c == '(':
k -= 1
m = min(k, m)
p.append((-m, k))
t.sort()
p.sort()
hq = []
hq1 = []
d = 0
idx = 0
for i in range(len(t)):
while idx < len(t) and d >= t[idx][0]:
m, k = t[idx]
heapq.heappush(hq, (-k, m))
idx += 1
if hq:
k, m = heapq.heappop(hq)
else:
print('No')
break
d -= k
else:
d1 = 0
idx = 0
for i in range(len(p)):
while idx < len(p) and d1 >= p[idx][0]:
m, k = p[idx]
heapq.heappush(hq1, (-k, m))
idx += 1
if hq1:
k, m = heapq.heappop(hq1)
else:
print('No')
break
d1 -= k
else:
if d == d1:
print('Yes')
else:
print('No')
|
C = input()
次の英単語 = ord(C)+1
print(chr(次の英単語))
| 0 | null | 58,070,583,746,340 | 152 | 239 |
n = int(input())
a = list(map(int, input().split()))
mod = 10**9 + 7
ans = 0
for i in range(60):
cnt = 0
digit = 1 << i
for j in a:
if digit & j:
cnt += 1
ans += digit*cnt*(n - cnt)%mod
print(ans%mod)
|
import math
import numpy as np
N = int(input())
ARR = list(map(int,input().split()))
def calculate(n,arr):
maxValue = max(arr)
if maxValue == 0:
maxNum = 1
else:
maxNum = math.ceil(math.log(maxValue,2))
arr = np.array(arr)
oneArray = [0]*(maxNum+1)
zeroArray = [0]*(maxNum+1)
for i in range(maxNum+1):
s = (arr >> i) & 1
a = np.count_nonzero(s)
oneArray[i] = a
zeroArray[i] = n - a
finalResult = 0
for i in range(maxNum + 1):
finalResult += 2**i * oneArray[i] * zeroArray[i]
print(finalResult % (10**9 + 7))
calculate(N, ARR)
| 1 | 122,820,291,426,108 | null | 263 | 263 |
def main():
A, B, K = map(int, input().split())
r = max(0, A + B - K)
a = min(r, B)
t = r - a
print(t, a)
if __name__ == '__main__':
main()
|
while True:
try:
m,n = map(int, input().split())
except EOFError:
break
LCM = m * n
if m < n:
m,n = n,m
# calculating GCD
while True:
if m % n == 0:
GCD = n
break
else:
m, n = n, m % n
# calculating LCM
LCM = LCM // GCD
print(GCD,LCM)
| 0 | null | 51,903,857,448,810 | 249 | 5 |
import math
cnt = 0
def insertionSort(A,n,g):
global cnt
for i in range(g,n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
cnt += 1
j -= g
A[j+g] = v
def shellSort(A, n):
g = int(n/2) + 1
G = []
while g > 0:
G.append(g)
insertionSort(A, n, g)
g = int(g/2)
return G
n = int(input())
A = []
for _ in range(n):
A.append(int(input()))
G = shellSort(A,n)
print(len(G))
print(" ".join(map(str, G)))
print(cnt)
for i in A:
print(i)
|
cnt = 0
def insertionSort(A, n, g):
global cnt####スコープ指定
for i in range(g,n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:##後半の条件が付いていてもiを回すのでソートされる
A[j+g] = A[j]
j = j - g
cnt+=1
A[j+g] = v
def shellSort(A, n):
tmp = 1
G=[]
while tmp<n:
G.append(tmp)
tmp*=3
tmp+=1###なぜ要るのか分からないが
G.reverse()
for i in range(len(G)):
insertionSort(A, n, G[i])
n = int(input())
G1=[]
tmp=1
while tmp<n:
G1.append(tmp)
tmp*=3
tmp += 1
G1.reverse()
A1 =[int(input()) for _ in range(n)]
m = len(G1)
shellSort(A1, n)
print(max(m,1))
if G1:
print(*G1)
else:
print(1)
print(cnt)
for a in A1:
print(a)
| 1 | 30,018,005,486 | null | 17 | 17 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
dp=[0]
mp={0:1}
ans=0
for t in range(n):
i=a[t]
if t>=k-1:
mp[dp[-k]]-=1
num=(dp[-1]+i-1)%k
if num in mp.keys():
ans += mp[num]
mp[num] += 1
else:
mp[num] = 1
dp.append(num)
print(ans)
|
#!/usr/bin/env python
# coding: utf-8
# In[10]:
X,Y,A,B,C = map(int, input().split())
p = sorted(list(map(int, input().split())), reverse=True)
q = sorted(list(map(int, input().split())), reverse=True)
r = sorted(list(map(int, input().split())), reverse=True)
# In[14]:
p_list = p[:X]
q_list = q[:Y]
mylist = sorted(p_list + q_list + r, reverse=True)
ans = 0
for i in range(X+Y):
ans += mylist[i]
print(ans)
# In[ ]:
| 0 | null | 91,405,265,905,560 | 273 | 188 |
p1 , s1=map(int , input().split())
p2 , s2=map(int , input().split())
t=int(input())
if abs(p1-p2) > t*(s1-s2):
print("NO")
else:
print("YES")
|
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
diff = abs(A - B)
dspeed = V - W
if dspeed * T >= diff:
print("YES")
else:
print("NO")
| 1 | 15,125,113,616,500 | null | 131 | 131 |
n,k = map(int,input().split())
h = list(map(int,input().split()))
h.sort()
for i in range(min(n,k)):
h.pop()
print(sum(h))
|
n = int(input())
A = list(map(int, input().split()))
freq = [0] * (max(A)+1)
for a in A:
freq[a] += 1
total = 0
for f in freq:
total += f*(f-1)//2
for a in A:
print (total - max(freq[a]-1, 0))
| 0 | null | 63,457,144,430,318 | 227 | 192 |
X=int(input())
a=X%500
to=X//500*1000+a//5*5
print(to)
|
def readinput():
a,b=map(int,input().split())
return a,b
def main(a,b):
for i in range(20000):
if i*108//100 - i ==a and i*110//100 - i ==b:
return i
return -1
if __name__=='__main__':
a,b=readinput()
ans=main(a,b)
print(ans)
| 0 | null | 49,747,285,728,182 | 185 | 203 |
def rle(t):
tmp2, count_, ans_ = t[0], 1, []
for i_ in range(1, len(t)):
if tmp2 == t[i_]:
count_ += 1
else:
ans_.append([tmp2, count_])
tmp2 = t[i_]
count_ = 1
ans_.append([tmp2, count_])
return ans_
S = list(input())
l = rle(S)
ans = [0] * (len(S) + 1)
count = 0
for i in range(len(l)):
if l[i][0] == '<':
for j in range(l[i][1] + 1):
ans[count + j] = max(ans[count + j], j)
elif l[i][0] == '>':
for k in range(l[i][1] + 1):
ans[count + k] = max(ans[count + k], l[i][1] - k)
count += l[i][1]
print(sum(ans))
|
S = int(input())
q , mod = divmod(S , 2)
print(q+mod)
| 0 | null | 107,606,153,586,612 | 285 | 206 |
from collections import deque
n, q = map(int, input().split())
ps = [input().split() for _ in range(n)]
que = deque(ps)
time = 0
while que:
p, rest = que.popleft()
elapsed = min(q, int(rest))
time += elapsed
rest = str(int(rest) - elapsed)
if int(rest) > 0:
que.append([p, rest])
else:
print(p, time)
|
class Proc:
def __init__(self, name, time):
self.name = name
self.time = time
n, q = map(int, input().split(' '))
procs = []
for i in range(0, n):
name, time = input().split(' ')
time = int(time)
procs.append(Proc(name, time))
elapsed = 0
while len(procs) > 0:
proc = procs.pop(0)
if proc.time > q:
proc.time -= q
elapsed += q
procs.append(proc)
else:
elapsed += proc.time
print(proc.name, elapsed)
| 1 | 46,273,930,942 | null | 19 | 19 |
# -*- coding: utf-8 -*-
# 入力を整数に変換して受け取る
def input_int():
return int(input())
# マイナス1した値を返却
def int1(x):
return int(x) - 1
# 半角スペース区切り入力をIntに変換してMapで受け取る
def input_to_int_map():
return map(int, input().split())
# 半角スペース区切り入力をIntに変換して受け取る
def input_to_int_tuple():
return tuple(map(int, input().split()))
# 半角スペース区切り入力をIntに変換してマイナス1した値を受け取る
def input_to_int_tuple_minus1():
return tuple(map(int1, input().split()))
def main():
n = input_int()
cnt = [[0] * 10 for i in range(10)]
for n in range(1, n + 1):
cnt[int(str(n)[0])][int(str(n)[-1])] += 1
ret = 0
for i in range(10):
for j in range(10):
ret += cnt[i][j] * cnt[j][i]
return ret
if __name__ == "__main__":
print(main())
|
N = int(input())
li = [[0]*9 for i in range(9)]
counter = 0
for i in range(1,N+1):
I = str(i)
fast = int(I[0])
last = int(I[-1])
if not last==0:
li[fast-1][last-1] += 1
for i in range(9):
for k in range(9):
counter += li[i][k]*li[k][i]
print(counter)
| 1 | 86,798,072,019,360 | null | 234 | 234 |
def factorization(n):
res = []
tmp = n
for i in range(2, int(-(-n**0.5//1))+1):
if tmp % i == 0:
cnt = 0
while tmp % i == 0:
cnt += 1
tmp //= i
res.append([i, cnt])
if tmp!=1:
res.append([tmp, 1])
return res
N = int(input())
ans = 0
for tmp,cnt in factorization(N):
i = 1
while i<=cnt:
ans += 1
cnt-=i
i += 1
print(ans)
|
import sys
import math
n, k = map(int, sys.stdin.readline().split())
W = []
for _ in range(n):
w = int(sys.stdin.readline())
W.append(w)
r = sum(W)
l = max(W)
pre_p = 0
while l < r:
current = 0
num_tracks = 1
p = (l + r) // 2 # 値を設定
# 積み込めるか確認
for w in W:
if current + w > p:
num_tracks += 1 # 次のトラックを持ってくる
current = w
else:
current += w
if num_tracks > k: # 現在の p ではトラックが足りない場合
l = p + 1 # 最少値を上げる
else:
r = p # 最大値を下げる
print(l)
| 0 | null | 8,468,077,172,796 | 136 | 24 |
class BIT:
def __init__(self, n):
self.node = [ 0 for _ in range(n+1) ]
def add(self, idx, w):
i = idx
while i < len(self.node) - 1:
self.node[i] += w
i |= (i + 1)
def sum_(self, idx):
ret, i = 0, idx-1
while i >= 0:
ret += self.node[i]
i = (i & (i + 1)) - 1
return ret
def sum(self, l, r):
return self.sum_(r) - self.sum_(l)
n = int(input())
s = list(input())
q = int(input())
tree = [ BIT(n) for _ in range(26) ]
for i in range(n):
tree_id = ord(s[i]) - ord("a")
tree[tree_id].add(i, 1)
for _ in range(q):
query = input().split()
com = int(query[0])
if com == 1:
idx, new_char = int(query[1]), query[2]
idx -= 1
old_char = s[idx]
new_id = ord(new_char) - ord("a")
old_id = ord(old_char) - ord("a")
tree[old_id].add(idx, -1)
tree[new_id].add(idx, 1)
s[idx] = new_char
if com == 2:
l, r = int(query[1]), int(query[2])
ret = 0
for c in range(26):
if tree[c].sum(l-1, r) > 0:
ret += 1
print(ret)
|
n,d,a=map(int,input().split())
arr=[list(map(int,input().split())) for _ in range(n)]
arr=sorted(arr,key=lambda x:x[0])
lim=[0]*n
pos=0
for i in range(n):
while pos!=n-1:
if arr[i][0]+2*d>=arr[pos+1][0]:
pos+=1
else:
break
lim[i]=pos
ans=0
damage=[0]*n
acum=0
pos=0
for i in range(n):
while i>lim[pos]:
acum-=damage[pos]
pos+=1
if pos==n:
break
ans+=max(0,(arr[i][1]-acum+(a-1))//a)
damage[i]=a*max(0,(arr[i][1]-acum+(a-1))//a)
acum+=damage[i]
print(ans)
| 0 | null | 72,124,587,776,560 | 210 | 230 |
import math
print(2*float(input())*math.pi)
|
x = input()
if x == "1": print(0)
else: print(1)
| 0 | null | 17,125,747,385,798 | 167 | 76 |
import itertools
while True:
n, x = map(int, input().split())
if n == x == 0:
break
result = 0
for i in itertools.combinations(range(1, n + 1), 3):
if sum(i) == x:
result += 1
print(result)
|
from sys import stdin
mod = 10**9+7
N,K = [int(x) for x in stdin.readline().rstrip().split()]
A = [int(x) for x in stdin.readline().rstrip().split()]
maxn = 2*10**6
fac = [0 for _ in range(maxn)]
finv = [0 for _ in range(maxn)]
inv = [0 for _ in range(maxn)]
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,maxn):
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 combinations(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
ans = 0
A.sort()
for ind,a in enumerate(A):
ans -= a*combinations(N-ind-1,K-1) % mod
ans %= mod
A.reverse()
for ind,a in enumerate(A):
ans += a*combinations(N-ind-1,K-1) % mod
ans %= mod
print(ans%mod)
| 0 | null | 48,510,872,362,040 | 58 | 242 |
from collections import Counter, defaultdict
# n = int(input())
# li = list(map(int, input().split()))
# n = int(input())
a, b = map(int, input().split())
c, d = map(int, input().split())
# d = defaultdict(lambda: 0)
# s = input()
print("1" if c == a+1 else "0")
|
d1 = input().split()[0]
d2 = input().split()[0]
if d1 != d2:
print(1)
else:
print(0)
| 1 | 124,768,564,237,130 | null | 264 | 264 |
x = list(map(int, input().split(" ")))
h1 = x[0]
m1 = x[1]
h2 = x[2]
m2 = x[3]
s = x[4]
h = (h2-h1)*60
m = m2-m1
print((h+m)-s)
|
h1,m1,h2,m2,K = map(int,input().split() )
H=h2-h1
M=m2-m1
if(M<0):
M += 60
H -= 1
if(H<0):
H += 24
M += H*60
ans =M - K
print(ans)
| 1 | 18,078,419,573,540 | null | 139 | 139 |
print '1' if int(raw_input().split(' ')[1]) > int(raw_input().split(' ')[1]) else '0'
|
a=input()
b=input()
if(a==b[0:len(b)-1] and len(b)-len(a)==1):
print('Yes')
else:
print('No')
| 0 | null | 72,880,442,961,020 | 264 | 147 |
N = int(input())
S = str(input())
count = 1
for i in range(N-1):
if S[i]!=S[i+1]:
count += 1
print(count)
|
n = int(input())
s = input()
ans = 1
prev = s[0]
for i in range(1, len(s)):
if s[i] == prev:
continue
ans += 1
prev = s[i]
print(ans)
| 1 | 169,926,973,457,952 | null | 293 | 293 |
import math
a, b, h, m = list(map(int, input().split()))
ang = abs(h * 30 + m * 0.5 - m * 6)
print(math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(ang * math.pi / 180)))
|
a,b,c = map(int, input().split())
print(str(c)+" "+str(a)+" "+str(b))
| 0 | null | 28,920,356,391,420 | 144 | 178 |
#!/usr/bin/env python3
def main():
n = int(input())
s, t = input().split()
print(*[s[i] + t[i] for i in range(n)], sep="")
if __name__ == "__main__":
main()
|
n=int(input())
s,t=input().split()
ans=''
for i in range(2*n):
ans=ans+(s[i//2] if i%2==0 else t[(i-1)//2])
print(ans)
| 1 | 112,434,207,779,368 | null | 255 | 255 |
import sys
for i in sys.stdin.readlines():
nums = list(map(int,i.split()))
h = nums[0]
w = nums[1]
if h == 0 and w == 0:
break
for j in range(1,h+1):
if h == 1 and w == 1:
print("#")
elif j % 2 == 1:
if w % 2 == 1:
x = int((w-1)/2)
print("#."*x +"#")
else:
x = int(w/2)
print("#."*x)
elif j % 2 == 0:
if w % 2 == 1:
x = int((w-1)/2)
print(".#"*x +".")
else:
x = int(w/2)
print(".#"*x)
print("")
|
import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
MAX = 2 * 10 ** 5 + 5
MOD = 10 ** 9 + 7
fac = [0 for i in range(MAX)]
finv = [0 for i in range(MAX)]
inv = [0 for i in range(MAX)]
def comInit(mod):
fac[0], fac[1] = 1, 1
finv[0], finv[1] = 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(mod, n, k):
numerator = 1
for i in range(1, k + 1):
numerator *= (n - i + 1)
numerator %= mod
return (numerator * finv[k] % mod)
comInit(MOD)
n, a, b = map(int, readline().split())
nb = n
def my_pow(base, n, mod):
if n == 0:
return 1
x = base
y = 1
while n > 1:
if n % 2 == 0:
x *= x
n //= 2
else:
y *= x
n -= 1
x %= mod
y %= mod
return x * y % mod
ans = (my_pow(2, n, MOD) - 1) % MOD
print((ans - com(MOD, nb, a) - com(MOD, nb, b)) % MOD)
| 0 | null | 33,655,975,721,760 | 51 | 214 |
class Dice:
def __init__(self):
self.up = 1
self.under = 6
self.N = 5
self.W = 4
self.E = 3
self.S = 2
def roll(self, d):#d => direction
if d == "N":
tmp = self.up
self.up = self.S
self.S = self.under
self.under = self.N
self.N = tmp
elif d == "W":
tmp = self.up
self.up = self.E
self.E = self.under
self.under = self.W
self.W = tmp
elif d == "E":
tmp = self.up
self.up = self.W
self.W = self.under
self.under = self.E
self.E = tmp
elif d == "S":
tmp = self.up
self.up = self.N
self.N = self.under
self.under = self.S
self.S = tmp
def getUpward(self):
return self.up
def setRoll(self,up,under,N,W,E,S):
self.up = up
self.under = under
self.N = N
self.W = W
self.E = E
self.S = S
def rotate(self):#crockwise
tmp = self.S
self.S = self.E
self.E = self.N
self.N = self.W
self.W = tmp
def getE(self, up, S):
'''
:param up:num
:param S: num
:return: num
'''
count = 0
while True:
if self.up == up:
break
if count != 3:
self.roll("N")
count += 1
else:
self.roll("E")
while True:
if self.S == S:
break
self.rotate()
return self.E
myd = Dice()
myd.up, myd.S, myd.E, myd.W, myd.N, myd.under = map(int,input().split())
n = int(input())
for i in range(n):
up, S = map(int,input().split())
print(myd.getE(up,S))
|
n=int(input())
a=[0]*n
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
k=x*x+y*y+z*z+x*y+y*z+z*x
if k <=n:
a[k-1]+=1
for q in range(n):
print(a[q])
| 0 | null | 4,125,818,884,840 | 34 | 106 |
while True:
t = input()
if t.find("?") > 0:
break
print(int(eval(t)))
|
n,a,b = map(int,input().split())
if (b-a) % 2 == 0:
ans = (b-a) // 2
else:
if a-1 < n-b:
ans = b-1
x = b-(a-1)-1
ans = min(ans, a + (x-1) // 2)
else:
ans = n-a
x = a + (n-b) + 1
ans = min(ans, (n-b) + 1 + (n-x) // 2)
print(ans)
| 0 | null | 55,275,447,876,990 | 47 | 253 |
import math
a,b,c=map(int,input().split())
C=(c/180)*math.pi
S=(a*b*math.sin(C))/2
L=a+b+(a**2+b**2-2*a*b*math.cos(C))**0.5
h=b*math.sin(C)
print("%.5f\n%.5f\n%.5f\n"%(S,L,h))
|
for _ in[0]*int(input()):a,b,c=sorted(map(int,input().split()));print(['NO','YES'][a*a+b*b==c*c])
| 0 | null | 85,084,547,042 | 30 | 4 |
def how_many_ways(n, x):
ways = 0
for i in range(1, n-1):
for j in range(i+1, n):
for k in range(j+1, n+1):
if i+j+k == x:
ways += 1
return ways
def main():
while True:
n, x = [int(x) for x in input().split()]
if n == x == 0:
break
print(how_many_ways(n, x))
if __name__ == '__main__':
main()
|
while True:
n, x = map(int, input().split())
if n == 0:
break
count = 0
for n1 in range(1, n+1):
for n2 in range(n1+1, n+1):
for n3 in range(n2+1, n+1):
if n1 + n2 + n3 == x:
count += 1
print(count)
| 1 | 1,292,006,388,232 | null | 58 | 58 |
n = int(input())
s = [input() for _ in range(n)]
d = {}
for i in s:
if i not in d:
d[i] = 1
else:
d[i] += 1
m = max(d.values())
l = []
for i in d.keys():
if d[i] == m:
l.append(i)
l_s = sorted(l)
for i in l_s:
print(i)
|
def kton(S):
r = 0
m = 0
for s in S:
r += 1 if s == '(' else -1
m = min(m, r)
return r, m
def main():
N = int(input())
RM = [kton(input()) for _ in range(N)]
pos = 0
negp = []
negn = []
posn = []
for r, m in RM:
if m < 0:
if r >= 0:
negp.append((-m, r))
else:
negn.append((-(r-m), -r, m))
else:
pos += r
negp.sort()
for m, r in negp:
if pos - m < 0:
return False
pos += r
negn.sort()
for _, r, m in negn:
if pos + m < 0:
return False
pos -= r
return pos == 0
print('Yes' if main() else 'No')
| 0 | null | 46,926,945,848,442 | 218 | 152 |
def srch(u, cnt, Dst, Fst, Lst):
S = [u]
Fst[u] = cnt
while(len(S) > 0):
cnt += 1
u = S.pop()
if Dst[u] is not None and len(Dst[u]) > 0:
while(len(Dst[u])):
u1 = Dst[u].pop()
if Fst[u1] == 0:
S.append(u)
S.append(u1)
Fst[u1] = cnt
break
else:
Lst[u] = cnt
else:
Lst[u] = cnt
return cnt + 1
def main():
num = int(input())
Dst = [None for i in range(num + 1)]
Fst = [0] * (num + 1)
Lst = Fst[:]
for n in range(1, num+1):
a = list(map(int,input().split()))
u = a[0]
if a[1] > 0:
Dst[u] = a[2:]
Dst[u].reverse()
cnt = 1
for i in range(1,num):
if Fst[i] == 0:
cnt = srch(i, cnt, Dst, Fst, Lst)
for n in range(1, num+1):
print("{} {} {}".format(n,Fst[n],Lst[n]))
if __name__ == '__main__':
main()
|
[H, A] = [int(i) for i in input().split()]
t = 0
if H/A != int(H/A):
t = 1
print(int(H/A) + t)
| 0 | null | 38,332,001,044,192 | 8 | 225 |
A,B,N=map(int,input().split())
max_L=0
x=0
if B>N:
x=N
max_L=int(A*x/B)-A*int(x/B)
else:
x=B-1
max_L=int(A*x/B)-A*int(x/B)
print(max_L)
|
def solve():
A,B,N = [int(i) for i in input().split()]
x = min(B-1,N)
print(int(A*x/B)-A*int(x/B))
if __name__ == "__main__":
solve()
| 1 | 28,091,167,533,690 | null | 161 | 161 |
N, K, C = map(int, input().split())
S = input()
L, R = [], []
i = 0
while len(L) < K:
if S[i] == "o":
L.append(i)
i += C+1
else:
i += 1
i = N-1
while len(R) < K:
if S[i] == "o":
R.append(i)
i -= C+1
else:
i -= 1
R = R[::-1]
for i in range(K):
if L[i] == R[i]:
print (L[i]+1)
|
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)
| 1 | 40,652,695,978,620 | null | 182 | 182 |
n_m_str=input().split()
n_m=list(map(lambda i : int(i),n_m_str))
n,m=n_m[0],n_m[1]
a=[input() for i in range(n)]
A=[]
for i in a:
A.append(i.split())
b=[input() for i in range(m)]
Ab=[]
for i in range(n):
Ab.append(0)
for i in range(n):
for j in range(m):
Ab[i]+=int(A[i][j])*int(b[j])
for i in Ab:
print(i)
|
print("Yes" if "7" in list(input()) else "No")
| 0 | null | 17,632,813,900,312 | 56 | 172 |
MOD = 10 ** 9 + 7
class ModFactorial:
"""
階乗, 組み合わせ, 順列の計算
"""
def __init__(self, n, MOD=10 ** 9 + 7):
"""
:param n: 最大の要素数.
:param MOD:
"""
kaijo = [0] * (n + 10)
gyaku = [0] * (n + 10)
kaijo[0] = 1
kaijo[1] = 1
for i in range(2, len(kaijo)):
kaijo[i] = (i * kaijo[i - 1]) % MOD
gyaku[0] = 1
gyaku[1] = 1
for i in range(2, len(gyaku)):
gyaku[i] = pow(kaijo[i], MOD - 2, MOD)
self.kaijo = kaijo
self.gyaku = gyaku
self.MOD = MOD
def nCm(self, n, m):
return (self.kaijo[n] * self.gyaku[n - m] * self.gyaku[m]) % self.MOD
def nPm(self, n, m):
return (self.kaijo[n] * self.gyaku[n - m]) % self.MOD
def factorial(self, n):
return self.kaijo[n]
N, K = [int(_) for _ in input().split()]
modf = ModFactorial(N)
A = [int(_) for _ in input().split()]
A.sort()
i = 1
maxv = 0
for i in range(N):
if K - 1 <= i:
maxv += modf.nCm(i, K - 1) * A[i]
maxv %= MOD
# print(maxv)
A.reverse()
minv=0
for i in range(N):
if K - 1 <= i:
minv += modf.nCm(i, K - 1) * A[i]
minv %= MOD
print((maxv-minv)%MOD)
|
N = int(input())
A = list(map(int,input().split()))
A.sort()
ans = 0
for k in range(1, N): ans += A[N-k//2-1]
print(ans)
| 0 | null | 52,566,162,091,718 | 242 | 111 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
s,t = input().split()
print(''.join([s[i] + t[i] for i in range(n)]))
|
N, A, B = map(int, input().split())
cont_num = A+B
k = N // cont_num
# print(k)
adjust_num = N - k*cont_num
add_blue = 0
if adjust_num >= A:
add_blue = A
else:
add_blue = adjust_num
print(k*A + add_blue)
| 0 | null | 83,776,750,756,548 | 255 | 202 |
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
class BIT:
def __init__(self, L):
self.n = len(L)
self.bit = [0] * (self.n + 1)
def update(self, idx, x):
while idx <= self.n:
self.bit[idx] += x
idx += idx & (-idx)
def query(self, idx):
res = 0
while idx > 0:
res += self.bit[idx]
idx -= idx & (-idx)
return res
def sec_sum(self, left, right):
return self.query(right) - self.query(left - 1)
def debug(self):
print(*[self.sec_sum(i, i) for i in range(1, self.n + 1)])
def resolve():
n = int(input())
S = list(input().rstrip())
q = int(input())
bits = [BIT(S) for _ in range(26)]
for idx in range(1, n + 1):
s = S[idx - 1]
bits[ord(s) - ord("a")].update(idx, 1)
for _ in range(q):
query = list(input().split())
if query[0] == "1":
i, c = int(query[1]), query[2]
prev = S[i - 1]
bits[ord(prev) - ord("a")].update(i, -1)
bits[ord(c) - ord("a")].update(i, 1)
S[i - 1] = c
else:
l, r = int(query[1]), int(query[2])
res = 0
for j in range(26):
if bits[j].sec_sum(l, r):
res += 1
print(res)
if __name__ == '__main__':
resolve()
|
import bisect
import sys
def input(): return sys.stdin.readline().rstrip()
n = int(input())
s = list(input())
q = int(input())
char_idx = [[] for _ in range(26)]
for i in range(n):
char_idx[ord(s[i])-ord('a')].append(i)
# print(char_idx)
query = [input().split() for _ in range(q)]
# print(query)
for t, a, b in query:
if t=='1':
i = int(a) - 1
if s[i] == b:
continue
else:
idx = bisect.bisect_left(char_idx[ord(s[i])-ord('a')], i)
if char_idx[ord(s[i])-ord('a')][idx] == i:
del char_idx[ord(s[i])-ord('a')][idx]
bisect.insort_left(char_idx[ord(b)-ord('a')], i)
s[i] = b
else:
l = int(a) - 1
r = int(b) - 1
ans = 0
for i in range(26):
if len(char_idx[i]) == 0:
continue
it = bisect.bisect_left(char_idx[i], l)
if it < len(char_idx[i]) and char_idx[i][it] <= r:
ans += 1
print(ans)
| 1 | 62,268,101,731,780 | null | 210 | 210 |
n = int(input())
a = list(map(int, input().split()))
ret = 0
now = a[0]
for i in range(1, n):
if now > a[i]:
ret += now - a[i]
a[i] = now
now = a[i]
print(ret)
|
n = int(input())
a = list(map(int, input().split()))
maxa = 0
ans = 0
for i in range(n):
if maxa > a[i]:
ans += maxa - a[i]
else:
maxa = a[i]
print(ans)
| 1 | 4,550,561,241,470 | null | 88 | 88 |
P=10**9+7
N=int(input())
A=list(map(int, input().split()))
ans=1
c=[0,0,0]
for i in range(N):
a,f,k=A[i],-1,0
for j in range(3):
if c[j]==a:
k+=1
if f==-1:
c[j]+=1
f=j
ans=(ans*k)%P
print(ans)
|
def check(seq):
return len(seq) != len(set(seq))
def main():
N = int(input())
A = list(map(int, input().split()))
ans = check(A)
if ans:
print("NO")
else:
print("YES")
main()
| 0 | null | 101,886,912,464,544 | 268 | 222 |
import sys
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
X, Y, A, B, C = map(int, readline().split())
p = list(map(int, readline().split()))
q = list(map(int, readline().split()))
r = list(map(int, readline().split()))
p = sorted(p, reverse=True)[:X]
q = sorted(q, reverse=True)[:Y]
bag = p + q + r
bag = sorted(bag, reverse=True)
print(sum(bag[:(X + Y)]))
|
S = input()
T = input()
n = 0
for s, t in zip(S, T):
if s != t:
n += 1
print(n)
exit()
| 0 | null | 27,533,371,946,892 | 188 | 116 |
n = map(int, raw_input().split())
if (n[0] < n[1] and n[1] < n[2]):
print "Yes"
else:
print "No"
|
import sys
def ISI(): return map(int, sys.stdin.readline().rstrip().split())
n, m=ISI()
if(n==m):print("Yes")
else:print("No")
| 0 | null | 41,690,541,371,870 | 39 | 231 |
from collections import deque
n,x,y=map(int,input().split())
l=[[1]]
for i in range(1,n-1):
l.append([i-1,i+1])
l.append([n-2])
x,y=x-1,y-1
l[x].append(y)
l[y].append(x)
#print(l)
p=[0 for i in range(n)]
for j in range(n):
s=[-1 for i in range(n)]
s[j]=0
q=deque([j])
while len(q)>0:
a=q.popleft()
for i in l[a]:
if s[i]==-1:
s[i]=s[a]+1
q.append(i)
for i in s:
if i!=0:
p[i]+=1
print(*map(lambda x:x//2,p[1:]),sep='\n')
|
import sys
sys.setrecursionlimit(300000)
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI0(): return map(lambda s: int(s) - 1, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
def LMI0(): return list(map(lambda s: int(s) - 1, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')
X, K, D = MI()
if abs(X) >= K * D:
print(abs(X) - K * D)
else:
a = abs(abs(X) - (abs(X) // D) * D)
K -= (abs(X) // D)
if K % 2 == 0:
print(a)
else:
print(abs(a - D))
| 0 | null | 24,621,022,625,178 | 187 | 92 |
n = int(input())
s, t = input().split(' ')
q = ''
for i in range(n):
q += s[i]
q += t[i]
print(q)
|
a = input()
print("ABC" if a == "ARC" else "ARC")
| 0 | null | 68,128,299,495,370 | 255 | 153 |
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
N = int(readline())
A = list(map(int, readline().split()))
lcmnum = 1
def gcd(a, b):
if (a == 0):
return b
return gcd(b%a, a)
def lcm(x, y):
return (x * y) // gcd(x, y)
for a in A:
lcmnum = lcm(lcmnum, a)
ans = 0
for a in A:
a = lcmnum // a
ans += a
ans %= mod
print(ans)
if __name__ == '__main__':
solve()
|
a=map(int,raw_input().split())
a.sort()
while a[1]%a[0]!=0:
a[0],a[1]=a[1]%a[0],a[0]
print(a[0])
| 0 | null | 44,114,683,260,100 | 235 | 11 |
n = int(input())
S = set(input().split())
q = int(input())
T = set(input().split())
print(len(S & T))
|
N=int(input())
A=list(map(int, input().split()))
B=[0]*N
C=''
for i in range(N):
B[A[i]-1]=i+1
for i in range(N):
C+=str(B[i])+' '
print(C[0:-1])
| 0 | null | 90,104,432,780,662 | 22 | 299 |
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)
|
tmp=input().split()
m=int(tmp[0])
n=int(tmp[1])
while(m!=n):
if(m>n):
m=m-n
else:
n=n-m
print(m)
| 0 | null | 18,155,933,875,142 | 175 | 11 |
import sys
input = sys.stdin.readline
A = list(map(int, input().split()))
if sum(A) >= 22:
print('bust')
else:
print('win')
|
A,B,C = list(map(int,input().split()))
if A+B+C <= 21:
print("win")
else:
print("bust")
| 1 | 118,688,263,872,328 | null | 260 | 260 |
n=int(input())
s=input()
ans="No"
if n%2==0:
p=n//2
if s[:p]==s[p:]:
ans="Yes"
print(ans)
|
def abc173d_chat_in_the_circle():
n = int(input())
a = sorted(map(int, input().split()), reverse=True)
if n <= 1:
print(0)
return
val = 0
for i in range(0, n-1):
idx = (i+1) // 2
val += a[idx]
print(val)
abc173d_chat_in_the_circle()
| 0 | null | 78,051,471,898,590 | 279 | 111 |
ans=0
for i,j in zip(input(),input()):
if i!=j:ans+=1
print(ans)
|
t = list(map(int, input().split()))
m = (t[2] - t[0]) * 60 + (t[3] - t[1])
print(m - t[4])
| 0 | null | 14,259,330,055,120 | 116 | 139 |
r,c = [int(i) for i in input().split()]
a = [[0 for i in range(c+1)] for j in range(r+1)]
for i in range(r):
a[i] = [int(j) for j in input().split()]
for i in range(r):
rowSum = 0
for j in range(c):
rowSum += a[i][j]
a[i].append(rowSum)
for i in range(c+1):
columnSum = 0
for j in range(r):
columnSum += a[j][i]
a[r][i] = columnSum
for i in range(r+1):
for j in range(c):
print(a[i][j],end=' ')
print(a[i][c])
|
r, c = list(map(int,input().split()))
S = [map(int,input().split()) for i in range(r)]
col_sum = [0 for i in range(c)];
for row in S:
row = list(row)
print(' '.join(map(str,row)) + ' {}'.format(sum(row)))
col_sum = [x + y for (x,y) in zip(col_sum,row)]
print(' '.join(map(str,col_sum)) + ' {}'.format(sum(col_sum)))
| 1 | 1,373,303,678,252 | null | 59 | 59 |
x1, y1, x2, y2 = (float(x) for x in input().split())
print("{:.7f}".format(((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5))
|
import math
a,b,c,d = map(float,input().split())
print(math.sqrt(((c-a)**2) + ((d-b)**2)))
| 1 | 158,317,952,258 | null | 29 | 29 |
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))
from math import gcd
mod = int(1e9+7)
n = ii()
cnd = {}
azero = 0
bzero = 0
allzero = 0
for _ in range(n):
a,b = iim()
if a*b == 0:
if a == 0 and b != 0:
azero += 1
elif a != 0 and b == 0:
bzero += 1
else:
allzero += 1
else:
g = gcd(a,b)
a //= g
b //= g
if a<0:
a *= -1
b *= -1
before = cnd.get((a,b),False)
if b > 0:
check = cnd.get((b,-a),False)
else:
check = cnd.get((-b,a),False)
if before:
cnd[(a,b)] = [before[0]+1,before[1]]
elif check:
if b > 0:
cnd[(b,-a)] = [check[0],check[1]+1]
else:
cnd[(-b,a)] = [check[0],check[1]+1]
else:
cnd[(a,b)] = [1,0]
cnd[0] = [azero,bzero]
noreg = 0
ans = 1
#print(cnd)
for item in cnd.values():
if item[0] == 0 or item[1] == 0:
noreg += max(item[0],item[1])
else:
ans *= (2**item[0]+2**item[1]-1)
ans %= mod
print((ans*((2**noreg)%mod)-1+allzero)%mod)
|
a, b, c, d = map(int, input().split())
print('Yes') if (a-1) // d >= (c-1) // b else print('No')
| 0 | null | 25,286,154,129,430 | 146 | 164 |
N = int(input())
a = list(map(int, input().split()))
cnt = 0
for i in range(N):
if i % 2 == 0:
if a[i] % 2 == 1:
cnt += 1
print(cnt)
|
import sys
#DEBUG=True
DEBUG=False
if DEBUG:
f=open("202007_2nd/B_input.txt")
else:
f=sys.stdin
N=int(f.readline().strip())
A=list(map(int,f.readline().split()))
ans=0
for _ in range(N):
ans=ans+1 if (_+1)%2 and (A[_]%2) else ans
print(ans)
f.close()
| 1 | 7,806,638,476,060 | null | 105 | 105 |
x = int(input())
answer = 0
answer = (x//500)*1000
x = x%500
answer += (x//5)*5
print(answer)
|
a, b, c, k = (int(i) for i in input().split())
res = 1 * min(a, k) + 0 * min(b, max(0, k - a)) + -1 * min(c, max(0, k - a - b))
print(res)
| 0 | null | 32,493,802,912,450 | 185 | 148 |
a,b = map(int, input().split())
area = a * b
dis = a*2 + b*2
print(area, dis)
|
a, b = (int(x) for x in input().split())
print(a*b, 2*a + 2*b)
| 1 | 307,224,020,018 | null | 36 | 36 |
def resolve():
t = input()
print(t.replace('?','D'))
if __name__ == "__main__":
resolve()
|
s = input()
a = [str(c) for c in s]
for i in range (len(a)-1):
if a[i]=='?':
if i!=0 and a[i-1]=='P':
a[i]='D'
elif a[i+1]=='D' or a[i+1]=='?':
a[i]='P'
else:
a[i]='D'
if a[len(a)-1]=='?':
a[len(a)-1]='D'
print(*a,sep='')
| 1 | 18,448,575,641,888 | null | 140 | 140 |
import copy
import math
import time
import statistics
import math
import itertools
# a = get_int()
def get_int():
return int(input())
# a = get_string()
def get_string():
return input()
# a_list = get_int_list()
def get_int_list():
return [int(x) for x in input().split()]
# a_list = get_string_list():
def get_string_list():
return input().split()
# a, b = get_int_multi()
def get_int_multi():
return map(int, input().split())
# a_list = get_string_char_list()
def get_string_char_list():
return list(str(input()))
# print("{} {}".format(a, b))
# for num in range(0, a):
# a_list[idx]
# a_list = [0] * a
'''
while (idx < n) and ():
idx += 1
'''
def main():
start = time.time()
n = get_int()
p = get_int_list()
q = get_int_list()
a = []
for i in range(1, n+1):
a.append(i)
count = 0
count_p = 0
count_q = 0
for keiro in list(itertools.permutations(a)):
if list(keiro) == p:
count_p = count
if list(keiro) == q:
count_q = count
count += 1
print(abs(count_p - count_q))
if __name__ == '__main__':
main()
|
import itertools
n=int(input())
p=tuple(map(int, input().split()))
q=tuple(map(int, input().split()))
per=itertools.permutations(range(1, n+1), n)
for i, v in enumerate(per):
if(p==v): pi=i
if(q==v): qi=i
print(abs(pi-qi))
| 1 | 100,233,798,086,450 | null | 246 | 246 |
X=int(input())
h500=X//500
h5=(X-h500*500)//5
print(h500*1000+h5*5)
|
a=input()
print("a") if a.islower() else print("A")
| 0 | null | 27,081,741,070,010 | 185 | 119 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
import resource
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
from copy import deepcopy
sys.setrecursionlimit(1000000)
s, h = resource.getrlimit(resource.RLIMIT_STACK)
# resource.setrlimit(resource.RLIMIT_STACK, (h, h))
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, S):
def f(s, p):
if p == 0:
return s
elif p < 0:
return None
for i in range(M, 0, -1):
j = p - i
if j < 0 or j >= len(S):
continue
if S[j] == '1':
continue
s.append(i)
v = f(s, j)
if v:
return v
s.pop()
return None
m = 0
mm = 0
for c in S:
if c == '1':
mm += 1
m = max(mm, m)
else:
mm = 0
if m >= M:
return -1
ans = f([], N)
if ans:
return ' '.join(map(str, reversed(ans)))
return -1
def main():
N, M = read_int_n()
S = read_str()
print(slv(N, M, S))
if __name__ == '__main__':
main()
|
N, M = map(int, input().split())
S = input()
index = N
count = 0
history = []
while index > 0:
start = max(0, index - M)
for i, c in enumerate(S[start:index], start=start):
if c == '0':
history.append(index - i)
index = i
count += 1
break
else:
print(-1)
exit()
print(*history[::-1])
| 1 | 139,071,168,625,970 | null | 274 | 274 |
#C - Welcome to AtCoder
N,M = map(int,input().split())
S_P_list = []
for _ in range(M):
p,s = input().split()
S_P_list.append((int(p),s))
#Pに着目して安定ソート
S_P_list = sorted(S_P_list,key = lambda x:x[0],reverse = False)
#ACが存在するPの集合
AC_list = list(set([i[0] for i in S_P_list if i[1] == 'AC']))
WA = 0
AC = 0
for i in range(M):
if (S_P_list[i][0] in AC_list):
if S_P_list[i][1] == 'AC':
AC += 1
AC_list.remove(S_P_list[i][0])
else:
WA += 1
print(AC,WA)
|
n,m=map(int,input().split())
a=0
p=0
L=[0 for _ in range(n)]
for _ in range(m):
num,s = input().split()
num=int(num)-1
if not L[num] == -1:
if s == "AC":
a+=1
p+=L[num]
L[num]=-1
else:
L[num]+=1
print(a,p)
| 1 | 93,432,580,459,688 | null | 240 | 240 |
from functools import reduce
from math import gcd, sqrt,ceil
n = int(input())
a = list(map(int,input().split()))
m = 10**6
a_gcd = reduce(gcd,a)
if a_gcd != 1:
print("not coprime")
exit(0)
isset = a_gcd == 1
hurui = [i for i in range(m+1)]
for i in range(2,ceil(sqrt(m))+1):
for j in range(2,ceil(sqrt(i))+1):
if i==2:
continue
if i%j == 0:
break
else:
for k in range(i+i,m,i):
if hurui[k] != k:
continue
hurui[k] = i
continue
s = set()
p_f = True
for ai in a:
t = set()
while(ai > 1):
t.add(hurui[ai])
ai //= hurui[ai]
for ti in t:
if ti in s:
print("setwise coprime")
exit(0)
else:
s.add(ti)
print("pairwise coprime")
|
from bisect import bisect_left
def main():
N = int(input())
L = sorted(list(map(int, input().split())))
ans = 0
for ia in range(N):
for ib in range(ia+1, N-1):
a = L[ia]
b = L[ib]
ic_end = bisect_left(L, a+b, lo=ib+1)
ans += ic_end - (ib+1)
print(ans)
main()
| 0 | null | 88,293,536,006,720 | 85 | 294 |
i = 0
while True:
i += 1
n = input()
if (n == "0"): break
print("Case " + str(i) + ": " + n)
|
import sys
l = sys.stdin.readlines()
for i in range(len(l)-1):
print('Case {}: {}'.format(i+1,l[i].strip()))
| 1 | 490,161,704,928 | null | 42 | 42 |
K=int(input())
S=input()
len_S=len(S)
#逆元を用いたコンビネーション
mod = 10**9+7
def mul_mod(a,b):
return (a*b) % mod
def fact_inv(a):
ans = 1
for i in range(1,a+1):
ans = (pow(i,mod-2,mod) * ans) % mod
return ans
fact_list = [1]
for i in range(1,len_S+K):
fact_list.append(mul_mod(fact_list[-1],i))
fact_list_inv = [1]
for i in range(1,len_S+K):
fact_list_inv .append((pow(i,mod-2,mod) * fact_list_inv[-1]) % mod)
def comb_inv_mod(a,b):
tmp = (fact_list[a]*fact_list_inv[b]) % mod
return (tmp*fact_list_inv[a-b]) % mod
ans = 0
for i in range(len_S-1,len_S+K): #Snの位置
#print(i)
#ans += comb_inv(len_S+K-(len_S+K-i-1)-1,N-1)*pow(25,(K-(len_S+K-i-1)),mod)*pow(26,len_S+K-i-1,mod)
A = comb_inv_mod(i,len_S-1)*pow(25,i-len_S+1,mod) % mod
A = A*pow(26,len_S+K-i-1,mod) % mod
ans += A
#print(ans)
ans = ans % mod
print(ans)
|
k = int(input())
S = input()
n = len(S)
mod = 10**9+7
facs = [1] * (n+k)
# invs = [1] * (n+k)
nfac = 1
for i in range(1, n+k):
nfac = nfac * i % mod
facs[i] = nfac
# invs[i] = pow(facs[i], mod-2, mod)
invn1 = pow(facs[n-1], mod-2, mod)
ans = 0
for i in range(k+1):
left = facs[i+n-1] * pow(facs[i], mod-2, mod) * invn1 % mod
left = left * pow(25, i, mod) % mod
ans += left * pow(26, k-i, mod) % mod
ans %= mod
print(ans)
| 1 | 12,666,331,896,620 | null | 124 | 124 |
a = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
for _ in range(n):
d = int(input())
for i in range(3):
if d in a[i]:
a[i][a[i].index(d)] = -1
for i in range(3):
if sum(a[i])==-3:
print('Yes')
exit()
s = 0
for j in range(3):
s += a[j][i]
if s==-3:
print('Yes')
exit()
if a[0][0]+a[1][1]+a[2][2]==-3:
print('Yes')
exit()
if a[0][2]+a[1][1]+a[2][0]==-3:
print('Yes')
exit()
print('No')
|
A = [[int(x) for x in input().split()] for _ in range(3)]
N = int(input())
b = [int(input()) for _ in range(N)]
Bingo = [[0, 0, 0] for _ in range(3)]
for i in range(3):
for j in range(3):
for l in range(N):
if(A[i][j] == b[l]):
Bingo[i][j] = 1
bingo = 0
for i in range(3):
if(Bingo[i][0]+Bingo[i][1]+Bingo[i][2])==3:
bingo += 1
elif(Bingo[0][i]+Bingo[1][i]+Bingo[2][i])==3:
bingo += 1
if(Bingo[0][0]+Bingo[1][1]+Bingo[2][2])==3:
bingo += 1
elif(Bingo[0][2]+Bingo[1][1]+Bingo[2][0])==3:
bingo += 1
if(bingo!=0):
print('Yes')
else:
print('No')
| 1 | 59,590,683,380,650 | null | 207 | 207 |
x, y, z = map(int, input().split())
createNum = 0
createTime = 0
loopCnt = x//y
createNum = y*loopCnt
createTime = z*loopCnt
remain = x%y
if remain != 0:
createTime += z
print(createTime)
|
n, x, t = map(int, input().split())
if n % x == 0:
res = int((n / x) * t)
else:
res = int(((n // x) + 1) * t)
print(res)
| 1 | 4,281,968,780,990 | null | 86 | 86 |
# -*- coding: utf-8 -*-
# スペース区切りの整数の入力
S, T = input().split()
U = T+S
print(U)
|
import sys
def input():
return sys.stdin.buffer.readline()[:-1]
n = int(input())
d = [list(map(int, input().split())) for _ in range(n)]
ans1 = max(x[0] + x[1] for x in d) - min(x[0] + x[1] for x in d)
ans2 = max(x[0] - x[1] for x in d) - min(x[0] - x[1] for x in d)
print(max(ans1, ans2))
| 0 | null | 53,221,725,411,156 | 248 | 80 |
cnt = 0
def merge(A,left,mid,right):
'''n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(0,n1):
L.append(A[left+i])
for i in range(0,n2):
R.append(A[mid+i])
L.append(1000000001)
R.append(1000000001)
'''
L = A[left:mid]+[1000000001]
R = A[mid:right]+[1000000001]
i = 0
j = 0
global cnt
for k in range(left,right):
cnt += 1
if L[i] <= R[j]:
A[k]=L[i]
i += 1
else:
A[k] = R[j]
j += 1
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)
if __name__ == '__main__':
n = (int)(input())
a = list(map(int,input().split()))
mergeSort(a,0,n)
print(*a)
print(cnt)
|
import sys
input = sys.stdin.readline
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N=I()
P=LI()
Q=LI()
import itertools
cnt=0
p=0
q=0
for ite in itertools.permutations(range(1,N+1)):
if P==list(ite):
p=cnt
if Q==list(ite):
q=cnt
cnt+=1
print(abs(p-q))
main()
| 0 | null | 50,476,513,337,088 | 26 | 246 |
N, M = map(int, raw_input().split())
matrix = []
array = []
for n in range(N):
tmp = map(int, raw_input().split())
if len(tmp) > M:
print 'error'
matrix.append(tmp)
for m in range(M):
tmp = input()
array.append(tmp)
for n in range(N):
multi = 0
for m in range(M):
multi += matrix[n][m] * array[m]
print multi
|
S = input()
T = input()
t_len = len(T)-1
if S == T[:t_len]:
print("Yes")
else:
print("No")
| 0 | null | 11,239,294,420,640 | 56 | 147 |
K = int(input())
seven = [0]*K
seven[0] = 7%K
for i in range(1,K):
seven[i] = (10*seven[i-1]+7)%K
for i in range(K):
if seven[i] == 0:
print(i+1)
exit()
print(-1)
|
x = input()
if x == "1": print(0)
else: print(1)
| 0 | null | 4,505,687,256,288 | 97 | 76 |
import sys
sys.setrecursionlimit(10**9)
N, u, v = map(int, input().split())
u, v = u-1, v-1
edge = [[] for _ in range(N)]
for i in range(N-1):
a, b = map(int, input().split())
a, b = a-1, b-1
edge[a].append(b)
edge[b].append(a)
taka = [0] * N
aoki = [0] * N
def dfs(v, pre, cost, i):
for e in edge[v]:
if e == pre:
continue
cost = dfs(e, v, cost, i+1)
cost[v] = i
return cost
taka = dfs(u, -1, [0] * N, 0)
aoki = dfs(v, -1, [0] * N, 0)
m = 0
for i in range(N):
if taka[i] < aoki[i]:
m = max(m, aoki[i])
print(m-1)
|
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 7 01:25:53 2020
@author: saito
"""
# %% import phase
#from collections import deque
# %% define phase
# %% input phase
K = int(input())
# %% process phase
r = 0
answer = -1
h = []
for cnt in range(K):
r = (10*r+7) % K
if r == 0:
answer = cnt + 1
break
# %%output phase
print(answer)
| 0 | null | 61,933,791,594,830 | 259 | 97 |
def dts():
return list(map(int,input().split()))
d,t,s=dts()
if d>t*s:
print("No")
else:
print("Yes")
|
data=list(map(int,input().split()))
if data[0]/data[1]<=data[2]:
print('Yes')
else:
print('No')
| 1 | 3,557,676,536,590 | null | 81 | 81 |
first_line = raw_input().split(" ")
n = int(first_line[0])
m = int(first_line[1])
l = int(first_line[2])
array_a = []
array_b = []
for i in xrange(n):
line = map(int, raw_input().split(" "))
array_a.append(line)
for i in xrange(m):
line = map(int, raw_input().split(" "))
array_b.append(line)
# print array_a
# print array_b
array_c = []
for i in xrange(n):
line = []
for j in xrange(l):
sum = 0
for k in xrange(m):
sum += array_a[i][k] * array_b[k][j]
line.append(sum)
array_c.append(line)
for i in xrange(n):
print " ".join(map(str, array_c[i]))
|
n, m, l = map(int, input().split())
mat_a = [list(map(int, input().split())) for _ in range(n)]
mat_b = [list(map(int, input().split())) for _ in range(m)]
for i in range(n):
row = []
for j in range(l):
tmp = 0
for k in range(m):
tmp += mat_a[i][k]*mat_b[k][j]
row.append(tmp)
print(*row)
| 1 | 1,431,061,680,256 | null | 60 | 60 |
# 163 B
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
print(N-sum(A)) if sum(A) <= N else print(-1)
|
x=int(input())
def divisors(n):
lower_divisors=[]
upper_divisors=[]
i=1
while i*i<=n:
if n%i==0:
lower_divisors.append(i)
if i!=n//i:
upper_divisors.append(n//i)
i+=1
return lower_divisors
max_lower_div=max(divisors(x))
print((max_lower_div-1)+(x//max_lower_div-1))
| 0 | null | 96,800,615,345,120 | 168 | 288 |
k=int(input())
from math import gcd
ans=0
for i in range(1,k+1):
for j in range(1,k+1):
temp=gcd(i,j)
for m in range(1,k+1):
ans=ans+gcd(temp,m)
print(ans)
|
N,K = map(int,input().split())
ls = list(map(int,input().split()))
ls.sort(reverse=True)
if N <= K:
print(0)
else:
print(sum(ls[K:N+1]))
| 0 | null | 57,357,986,029,502 | 174 | 227 |
X = int(input())
a = X // 500
X -= a * 500
b = X // 5
print(a * 1000 + b * 5)
|
x = int(input())
ans = 0
div_500, x = divmod(x, 500)
div_5, x = divmod(x, 5)
ans = div_500 * 1000 + div_5 * 5
print(ans)
| 1 | 42,757,336,640,932 | null | 185 | 185 |
i = int(input())
print((i-1)//2)
|
a = int(input())
print(a//2-(a%2==0))
| 1 | 153,217,311,794,118 | null | 283 | 283 |
N = int(input())
aaa = list(map(int, input().split()))
i = 1
ans = 0
for a in aaa:
if a == i:
i += 1
else:
ans += 1
print(ans if ans != N else -1)
|
N = int(input())
A = list(map(int, input().split()))
cnt = 0
idx = 1
for i, a in enumerate(A):
if idx == a:
idx += 1
else:
cnt += 1
if cnt == N:
print(-1)
else:
print(cnt)
| 1 | 114,774,832,399,840 | null | 257 | 257 |
N, M = map(int, input().split())
Ev = M * (M - 1) // 2
Od = N * (N - 1) // 2
print(Ev + Od)
|
import itertools
N, M = map(int, input().split())
print( len([i for i in list(itertools.combinations(([2]*N)+([3]*M), 2)) if sum(i) % 2 == 0]) )
| 1 | 45,771,544,108,900 | null | 189 | 189 |
from collections import defaultdict
import sys
from math import gcd
count = defaultdict(int)
N = int(sys.stdin.readline())
zeros = 0
for i in range(N):
A, B = [int(x) for x in input().split()]
if A == B == 0:
zeros += 1
continue
if A == 0:
angle = (0, 1)
elif B == 0:
angle = (1, 0)
else:
sgn = A // abs(A)
g = gcd(A, B)
angle = (A // sgn // g, B // sgn // g)
count[angle] += 1
# print(count)
pairs = {}
solos = []
for k1 in count:
if k1 in pairs:
continue
if k1 == (0, 1):
if (1, 0) in count:
pairs[(1, 0)] = k1
else:
solos.append(k1)
continue
A, B = k1
if B:
sgn = -B // abs(B)
k2 = (-B // sgn, A // sgn)
else:
k2 = (0, 1)
if k2 in count:
pairs[k2] = k1
else:
solos.append(k1)
#print(pairs, solos)
P = 1000000007
def pow2(n):
# if n < 30:
# return 2 ** n
# p = pow2(n // 2)
# pp = (p * p) % P
# if n % 2 == 1:
# return (2 * pp) % P
# else:
# return pp
return pow(2, n, P)
result = 1
for p in pairs:
# print("pair", p, count[p], pairs[p], count[pairs[p]])
n = count[p]
m = count[pairs[p]]
result = result * ((pow2(n) - 1) + (pow2(m) - 1) + 1) % P
for k in solos:
# print("solo", k, count[k])
result = result * pow2(count[k]) % P
print((result + zeros - 1) % P)
|
def GCD(a, b):
b %= a
return b if a%b == 0 else GCD(b, a)
while True:
try:
a, b = list(map(float, input().split()))
except EOFError:
break
if a >= b:
a, b = b, a
gcd = GCD(a, b) if b%a != 0 else a
print("{0} {1}".format(int(gcd), int(a*b/gcd)))
| 0 | null | 10,578,723,065,988 | 146 | 5 |
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 i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10**9)
INF = 10**9
mod = 10**9+7
N = i()
table = [[0]*9 for _ in range(9)]
for i in range(N):
s = str(i+1)
a,b = int(s[0]),int(s[-1])
if b == 0:
continue
table[a-1][b-1] += 1
ans = 0
for i in range(9):
for j in range(9):
ans += table[i][j]*table[j][i]
print(ans)
|
import sys
import math
def str_input():
S = raw_input()
if S[len(S)-1] == "\r":
return S[:len(S)-1]
return S
W = str_input()
cnt = 0
while 1:
S = str_input()
if (S == "END_OF_TEXT"):
break
S = S.lower().split()
cnt += S.count(W)
print cnt
| 0 | null | 44,230,187,274,988 | 234 | 65 |
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
h,w,k=nii()
c=[list(input()) for i in range(h)]
b_cnt=0
for i in c:
b_cnt+=i.count('#')
ans=0
for i in range(2**h):
for j in range(2**w):
h_use=[]
for ii in range(h):
if (i>>ii)&1:
h_use.append(ii)
w_use=[]
for jj in range(w):
if (j>>jj)&1:
w_use.append(jj)
t_cnt=0
for s in h_use:
t_cnt+=c[s].count('#')
for s in w_use:
for t in range(h):
if c[t][s]=='#':
t_cnt+=1
for s in h_use:
for t in w_use:
if c[s][t]=='#':
t_cnt-=1
if b_cnt-t_cnt==k:
ans+=1
print(ans)
|
A = input()
B = input()
KAI = "123"
KAI1 = KAI.replace(A,"")
KAI2 = KAI1.replace(B,"")
print(KAI2)
| 0 | null | 59,623,377,886,006 | 110 | 254 |
def main():
N,M=map(int,input().split())
S=input()
c,l=N,[]
while c>0:
for i in range(M,0,-1):
if i<=c and S[c-i]=='0':
l+=[i]
c-=i
break
else:
l=[-1]
break
print(*l[::-1])
main()
|
import sys
#+++++
def main():
n, m = map(int, input().split())
s=input()
s=s[::-1]
#arch=[len(s)+100]*len(s)
pos=0
ret=[]
while pos < len(s)-1:
for mi in range(m,0,-1):
if pos+mi >= len(s):
pass
elif s[pos+mi]=='0':
pos += mi
ret.append(mi)
#print(pos)
break
else:
pass
else:
return -1
r=ret[::-1]
print(*r)
'''
def main2():
n, m = map(int, input().split())
s = input()
tt=[-1]*len(s)
t_parent=[-1]*len(s)
rs=s[::-1]
open_list=[0]
max_dist = 0
while True#len(open_list) > 0:
st, parent, count = open_list.pop()
for i in range(m, 0, -1):
aa = st + i
if aa > n+1:
pass
#gmマス
if rs[aa] == 1:
continue
#アクセス済み
if tt[aa] > 0:
break
tt[aa] = count+1
t_parent[aa] = st
open_list.append(aa, st, count+1)
print(1)
'''
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
if __name__ == "__main__":
if sys.platform =='ios':
sys.stdin=open('inputFile.txt')
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| 1 | 139,172,844,482,580 | null | 274 | 274 |
def main():
r = int(input())
print(r * r)
if __name__ == '__main__':
main()
|
r = int(input())
S = int(r**2)
print(S)
| 1 | 145,504,331,181,028 | null | 278 | 278 |
import math
radius=int(input())
print(2*math.pi*radius)
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys
WHITE = 0
GRAY = 1
BLACK = 2
def dbg_record(records):
for index, record in enumerate(records):
print("???????????????: %d" % index)
if isinstance(record, dict):
print("??\??????: %d" % record.get("visit", -1))
print("?????????: %d" % record.get("leave", -1))
else:
print("?????????")
print("")
def dfs(matrix):
def internal_dfs(node_id, current_time):
if state[node_id] == WHITE:
# ?¨??????????
state[node_id] = GRAY
stack.append(node_id)
records[node_id] = {"visit": current_time} # ?¨??????????????¨????
# ?¬?????¨????????????¨?????§????????????????????¢???
next_id = None
for index in range(len(matrix)):
if matrix[node_id][index] == 1 and state[index] == WHITE:
next_id = index
break
if next_id is not None:
return internal_dfs(next_id, current_time + 1)
elif 0 < len(stack):
# ?¬?????¨????????????¨?????§?????????????????????????????????????????°?????????
return internal_dfs(stack.pop(), current_time + 1)
elif state[node_id] == GRAY:
# ????????????
# ?¬?????¨????????????¨?????§????????????????????¢???
next_id = None
for index in range(len(matrix)):
if matrix[node_id][index] == 1 and state[index] == WHITE:
next_id = index
break
if next_id is not None:
stack.append(node_id)
return internal_dfs(next_id, current_time)
elif 0 < len(stack):
# ?¬?????¨????????????¨?????§?????????????????????????????????????????°?????????
state[node_id] = BLACK
records[node_id]["leave"] = current_time # ????????????????¨????
return internal_dfs(stack.pop(), current_time + 1)
else: # ??????????§????????????£???????????¨??? (node_id should be 0)
state[node_id] = BLACK
records[node_id]["leave"] = current_time
return current_time
elif state[node_id] == BLACK:
print("Black!!")
state = [WHITE] * len(matrix) # White, Gray, Black
records = [None] * len(matrix) # Save time when the node is processed
stack = []
current_time = 0
while True:
node_id = None
for index, record in enumerate(records):
if record is None:
node_id = index
break
if node_id is None:
break
else:
current_time = internal_dfs(node_id, current_time + 1)
return records
if __name__ == "__main__":
# ??????????????????
# lines = [
# "6",
# "1 2 2 3",
# "2 2 3 4",
# "3 1 5",
# "4 1 6",
# "5 1 6",
# "6 0",
# ]
lines = sys.stdin.readlines()
# Create n * n matrix
dimension = int(lines[0])
matrix = []
for x in range(dimension):
matrix.append([0] * dimension)
# Set edge info
for index, line in enumerate(lines[1:]):
for edge in [int(x) for x in line.strip().split(" ")[2:]]:
matrix[index][edge - 1] = 1
records = dfs(matrix)
for index, line in enumerate(records):
if line is not None:
print("%d %d %d" % (index + 1, line.get("visit", -1), line.get("leave", -1)))
else:
print("%d None None" % (index + 1))
| 0 | null | 15,755,913,361,828 | 167 | 8 |
k = int(input())
s = str(input())
if len(s) > k:
print(s[:k], end='')
print("...")
else:
print(s)
|
a,n=0,int(input())
for i in range(2,int(n**0.5+1)):
x=0
while(n%i==0):n//=i;x+=1
j=1
while(x>=j):a+=1;x-=j;j+=1
print(a+(n>1))
| 0 | null | 18,268,556,103,080 | 143 | 136 |
# -*- coding: utf-8 -*-
S = [0] * 13
H = [0] * 13
C = [0] * 13
D = [0] * 13
n = int(raw_input())
for i in xrange(n):
symbol, num = map(str, raw_input().split())
if symbol == 'S':
S[int(num)-1] = 1
elif symbol == 'H':
H[int(num)-1] = 1
elif symbol == 'C':
C[int(num)-1] = 1
else:
D[int(num)-1] = 1
cards = [S, H, C, D]
marks = ['S', 'H', 'C', 'D']
for card, mark in zip(cards, marks):
for index, num in enumerate(card):
if num < 1:
print mark, index+1
|
cards_num = int(input())
cards = []
missing_cards = []
for i in range(cards_num):
cards.append(input())
for i in range(1, 14):
if "S {0}".format(i) not in cards:
missing_cards.append("S {0}".format(i))
for i in range(1, 14):
if "H {0}".format(i) not in cards:
missing_cards.append("H {0}".format(i))
for i in range(1, 14):
if "C {0}".format(i) not in cards:
missing_cards.append("C {0}".format(i))
for i in range(1, 14):
if "D {0}".format(i) not in cards:
missing_cards.append("D {0}".format(i))
for i in missing_cards:
print(i)
| 1 | 1,022,873,830,418 | null | 54 | 54 |
n = int(input())
d = {'AC': 0, 'WA': 0, 'TLE': 0, 'RE': 0}
for i in range(n):
st = input()
d[st] += 1
for k, v in d.items():
print(k, 'x', v)
|
N = int(input())
ac = 0
wa = 0
tle = 0
re = 0
for i in range(N):
s = input()
if s == "AC":
ac += 1
elif s == "WA":
wa += 1
elif s == "TLE":
tle += 1
else:
re += 1
print("AC x", ac)
print("WA x", wa)
print("TLE x", tle)
print("RE x", re)
| 1 | 8,647,303,364,590 | null | 109 | 109 |
N, M = map(int,input().split())
li = []
for _ in range(M):
p, S = input().split()
li.append([int(p), S])
ac = [0] * N
wa = [0] * N
c1 = 0
c2 = 0
for i in range(M):
j = li[i][0] - 1
if li[i][1] == "WA":
wa[j] += 1
if ac[j] == 0 and li[i][1] == "AC":
ac[j] = 1
c1 += 1
c2 += wa[j]
print(c1, c2)
|
n,m = map(int,input().split())
dic = {}
ac = 0
wa = 0
for _ in range(m):
p,s = map(str,input().split())
p = int(p)
if p not in dic:
if s =='AC':
ac += 1
dic[p] = s
else:
dic[p] = 1
elif dic[p]=='AC':
continue
else:
if s =='AC':
ac += 1
wa +=dic[p]
dic[p] = s
else:
dic[p] += 1
print(str(ac) + ' ' + str(wa))
| 1 | 93,732,555,875,436 | null | 240 | 240 |
import sys
from fractions import gcd
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def lcm(x, y):
return x * y // gcd(x, y)
def main():
N, M, *A = map(int, read().split())
B = A[::]
while not any(b % 2 for b in B):
B = [b // 2 for b in B]
if not all(b % 2 for b in B):
print(0)
return
semi_lcm = 1
for a in A:
semi_lcm = lcm(semi_lcm, a // 2)
print((M // semi_lcm + 1) // 2)
return
if __name__ == '__main__':
main()
|
input_data = list(map(int,input().split()))
time = input_data[0] / input_data[2]
if time > input_data[1]:
print('No')
else:
print('Yes')
| 0 | null | 52,497,940,179,350 | 247 | 81 |
import collections
import sys
readline = sys.stdin.readline
def main():
n = int(readline().rstrip())
s = readline().rstrip()
cnt = s.count("R") * s.count("G") * s.count("B")
for i in range(n - 2):
for k in range(1, n):
if i + 2 * k >= n:
break
if (s[i] != s[i + k]) and (s[i + k] != s[i + 2 * k])and (s[i] != s[i + 2 * k]):
cnt -= 1
print(cnt)
if __name__ == '__main__':
main()
|
s = input()
t = input()
for i in range(len(s)):
if not s[i] == t[i]:
print("No")
exit()
print("Yes")
| 0 | null | 28,846,295,895,108 | 175 | 147 |
#coding: utf-8
s = input()
p = input()
for i in range(len(s)):
s = s[1:] + s[0:1]
if s.find(p) != -1:
print("Yes")
exit()
print("No")
|
s = input() * 2
p = input()
print("Yes" if s.find(p, 0, len(s) )>= 0 else "No")
| 1 | 1,753,031,528,160 | null | 64 | 64 |
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="")
|
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
in_str = sys.stdin.readline().strip()
q = int(sys.stdin.readline())
for i in range(q):
command = sys.stdin.readline().split()
pos_a = int(command[1])
pos_b = int(command[2])
if command[0] == 'print':
print(in_str[pos_a:pos_b+1])
elif command[0] == 'reverse':
if pos_a == 0: to_pos = None
else: to_pos = pos_a - 1
in_str = in_str[:pos_a] + in_str[pos_b:to_pos:-1] + in_str[pos_b+1:]
elif command[0] == 'replace':
in_str = in_str[:pos_a] + command[3] + in_str[pos_b+1:]
else:
raise ValueError
| 0 | null | 29,767,246,962,432 | 204 | 68 |
# Problem D - String Equivalence
from collections import deque
# input
N = int(input())
char_list = [chr(i) for i in range(97, 97+26)]
def dfs(a_list, a_len):
if a_len==N:
print("".join(a_list))
return
else:
biggest = 97
count = len(set(a_list)) # N<=10だからさほど時間はかからない
for c in range(biggest, biggest + count + 1):
ch = chr(c)
a_list.append(ch)
dfs(a_list, a_len+1)
a_list.pop()
# initialization
a_nums = deque([])
# dfs search
dfs(a_nums, 0)
|
n,a,b = map(int,input().split())
if (b-a)%2==0:
print((b-a)//2)
else:
m = min(b-1,n-a)
M = min(a-1,n-b)+(b-a-1)//2+1
print(min(m,M))
| 0 | null | 80,473,324,822,694 | 198 | 253 |
n = int(input())
a = list(map(int, input().split()))
m = max(a)
ans = [0] * n
z = 1
while True:
b = False
for i in range(n):
if a[i] & z:
b = not b
for i in range(n):
if not b:
if a[i] & z:
ans[i] |= z
else:
if not (a[i] & z):
ans[i] |= z
z <<= 1
if z > m:
break
print(' '.join([str(x) for x in ans]))
|
N = int(input())
A = list(map(int,input().split()))
xor = 0
for i in range(N):
xor ^= A[i]
anslis = []
for i in range(N):
answer = xor^A[i]
anslis.append(answer)
print(' '.join(map(str,anslis)))
| 1 | 12,474,509,241,910 | null | 123 | 123 |
A, B = [x for x in input().split(" ")]
print(int(A) * int(float(B) * 100 + 0.5) // 100)
|
A,B = input().split()
A = int(A)
B1, B2 = B.split('.')
B = int(B1)*10**len(B2)+int(B2)
print((A*B)//10**len(B2))
| 1 | 16,568,563,633,376 | null | 135 | 135 |
import itertools
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
INF=10**20
def main():
N,M,Q=mi()
X = []
for i in range(Q):
a,b,c,d = mi()
X.append((a,b,c,d))
ans = 0
num_list = list(range(1,M+1))
for _nums in itertools.combinations_with_replacement(num_list, N):
nums = list(_nums)
D = 0
for j in range(Q):
a,b,c,d = X[j]
if nums[b-1] - nums[a-1] == c:
D += d
ans = max(ans,D)
print(ans)
if __name__ == "__main__":
main()
|
H, W, K = map(int, input().split())
S = [input() for _ in range(H)]
# chocoのj列目の0(white)の個数を数える
def count_col_whites(choco, j):
res = 0
for c in choco:
if c[j]=="1":
res += 1
return res
# チョコレートをヨコ方向にカットする
def cut_chocolate(i):
if i == 0:
return [S]
else:
res = []
pre = 0
tmp = 0
while i > 0:
tmp += 1
if i%2 == 1:
res.append(S[pre:tmp])
pre = tmp
i //= 2
res.append(S[pre:len(S)])
return res
def is_less_than_or_equal_to_K(cut):
for c in cut:
for j in range(W):
tmp = 0
for i in range(len(c)):
if c[i][j] == "1":
tmp += 1
if tmp > K:
return False
return True
ans = 10**10
for i in range(2**(H-1)):
# 横方向にカットしたときのかたまりをcutに格納
cut = cut_chocolate(i)
tmp_ans = len(cut)-1
# 縦方向にみていって、1列中の白チョコの個数がK個より大きければそもそも無理
if not is_less_than_or_equal_to_K(cut):
continue
# 縦方向にみていって、白チョコがK個以下のかたまりになるようカットする
current_white_nums = [0 for _ in range(len(cut))]
for j in range(W):
for i in range(len(cut)):
white_num = count_col_whites(cut[i], j)
if white_num + current_white_nums[i] <= K:
current_white_nums[i] += white_num
else:
current_white_nums = [count_col_whites(cut[_], j) for _ in range(len(cut))]
tmp_ans += 1
break
ans = min(ans, tmp_ans)
print(ans)
| 0 | null | 37,988,973,545,380 | 160 | 193 |
n = int(input())
f = list(map(int,input().split()))
f.sort(reverse = True)
ans = 0
if n%2 == 0:
for i in range(n//2):
ans += f[i] * 2
ans -= f[0]
else:
for i in range(n//2):
ans += f[i] * 2
ans += f[n//2]-f[0]
print(ans)
|
N = int(input())
A = list(map(int,input().split()))
A = sorted(A,reverse=True)
if N <= 3:
ans = sum(A[:-1])
elif N % 2 == 0:
ans = A[0] + sum(A[1:(N-2)//2+1])*2
elif N % 2 == 1:
ans = A[0] + sum(A[1:(N-2)//2+1])*2 + A[1+(N-2)//2]
print(ans)
| 1 | 9,190,887,562,858 | null | 111 | 111 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.