code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
import sys
sys.setrecursionlimit(10 ** 9)
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rank = [0]*(n+1)
def find(self, x):#親となる要素を探索
if self.root[x] < 0:
return x
else:
self.root[x] = self.find(self.root[x])#再帰
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:#深い木に連結
self.root[x] += self.root[y]
self.root[y] = x#yの親をxとする
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def issame(self, x, y):#x, yが同じ集合か判定
return self.find(x) == self.find(y)
def count(self, x):#要素の個数
return (-1)*self.root[self.find(x)]
n, m = map(int, input().split())
uf = UnionFind(n)
for i in range(m):
a, b = map(int, input().split())
uf.unite(a-1, b-1)
ans = set()
for i in range(n):
ans.add(uf.find(i))
print(len(ans)-1)
|
#self.r[x] means root of "x" if "x" isn't root, else number of elements
class UnionFind():
def __init__(self, n):
self.r = [-1 for i in range(n)]
#use in add-method
def root(self, x):
if self.r[x] < 0: #"x" is root
return x
self.r[x] = self.root(self.r[x])
return self.r[x]
#add new path
def add(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return False
self.r[x] += self.r[y]
self.r[y] = x
return True
n, m = map(int, input().split())
UF = UnionFind(n)
for i in range(m):
a, b = map(lambda x: int(x)-1, input().split())
UF.add(a, b)
ans = 0
for i in UF.r:
if i < 0:
ans += 1
print(ans-1)
| 1 | 2,256,877,194,718 | null | 70 | 70 |
a = int(input())
b, c = map(int, input().split())
ans = int(c/a) * a
if b<=ans<=c:
print('OK')
else:
print('NG')
|
from math import factorial
n, m = map(int, input().split())
ans = n*(n-1)//2 + m*(m-1)//2
print(ans)
| 0 | null | 35,977,037,421,820 | 158 | 189 |
N=int(input())
ans=0
speech_l=[[] for _ in range(N)]
for i in range(N):
tmp=int(input())
for j in range(tmp):
speech_l[i].append(list(map(int,input().split())))
for i in range(2**N):
sw=0
l=[1]*N
tmp=N
for j in range(N):
if ((i >> j)&1):
tmp-=1
l[j]=0
for j in range(N):
if l[j] == 1:
for k in speech_l[j]:
if l[k[0]-1] != k[1]:
sw=1
if sw==0:
ans=max(ans,tmp)
print(ans)
|
from sys import stdin,stdout
def INPUT():return list(int(i) for i in stdin.readline().split())
import math
def inp():return stdin.readline()
def out(x):return stdout.write(x)
import math as M
MOD=10**9+7
import sys
#####################################
n=int(input())
A=list(input())
X=["0"]
for i in range(n):
if X[-1]!=A[i]:
X.append(A[i])
X.pop(0)
print(len(X))
| 0 | null | 145,359,908,826,312 | 262 | 293 |
K = int(input())
s = input()
n=len(s)
def find_power(n,mod=10**9+7):
powlist=[0]*(n+1)
powlist[0]=1
powlist[1]=1
for i in range(2,n+1):
powlist[i]=powlist[i-1]*i%(mod)
return powlist
def find_inv_power(n,mod=10**9+7):
powlist=find_power(n)
check=powlist[-1]
first=1
uselist=[0]*(n+1)
secondlist=[0]*30
secondlist[0]=check
secondlist[1]=check**2
for i in range(28):
secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)
a=format(10**9+5,"b")
for j in range(30):
if a[29-j]=="1":
first=(first*secondlist[j])%(10**9+7)
uselist[n]=first
for i in range(n,0,-1):
uselist[i-1]=(uselist[i]*i)%(10**9+7)
return uselist
mod = 10**9+7
NUM = (2*10**6)+100
p_lis=find_power(NUM,mod)
ip_lis=find_inv_power(NUM,mod)
def comb(n,r,mod=10**9+7):
if n<r:
return 0
elif n>=r:
return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)
ans=0
for k in range(K+1):
ans+=(comb(n-1+K-k,n-1)* pow(25,K-k,mod)* pow(26,k,mod))
print(ans%mod)
|
mod = 10**9 + 7
K = int(input())
S = input()
n = len(S)
tmp = pow(26, K, mod)
waru = pow(26, -1, mod)
ans = tmp
for i in range(1, K+1):
tmp = (tmp * 25 * waru)%mod
tmp = (tmp * (i + n -1) * pow(i, -1, mod))%mod
ans = (ans+tmp)%mod
print(ans%mod)
| 1 | 12,785,082,970,630 | null | 124 | 124 |
S = list(input())
countA = 0
countB = 0
for i in range(0, len(S)):
if S[i] == "A":
countA += 1
elif S[i] == "B":
countB += 1
if countA == 3 or countB == 3:
print("No")
else:
print("Yes")
|
from collections import defaultdict, deque
import sys, heapq, bisect, math, itertools, string, queue, copy, time
from fractions import gcd
import numpy as np
sys.setrecursionlimit(10**8)
INF = float('inf')
MOD = 10**9+7
EPS = 10**-7
s = input()
if s == 'AAA' or s == 'BBB':
ans = 'No'
else:
ans = 'Yes'
print(ans)
| 1 | 54,939,720,017,468 | null | 201 | 201 |
try:
while True:
N=list(str(input()))
M=int(input())
for i in range(M):
H=int(input())
for j in range(H):
A=N[0]
N.remove(A)
N.append(A)
j+=1
for k in range(len(N)):
print(N[k],end='')
print()
except EOFError:
pass
|
while True:
n = str(input())
if n == "-":
break
m = int(input())
for i in range(m):
h=int(input())
n = n[h:len(n)] + n[0:h]
print(n)
| 1 | 1,910,180,181,488 | null | 66 | 66 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
from scipy.sparse import csr_matrix
INF = 10**12
N, M, L = map(int, readline().split())
ABCQST = np.array(read().split(), dtype=np.int64)
ABC = ABCQST[:3*M]
A = ABC[::3]; B = ABC[1::3]; C = ABC[2::3]
Q = ABCQST[3*M]
ST = ABCQST[3*M + 1:]
S = ST[::2]; T = ST[1::2]
graph = csr_matrix((C, (A, B)), (N + 1, N + 1))
d = floyd_warshall(graph, directed=False)
d[d <= L] = 1
d[d > L] = INF
d = floyd_warshall(d, directed=False).astype(int)
d[d == INF] = 0
d -= 1
print('\n'.join(d.astype(str)[S, T]))
|
N,M,L = map(int,input().split())
ABC = [list(map(int,input().split())) for _ in range(M)]
Q = int(input())
class WarshallFloyd:
def __init__(self,n):
self.n = n
self.inf = 100000000000000
self.d = [[self.inf for _ in range(n)] for _ in range(n)]
for i in range(self.n):
self.d[i][i] = 0
def register(self,v1,v2,l,multiple=True):
self.d[v1][v2] = l
if multiple:
self.d[v2][v1] = l
def solve(self):
for i in range(self.n):
for j in range(self.n):
for k in range(self.n):
self.d[j][k] = min(self.d[j][k],self.d[j][i]+self.d[i][k])
return self.d
W = WarshallFloyd(N)
for a,b,c in ABC:
W.register(a-1,b-1,c)
D = W.solve()
WL = WarshallFloyd(N)
for i in range(N):
for j in range(N):
if D[i][j] <= L and i != j:
WL.register(i,j,1)
DL = WL.solve()
ST = [list(map(int,input().split())) for _ in range(Q)]
for i in range(Q):
s,t = ST[i]
transition = DL[s-1][t-1]
if transition == 100000000000000:
print(-1)
else:
print(transition-1)
| 1 | 173,224,257,861,818 | null | 295 | 295 |
a, b = map(int, input().split())
for n in range(1500):
xa = int(n * 0.08)
xb = int(n * 0.1)
if a == xa and b == xb:
print(n)
exit()
print(-1)
|
a = list(map(int,input().split()))
p = a[0]
q = a[1]
for i in range(2000):
if int(i*0.08) == p and int(i*0.1) == q:
print(i)
break
if i == 1999:
print(-1)
| 1 | 56,230,602,194,170 | null | 203 | 203 |
n = int(input())
AB = [[] * 2 for _ in range(n - 1)]
graph = [[] for _ in range(n + 1)]
for i in range(n - 1):
a, b = map(int, input().split())
AB[i].append(a)
AB[i].append(b)
graph[a].append(b)
graph[b].append(a)
root = 1
parent = [0] * (n + 1)
order = []
stack = [root] # 根を stack に入れる
while stack:
x = stack.pop()
order.append(x)
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
color = [-1] * (n + 1)
for x in order:
ng = color[x]
c = 1
for y in graph[x]:
if y == parent[x]:
continue
if c == ng:
c += 1
color[y] = c
c += 1
res = []
for a, b in AB:
if parent[a] == b:
res.append(color[a])
else:
res.append(color[b])
print(max(res)) # root
print('\n'.join(map(str, res)))
|
import sys
class UnionFind():
def __init__(self, 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
N, M = map(int, input().split())
info = [()] * M
for i in range(M):
info[i] = map(int, input().split())
uf = UnionFind(N)
for a, b in info:
a -= 1; b -= 1
uf.union(a, b)
ans = min(uf.parents)
print(-ans)
| 0 | null | 69,872,105,279,014 | 272 | 84 |
n = int(input())
a = list(map(int, input().split()))
kane = 1000
kabu = 0
if a[0] < a[1]:
kabu = kane // a[0]
kane %= a[0]
for i in range(1, n - 1):
if a[i - 1] < a[i]:
kane += a[i] * kabu
kabu = 0
if a[i] < a[i + 1]:
kabu = kane // a[i]
kane %= a[i]
kane += a[n - 1] * kabu
print(kane)
|
N= int(input())
A = list(map(int,input().split()))
A.insert(0,A[0])
A.append(0)
money = 1000
previous_tendency = "remain"
current_tendency = "remain"
count = 1
#print(A)
for n in range(1,len(A)-1):
if A[n] < A[n+1]:
current_tendency = "up"
elif A[n] > A[n+1]:
current_tendency = "down"
else:
current_tendency = "remain"
if previous_tendency != "down" and current_tendency != "up":
#print(money,n,"chance",A[n],min(A[count:n+1]),previous_tendency, current_tendency)
money += (money//min(A[count:n+1]))*(A[n]-min(A[count:n+1]))
#print(A[count:n+1],money)
count = n + 1
previous_tendency = "remain"
#print(A[n],max_price,min_price,previous_tendency,current_tendency)
if current_tendency != "remain":
previous_tendency = current_tendency
print(money)
| 1 | 7,328,142,132,652 | null | 103 | 103 |
import math
h, w = map(int, input().split())
print(math.ceil((h * w) / 2) if h != 1 and w != 1 else 1)
|
def bishop(n, m):
if n == 1 or m == 1:
return 1
if n % 2 == 0:
return (n // 2) * m
else:
return (((n // 2)+1) * m) - (m // 2)
n, m = map(int, input().split())
print(bishop(n, m))
| 1 | 51,032,099,653,120 | null | 196 | 196 |
from math import *
n=int(input())
a=[]
for i in range(n):
s=input()
a.append(s)
s=set(a)
print(len(s))
|
n = int(input())
s = []
for i in range(n):
s.append(input())
ls1 = []
ls2 = []
for item in s:
stk1 = []
stk2 = []
for ch in item:
if ch == '(':
stk2.append(ch)
else:
if len(stk2) > 0:
stk2.pop()
else:
stk1.append(ch)
l1 = len(stk1)
l2 = len(stk2)
if l2 >= l1:
ls1.append((l1, l2))
else:
ls2.append((l1, l2))
ls1.sort()
cnt = 0
for item in ls1:
cnt -= item[0]
if cnt < 0:
print('No')
exit()
else:
cnt += item[1]
ls2.sort(key=lambda x: x[1])
ls2.reverse()
for item in ls2:
cnt -= item[0]
if cnt < 0:
print('No')
exit()
else:
cnt += item[1]
if cnt != 0:
print('No')
else:
print('Yes')
| 0 | null | 26,983,831,039,868 | 165 | 152 |
import subprocess
import gzip, base64, os
import stat
gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
pymain = "./" + pymain
subprocess.call(pymain)
# compiled by pythran
'''
#pythran export main2()
import numpy as np
i8 = np.int64
i4 = np.int32
def floyd_warshall(graph):
n = graph.shape[0]
for k in range(n):
for i in range(n):
for j in range(n):
if graph[i, j] > graph[i, k] + graph[k, j]:
graph[i, j] = graph[i, k] + graph[k, j]
def clac(graph, L, inf):
for i in range(graph.shape[0]):
for j in range(graph.shape[1]):
graph[i, j] = inf if graph[i, j] > L else 1
def main2():
inf = 10**10
stdin = open('/dev/stdin')
N, M, L = map(int, stdin.readline().split())
graph = np.empty((N, N), i8)
for i in range(N):
for j in range(N):
graph[i, j] = inf
for _ in range(M):
a, b, c = map(int, stdin.readline().split())
graph[a - 1, b - 1] = c
graph[b - 1, a - 1] = c
Q = int(stdin.readline())
s = np.empty(Q, i8)
t = np.empty(Q, i8)
for i in range(Q):
s[i], t[i] = map(int, stdin.readline().split())
floyd_warshall(graph)
clac(graph, L, inf)
floyd_warshall(graph)
graph[graph > L] = 0
x = []
for i in range(Q):
x.append(str(graph[s[i] - 1, t[i] - 1] - 1))
print('\n'.join(x))
'''
|
def main():
s = input()
print(s[:3])
if __name__ == '__main__':
main()
| 0 | null | 93,904,556,061,162 | 295 | 130 |
def main():
from functools import reduce
def a_comb_mod(n, r):
mod = 1000000007
r = min(n-r,r)
if r == 0: return 1
numer = reduce(lambda x, y: x * y % mod, range(n, n - r, -1), 1)
denom = reduce(lambda x, y: x * y % mod, range(1,r + 1), 1)
denom_inv = pow(denom, mod - 2, mod)
return numer * denom_inv % mod
n, a, b = list(map(int, input().split()))
mod = 1000000007
print((pow(2, n, mod) - 1 - a_comb_mod(n, a) - a_comb_mod(n, b)) % mod)
if __name__ == '__main__':
main()
|
n, a, b = map(int, input().split())
mod = 10 ** 9 + 7
def frac_rev(n, r):
x = 1
for i in range(n, n-r, -1):
x = x * i % mod
return x
def frac(n):
x = 1
for i in range(1, n+1):
x = x * i % mod
return x
print(( pow(2, n, mod) - 1 - frac_rev(n, a) * pow(frac(a), mod-2, mod) % mod - frac_rev(n, b) * pow(frac(b), mod-2, mod) % mod) % mod)
| 1 | 66,282,331,958,748 | null | 214 | 214 |
import math
def main():
n=int(input())
print(math.ceil(n/2)/n)
if __name__ == '__main__':
main()
|
#A
import math
n = int(input())
print((math.ceil(n / 2)) / n)
| 1 | 176,986,624,248,500 | null | 297 | 297 |
from collections import deque
infinity=10**6
import sys
input = sys.stdin.readline
N,u,v = map(int,input().split())
u -= 1
v -= 1
G=[[] for i in range(N)]
for i in range(N-1):
A,B = map(int,input().split())
A -= 1
B -= 1
G[A].append(B)
G[B].append(A)
ends = []
for i in range(N):
if len(G[i]) == 1:
ends.append(i)
#幅優先探索
def BFS (s):
queue = deque()
d = [infinity]*N
queue.append(s)
d[s]= 0
while len(queue)!=0:
u = queue.popleft()
for v in G[u]:
if d[v] == infinity:
d[v] = d[u]+1
queue.append(v)
return d
d_nigeru = BFS(u)
d_oni = BFS(v)
ans=0
for u in ends:
if d_nigeru[u] < d_oni[u]:
ans = max(ans,d_oni[u]-1)
print(ans)
|
import sys
sys.setrecursionlimit(10 ** 9)
N,u,v = map(int,input().split())
u -= 1
v -= 1
E = [set() for _ in range(N)]
for _ in range(N-1):
a,b = map(int,input().split())
a -= 1
b -= 1
E[a].add(b)
E[b].add(a)
DU = [-1 for _ in range(N)]
DV = [-1 for _ in range(N)]
def dfs(p,c,D):
D[p] = c
for q in E[p]:
if D[q] == -1:
dfs(q,c+1,D)
dfs(u,0,DU)
dfs(v,0,DV)
#print(DU)
#print(DV)
mx = 0
for du,dv in zip(DU,DV):
if du < dv:
mx = max(dv,mx)
print(mx-1)
| 1 | 117,311,192,152,960 | null | 259 | 259 |
S = list(input().split())[::-1]
res = "".join(S)
print(res)
|
ls = list(map(str, input().split()))
print(ls[1]+ls[0])
| 1 | 103,302,733,259,050 | null | 248 | 248 |
import numpy as np
from numpy.fft import rfft, irfft
N, M = map(int, input().split())
*A, = map(int, input().split())
B = np.zeros(5*10**5)
for a in A:
B[a] += 1
L = 5*10**5
FB = rfft(B, L)
C = np.rint(irfft(FB*FB)).astype(int)
ans = 0
for i in range(2*10**5, -1, -1):
c = C[i]
if not c:
continue
if M - c > 0:
ans += i*c
M -= c
else:
ans += i*M
break
print(ans)
|
from itertools import accumulate
from bisect import bisect_left
def main():
n,m=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
def count(k):
cnt=0
for a in A:
cnt+=bisect_left(A,k-a)
return cnt
ok=0
ng=2*10**5+1
while ng-ok>1:
mid=(ok+ng)//2
if count(mid)<n**2-m:
ok=mid
else:
ng=mid
border=ok
k=n**2-count(border)
Acc=[0]+list(accumulate(A))
s=Acc[-1]
ans=0
for a in A:
idx=bisect_left(A,border-a)
ans+=a*(n-idx)+(s-Acc[idx])
ans-=border*(k-m)
print(ans)
if __name__=='__main__':
main()
| 1 | 108,406,703,827,260 | null | 252 | 252 |
#import sys
#import numpy as np
import math
#from fractions import Fraction
import itertools
from collections import deque
from collections import Counter
#import heapq
#from fractions import gcd
#input=sys.stdin.readline
import bisect
n=input()
l=len(n)
ans=0
d=[(0,0)]*l
d[0]=min(int(n[0]),10-int(n[0])+1),min(int(n[0])+1,10-int(n[0]))
for i in range(1,l):
ori=min(int(n[i])+d[i-1][0],10-int(n[i])+d[i-1][1])
ori_1=min(int(n[i])+1+d[i-1][0],10-int(n[i])-1+d[i-1][1])
d[i]=ori,ori_1
print(d[l-1][0])
|
S = input().strip()
INFTY=10**8
dp = [[INFTY for _ in range(2)] for _ in range(len(S))]
for k in range(10):
n = int(S[-1])
if k>= n:
dp[0][0] = min(dp[0][0],2*k-n)
else:
dp[0][1] = min(dp[0][1],2*k-n+10)
for i in range(1,len(S)):
n = int(S[-(1+i)])
for k in range(10):
if k>n:
dp[i][0] = min(dp[i][0],2*k-n+dp[i-1][0],k+(k-1)-n+dp[i-1][1])
elif k==n:
dp[i][0] = min(dp[i][0],2*k-n+dp[i-1][0])
if n==0:
dp[i][1] = min(dp[i][1],k+(k-1)%10-n+dp[i-1][1])
else:
dp[i][1] = min(dp[i][1],k+10-n+k-1+dp[i-1][1])
elif k<n:
dp[i][1] = min(dp[i][1],k+10-n+k+dp[i-1][0],k+10-n+k-1+dp[i-1][1])
print(min(dp[len(S)-1][0],dp[len(S)-1][1]+1))
| 1 | 70,963,532,568,280 | null | 219 | 219 |
s = input()
ans = s
if s[-1] == "s":
ans += "e"
print(ans+"s")
|
s = input()
suffix = ''
if s.endswith('s'):
suffix = 'es'
else:
suffix = 's'
print(s + suffix)
| 1 | 2,405,388,161,242 | null | 71 | 71 |
a, b = map(int, input().split())
if a % b > 0:
print(a//b + 1)
else:
print(a//b)
|
b=input().split(' ')
b[0]=int(b[0])
b[1]=int(b[1])
k=1
m=0
while k==1:
if b[0]<=0:
k=k+1
b[0]=b[0]-b[1]
m=m+1
print(m-1)
| 1 | 77,088,764,580,718 | null | 225 | 225 |
import math
class Point:
def __init__(self, num_x, num_y):
self.x = num_x
self.y = num_y
def kock(n, p1, p2):
if n == 0:
return
s = Point(0, 0)
t = Point(0, 0)
u = Point(0, 0)
s.x = (2 * p1.x + p2.x) / 3.0
s.y = (2 * p1.y + p2.y) / 3.0
t.x = (p1.x + p2.x * 2) / 3.0
t.y = (p1.y + p2.y * 2) / 3.0
u.x = (t.x - s.x) * math.cos(math.pi / 3) - (t.y - s.y) * math.sin(math.pi / 3) + s.x
u.y = (t.x - s.x) * math.sin(math.pi / 3) + (t.y - s.y) * math.cos(math.pi / 3) + s.y
kock(n - 1, p1, s)
print "%.8f %.8f" % (s.x, s.y)
kock(n - 1, s, u)
print "%.8f %.8f" % (u.x, u.y)
kock(n - 1, u, t)
print "%.8f %.8f" % (t.x, t.y)
kock(n - 1, t, p2)
n = input()
p1 = Point(0, 0)
p2 = Point(100, 0)
print "%.8f %.8f" % (p1.x, p1.y)
kock(n, p1, p2)
print "%.8f %.8f" % (p2.x, p2.y)
|
H, W = map(int, input().split())
dp = [[H*W for __ in range(W)] for _ in range(H)]
dh = [1, 0]
dw = [0, 1]
S = []
for i in range(H):
s = input()
S.append(s)
if (S[0][0] == '#'):
dp[0][0] = 1
else:
dp[0][0] = 0
for i in range(H):
for j in range(W):
for k in range(2):
nh = i + dh[k]
nw = j + dw[k]
if nh >= H or nw >= W:
continue
add = 0
if (S[nh][nw] == "#" and S[i][j] == "."):
add = 1
dp[nh][nw] = min(dp[nh][nw], dp[i][j] + add)
print(dp[H-1][W-1])
| 0 | null | 24,885,411,032,412 | 27 | 194 |
n = int(input())
arr = []
for i in range(n):
x,y = list(map(int,input().split()))
arr.append((x,y))
arr = sorted(arr)
ans = 0
pre = 1e10
for i in range(n):
ans = max(ans, arr[i][0] + arr[i][1] - pre)
pre = min(pre, arr[i][0] + arr[i][1])
pre = 1e10
for i in range(n):
ans = max(ans, arr[i][0] - arr[i][1] - pre)
pre = min(pre, arr[i][0] - arr[i][1])
print(ans)
|
n = int(input())
s = input()
#print(s)
tot = s.count('R') * s.count('G') * s.count('B')
#print(tot)
for i in range(n):
for d in range(1,n):
j = i+d
k = j+d
if k > n-1:
break
if s[i]!=s[j] and s[j]!=s[k] and s[k]!=s[i]:
tot -= 1
print(tot)
| 0 | null | 19,774,553,288,262 | 80 | 175 |
k = int(input())
ans = k * "ACL"
print(ans)
|
import itertools
n = int(input())
a = [list(map(int, input().split(" "))) for i in range(n)]
ans = 0
for [ix,iy], [jx, jy] in itertools.combinations(a, 2):
ans += ((jx-ix)**2+(jy-iy)**2)**0.5*2
print(ans/n)
| 0 | null | 75,230,559,172,450 | 69 | 280 |
a, b, c, d= map(int, input().split())
if a <= 0 and b <= 0 and c<= 0 and d<= 0:
print(a * c)
elif a <= 0 and b<= 0 and c > 0 and d > 0:
print(b * c)
elif a > 0 and b > 0 and c <= 0 and d <= 0:
print(a * d)
elif a * c >= b * d:
print(a * c)
elif a * c < b * d:
print(b * d)
|
a,b,c,d = map(int,input().split())
ans=[]
for X in [a,b]:
for Y in [c,d]:
ans.append(X*Y)
print(max(ans))
| 1 | 2,999,495,803,200 | null | 77 | 77 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
def make_divisors(n):
divisors = set()
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
divisors.add(i)
divisors.add(n // i)
return divisors # sortしたリストで欲しい時はsorted(divisors)
ret = 0
a = make_divisors(n)
for k in a:
if k == 1:
continue
m = n
while m % k == 0:
m //= k
if m % k == 1:
ret += 1
s = make_divisors(n - 1)
s.discard(1)
print(ret + len(s))
|
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
from collections import Counter
def factorial(n):
prime_count = Counter()
for i in range(2, int(n**0.5) + 2):
while n % i == 0:
n /= i
prime_count[i] += 1
if n > 1:
prime_count[int(n)] += 1
return prime_count
def num_divisors(prime_count):
num = 1
for prime, count in prime_count.items():
num *= (count + 1)
return num
def divisors(n):
ret = set()
for i in range(1, int(n ** 0.5) + 1):
d, m = divmod(n, i)
if m == 0:
ret.add(i)
ret.add(d)
return sorted(ret)
def solve(N: int):
f = factorial(N-1)
ans = num_divisors(f)-1
divs = divisors(N)
for k in divs:
if k == 1:
continue
n = N
while n % k == 0:
n = n//k
if n == 1:
break
if n % k == 1:
ans += 1
print(ans)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
solve(N)
if __name__ == '__main__':
main()
| 1 | 41,245,688,089,188 | null | 183 | 183 |
X = int(input())
money = 100
answer = 0
while money < X:
money += (money//100)
answer += 1
print(answer)
|
n, m = map(int, input().split())
a = [list(map(int, input().split())) for i in range(n)]
b = [int(input()) for j in range(m)]
for a_row in a:
print(sum(a_row[k] * b[k] for k in range(m)))
| 0 | null | 14,179,694,470,162 | 159 | 56 |
S=str(input())
print('x'*len(S))
|
def p_is_smaller(p):
total = 0
number_of_track = 1
for w in W:
total += w
if total > p:
number_of_track += 1
if number_of_track > k:
return 1
total = w
return 0
if __name__ == "__main__":
n, k = map(int, input().split())
W = [int(input()) for _ in range(n)]
left, right = max(W), sum(W)
while right > left:
mid = (left + right) // 2
if p_is_smaller(mid):
left = mid + 1
else:
right = mid
print(right)
| 0 | null | 36,582,619,672,300 | 221 | 24 |
import math
import collections
import fractions
import itertools
import functools
import operator
import bisect
N = int(input())
def solve():
cnt = 0
for i in range(1, N):
cnt += (N-1)//i
print(cnt)
return 0
if __name__ == "__main__":
solve()
|
# This code is generated by [Atcoder_base64](https://github.com/kyomukyomupurin/AtCoder_base64)
import base64
import subprocess
import zlib
exe_bin = "c%1E9e{dUhcK_;!V<mPZIXH<41dAZJm?XkV>|iJLVcAl$;^f2^JCIVsMwaAQM3!7>6&xl&I3?lsj3C@FG@YYu+H0?2rc=1~u4OtmhfTN`ZrU3|OPdys3s;~Lg-HT5I3bDp-gm!WX?LwX?r!=|XY%#fZ{KI%d;7lc`@Y}Z{qFN4fzT$i$wYXwkgpQtjxAL9ZidgSDT@HsLFU8X8_04p4|uCePETh|T52m_N73srE4-dwPqfseqBX?04K!*gA+E9>`r5i&L0gx*G_=63J7(|F=$V<G!1M$r	B?amxE=Wxs<A*Hb^yQY)kV?@LiUey>5{^>mPEDcAct=*=U)eseOqja|<uE;GzuPWd?8mWU6nZ@VoKU6Y6>v*T;VJJzpR-{#4rJZq^>PA0o~%XTV{<84;?+{iFIf2w)cBJuLk3*Ts~`|Q#Ezv%kP+lBkhOoopeM%V<Jd{`Tg*7s(fspTf;w10x%MOE-|Fu0-$e!qeIb_4wPP1W(J0e;fJj@3YZzyM!hfInt{pE0=ZE(5%o@XXh?4F>j~G{Bt(b~YN|e{JB;3b5Zmt|i?rMa#(&@Gpph@48XJn|NYEUS_0dWYsFn#q~rKcaNr$Vnzz5B~c_|aIjB|#?rCf@r)Ep5BBvYQpwn0cqkE5&Q(8i&z6CBIuqCyr-!LTCV)o+Qd=w;O#~wYlGhs<38zIV9ga(xU?dRO2H3ixa3&rRQyD283y%f|#lcoFFtA>vs_P>0B()}W#8Vj&L}P8iWL)xl1A76FCi?g4PJ7!k`;rmyfw(jR{fWj?fg$YP__#P0OJ`Eaa3U`46Zf`)TJnL>YPNe7+u(O3m6b45yCV@XgOTzQaeMNCcrq$(i)FH-F+3UJA%y5f_K1;@J>qaUo&X>+9u~t=Y&<TJ(b#BYY#+mh<LJeMF+@jGdm(Zn+F{`z4MUeV_x6hGJgsDNDA?00uJyE)kGz$`wVrm;yJLs1Cn$P7>lAp$4$y1EAvVLxVTK<oqcs$nN7t8Hx~dS0BX5GA)uu{5_TRFv4yFE-<%<dAgY0}a{5Hnp3-J!~9K)V|>X~`CV*M@Sv&-W1apn4PS>H_8D88Ql^YeRZaK-v5lb2e)Z9{L~Wb%An<@bqWc7=B6@Ll}=tH+tV&85XTKhvzxd8D%5Vmqb6?JE4V3U{jTf(ma?;b&F2dcMx8@M~1Kllg_+uUFxGKI6T-QHAsQjQC;|KE~|VlFB^@+qeq1sPF?S+^WLAslwII5l2+G`aXJ8h1aU^V=COH!jG%)`6~Pc6}~`)zo^3NRQRL{U#P-gRpAa5F62J42@^Gom$-;<Xi_qlW`x`;wiBe({@`L4Dc!su{yLhw;RyK=R4JY=LAyDPJchJ5L;3rW$J8lKQho?|3~liR%HM-LhO~H$^4pNdP!^9+{!ZjEgvA4t??E2jEsjxs1M(QM;x5XsMIJ*{?5F&#$YY3#-IQN}Jcg#&O8I5L4<F(E_TBBf%Ukko_YH0zfEaW{g$e7;D={Fl-@Vd1S*QaYAuqYzLcS}7(V4CZEmdMzaKO0<zuTRgH94MeL!U$W_C0WN+V7_K6QK0@)6q=i6RYlZH|4%CIS!tKQ^K^>jc2^C1-vDUs}MO6@V@7pSbccd(F_lD@+n{L71JMne%UAgL^$f(xcaalpOA{e#(KBo;Gck|+~SwRRv|ZK^W`p^vM+@?FGx29^P3T}4tpHU2dR$}9YSu>mcQHNc>X_x&R4T%O!vC4?>khIY$3T+c=!tI06ILe-`&(X>v;0(*el6>J#_fKMi(hO2SS28U1$L6ofP2I%BZlejYi3FXdCt>_e#g_?eyL2+v&T{C!V1FnXtM;Ewh6BG6vEqOkK1Hhu&};{3{G?-nvNWq$g~S!^aVUNZDpF(%^)x@cCst8U(e8Hn(7UIn;SYzSS=eSrz?Y{%)Jl@~?vYi7@q{Mab8`iRs{d1FsvLXj>}CZB8NgvQ6lGJ$ptlO<|C*%gdn4iZ^n-yYLNq5#%Q7-PkKzP@Wb{Cqdg?JPv)O<3K&5*%n6kUMeZAS%64A7AVn(<iKa*ICv)tO#RX-$b)WMacv1LKpIUI_roDX_<B?EX)w!^qIeV-a0|zk4#v4l80TLUg5X%edby<JMZU{>!%jLq3xs;y_2?qV!u;ZIQPO@5oGpA0Rr6hEV7PGF7B@jIDtYAnI4Hk<pCJEI$h~*Ae=wA<S!Tr%SomEFlCDdjSz5dVY<;HmH{az0X1kED>BI|k!VtbMT?<RYhYiZouyAMTbS1xb($TK)pl?zfyV!tcTCRY;Fm=Tu$Y+JA!W|gk*RM!TVDS6QU_BZ%vUi}X0Xjvpw+Xo}5fs2A_)`yI_!e-5HQ;_hfG(V@DPH3uCR9IwdY_(9`j6r}i^CwH@HpRt@_C%_LHRS7^YUegEx5B4mcM2}el^(gj?i*Sn3^?%Z;pdMpnYm1!Rcv?l+bzBari~RXeu?j3!yJ?OkjW}`fPpjX<?$#9h83(G))IvPED9Yo&VV@``d}+3gJX}CnTQ{<d7SN+v+a(s48+WSAz1-w&wjc*1nbxLY?nQ4Iz0tB!3c;KPdde#ZoCKPxe9J4!tGWFhiyR3dy73L>5dv1j+tNlWzXe=ZjGOcYa7yZA-cT!iy|}?+`jqIv#7sJ{>xreX~zK3oB8;`*Cp-%9i5~>!OhVgQodi1VZ%%gsN4)LJIOM<oPtai%eQ!W@pcZ@=<rakWawuf_$eB26)iK59k8wJr76qc&qTeXr{{~%-_f)EDyN}CoUF$iPEqlID_&heweED!Iq1`sf*^op*J4x2g!-0p?rPLx3S@o9(l&+cz&`g(BmMFv<vyIR$uNz)0TYWQ~$l3_IsiM#jcZQaCxkVE)b3eJAW!S=Cbeja+4<Cqq7M6p=b4uC&p-SN>WYXt_#XqfeW9~`Rq;zdMgI~gc8?{lH28%iL}Ho&l7SdVHJ?vO~tR4*g6t|87QAAJVd83o^i9)4i=*m%0<r2viW}j=l=y|{ww+VZ<w#4{LMeEqf>LuNuUEh`7&g3sO5cn@1DABDcp`04t*@Syl?UG3&|Hl@_D~}##d^5TgaU-37tRBeu#^NDq)UP#{1I~>{)=`{n_*Bb(W3&M0p;$^m(cDEYN?1OT7a0ZJ?Kc?uTTaft>ph&;*``*%AW&5_I?|P+S8)0{RiqHgn~f&Gg_lVj6dvuB)%L9Wm895y$0G06VKx&nMO832`&|9pKjt3fP^S>`iw%>K?EiAa^X=c<Va%3a(H0O2A+B^HzC(=)wLFwOsq1u7xgg9k(AM$~8`5zrk<o9RT*&olly3>`hNt{B~E~+GAh&c#Y5AdU&4C-jS>I+s7=OrUmv6fPD6qJ$4s}f=Z9w7N`?2Ht;(R{ksL{XvJ2bY|CG^wb|Zpe%Zhj!Izmy_`Mfmy&r5@|6Z~8xY=iKI&2Z_uACJNSn9zU7eGF$xTy|jVL!<KIpo*|?EKg4&in03R4_&fIQLB$w-_<-PeA_!^smp}ov!8`eHZuv*m(i$sNW+>C6m+jBp^>)YD!k}?V1{j)&0y|^K&!##QdxF=B~D@?P|N)uC}Y~YP;J0KQ_K!%lBvbeysZYq?)caY55>K;CrF3vQ0w1$M-L6v-MiW^ZnxM7|-`;modushxv0be>VP~E2R|DqwL|0KbOt0%}~C_ImyoRJ;`^Oe|#^piBa`lEH=K^x`XXU@@GUB)926oe9v?#qsMJpe5_XMcL&qwd#C*RHxR8HJbu&unHY41@uykGN{r`zo@M;su=5ufuihK}zij;bu)dvV9h=7jzJ$?R7+ufkCPwdKbePe-j2>q68AiXS-c<fA8vlO4+veWh4X%~jhq6g2>$=_3?rB}KE=xJ@!`=>0Yg>zg{yMfTFiIU&zSQE^o58BMg-BI#YdN2_cuhHvwfMYpzH9N?avo@LTRDHU`22F7YVif-eAeQ1<$0~e>&fY=_(JkRmGQF>JDIGCJId>X7I%`<Rq=*${eTu<L^`T`bhVIcNNZy?ys^9<Y4OG7bx4aZsX7lVup01nLyN;~cU8kH-+#6EvN;$oA69a%q{s1Fi5cR_*X<1qzme)(OOCGES=PtaYG7w0voo_$i+3^HY1iWY{JJ`Pm|b^#g-dhYEIpnZ&u5vPV>&y>sr=k=G4g+!$}b|TtBh|o`8Vm`x%pF|cIJ-nIr_J8j{jzpg6sWUY(hJ8^I;YJe%eHubmP9jg5PoH=E+)GCs4_MKJ9%5^$BAJbs&#Z`O3U|maQvK8QA%Eyso)v&ieU*f&3M~Zv=V%U6d~$pIT6U?z~=Ru5M?I0lwLc{j!r6Sf1R%66?<l<n0!vzr5ay@7evGf&6O*_z<--cins6ti(q@j(9)E`i%oD|8a*J+c|UfdJmgL$p`(oUq%^_KgQ-SZ;LHT98R;3r2CnjuUHg$y+7+L)%&%B#b*~Aml(rG4CEg&!2j3)|DmONJ<RI{@<ry)4D*NI_AXee*TXoh)$Mq!)vw!SfZuIkhxCd*aa`;Xdp(h{F(PgbZSC=eL@|>c5`$tYL(5G<9ikXd#glP~MAA}5$_@{EBBWA=BTA!U1j}teT#Tl~-HFstI3Y%*R5~Muv*RR^8XZf-q*&B*`})p~>Oxq25*Neiba<Z_OG@c|WH=ojjfv6h=qT2ws5lW_(TIxTrft5yfEd`~$0{Ll^Oo&mKwzNY-$q3L?{4w+1$*I~MmeelXrW6v3R^dA8VC%EgT9_n0IbHMVJS?+;8t3`lN7U=SoF(le7d{U<uBSg8+MLW%+UIp-@YtKf1zk5C60u_lDYs&E9Af1la390s#YN>g+Ub$y=|JpA+75)3hVdAA~2f4_&_)q4+Oloi&&2pP9#zhh;b&CmV$R~gA;+hTRP#A$t;)~2PrX`N{>P+#37Z!XrMnn;1vS_|Jc?+k=0V^I)@cf`u=LGoGSj|xxv0(o*TS;YEHOdaQXP(v!y+i35$E$hqCcR6pOCJp-iT7wpwA9-X1NSie$1hy?8;DE^1Zc-rcP#oGMqV>5TuXDmYCU80fKjEtNw!(aJS!Ro$-Cd(ClpPBork#a)%cIPJxVC$n!<3J(F5(h42nNAV<>93!4&N{V?P9BZWTZpK04c<8vSiAM?LM#7m9;)(7{f<1*wY30mbh;2NT)G#8POUDvn6l6zZ2?;L=<AjHv-6=SLEQh}|R-SZ<PJK^oge^lO(R76a>yd~U8;``sBvGRM_f*yt#RflyYlcVT5jda*A*+Z7R>x6T#;UE(zj4ET2E29f`-)LrHg6^!e-lyO?YX|b?%Ac2*T0^5b^820kW=@U=;QaV^YCuZ_4)fErz;uG_e1orZ(E46_rdk~dnKp5&KqA7O)7o9PjMH~);ja|Pfp*}1xz2m`-rl4!S(rjDyOS;{+o4l4^j3)IM3f_Ipu{@^O&Fd{y#{Rm~wso-peW9pV7yU_x~W%?_oTDKjze>(qCFd{|Tb5`L67bamx3Rc+-!+tkdW3+nmnm<efVDv`(MDmvgF*mrY0iNT<)=BRE~8+edI}S@K<-K7SwJRKI<o@Bed5pFgYd_aXgzkzSwE?-T9(H~RkrqwBw<)93pOoX+YJULVibbozWBg43IH^7{Gn7E$V3`MzJ}{}~isA8-Bm{TEU83b;OhkL_Mw-Cw=_r=&8suvPwFgk4{?eyH`hUq@M=^!uwjnic-|mt6mnPQU!V#0Z~fdVSu^Y(ur&f2QBW^mo;DY2>?g`n4wI`udGQuHT}=tL>Xt`=<_p>CdwHgZCj1nY(_>SNX2-lP&!FbqTA_p9TZ{AF+kk`6cW3{{kH-Ur7"
open("./kyomu", 'wb').write(zlib.decompress(base64.b85decode(exe_bin)))
subprocess.run(["chmod +x ./kyomu"], shell=True)
subprocess.run(["./kyomu"], shell=True)
| 1 | 2,594,801,711,832 | null | 73 | 73 |
while 1:
n,x=map(int,input().split())
if n == 0 and x == 0: break
print(len([1 for a in range(1,n+1) for b in range(a+1,n+1) for c in range(b+1,n+1) if a + b + c == x]))
|
#!/usr/bin/env python3
import sys
def input():
return sys.stdin.readline()[:-1]
def main():
l = list(map(int, '1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51'.replace(',', '').split()))
K = int(input()) - 1
print(l[K])
if __name__ == '__main__':
main()
| 0 | null | 25,688,477,926,400 | 58 | 195 |
def resolve():
N, M = list(map(int, input().split()))
H = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(M)]
good = [True for i in range(N)]
for a, b in AB:
a, b = a-1, b-1
if H[a] < H[b]:
good[a] = False
elif H[a] == H[b]:
good[a] = False
good[b] = False
else:
good[b] = False
cnt = 0
for g in good:
if g:
cnt += 1
print(cnt)
if '__main__' == __name__:
resolve()
|
N,M=map(int,input().split())
H=list(map(int,input().split()))
H.insert(0,0)
s=set()
for i in range(M):
a,b=map(int,input().split())
if H[a]<=H[b]:s.add(a)
if H[a]>=H[b]:s.add(b)
print(N-len(s))
| 1 | 24,916,274,722,048 | null | 155 | 155 |
h, w, k = map(int, input().split())
c = [input() for _ in range(h)]
count = 0
for binh in range(2**h):
for binw in range(2**w):
redh, redw = bin(binh)[2:].zfill(h), bin(binw)[2:].zfill(w) # remove suffix '0x'
squares = [list(row) for row in c]
for i, rh in enumerate(redh):
for wh in range(w):
if rh == '1':
squares[i][wh] = '*'
for j, rw in enumerate(redw):
for hw in range(h):
if rw == '1':
squares[hw][j] = '*'
count += sum(row.count('#') for row in squares) == k
print(count)
|
N = int(input())
An = list(map(int, input().split()))
money = 1000
stock = 0
for i in range(N-1):
if An[i+1] > An[i]:
stock = money // An[i]
money += (An[i+1] - An[i]) * stock
print(money)
| 0 | null | 8,073,233,433,970 | 110 | 103 |
N = int(input())
S = input()
total = S.count("R") * S.count("G") * S.count("B")
sub = 0
for i in range(N):
for j in range(i + 1, N):
if S[i] == S[j]:
continue
h = j + j - i
if h > N - 1 or S[j] == S[h] or S[h] == S[i]:
continue
sub += 1
print(total - sub)
|
W = input()
if W.count("R") > 0:
if W == "RRR":
print(3)
elif "RR" in W:
print(2)
else:
print(1)
else:
print(0)
| 0 | null | 20,670,940,745,280 | 175 | 90 |
n=int(input())
s,t=map(str,input().split())
a=""
for i in range(2*n):
if i%2==0:
a=a+s[(i)//2]
else:
a=a+t[(i-1)//2]
print (a)
|
N=int(input())
S,T=input().split()
list=[]
i=0
while i<N:
list.append(S[i])
list.append(T[i])
i=i+1
print(*list, sep='')
| 1 | 112,214,328,872,772 | null | 255 | 255 |
mod=10**9+7
N=int(input())
A=list(map(int,input().split()))
B=[0]
for x in A:
B.append(B[-1]+x)
ans=0
for i in range(N):
s=(B[N]-B[i+1])%mod
ans+=A[i]*s
ans%=mod
print(ans)
|
N = int(input()) #入力する整数
A = list(map(int,input().split())) #入力する数列A
SUMA = sum(A) #数列の和
MOD = 10**9 + 7 # mod
C = [0] * (N-1) #累積和数列
for i in range(N-1): #\sum_{j = i+1}^{N}を求めて数列に代入する
SUMA -= A[i]
C[i] = SUMA
ans = 0 #求める答え
for i in range(N-1):
ans += A[i]*C[i]
ans %= MOD #その都度modで割った余りにする
print(ans) #答えを出力する
| 1 | 3,804,254,741,280 | null | 83 | 83 |
import math
a,b,x = map(int,input().split())
if 2*x>=a*a*b:
l = 2*(b-x/a**2)
print(math.degrees(math.atan(l/a)))
else:
l = 2*x/a**2
print(math.degrees(math.atan(a*b**2/2/x)))
|
x = raw_input()
x = int(x)
print x * x * x
| 0 | null | 81,598,386,242,310 | 289 | 35 |
s = input()
if 'A' in s:
if 'B' in s:
print('Yes')
else:
print('No')
else:
print('No')
|
dice = list(map(int, input().split()))
cmd = input()
for i in range(len(cmd)):
if cmd[i] == 'N':
dice[0], dice[1] = dice[1], dice[0]
dice[1], dice[5] = dice[5], dice[1]
dice[5], dice[4] = dice[4], dice[5]
elif cmd[i] == 'E':
dice[0], dice[3] = dice[3], dice[0]
dice[3], dice[5] = dice[5], dice[3]
dice[5], dice[2] = dice[2], dice[5]
elif cmd[i] == 'W':
dice[0], dice[2] = dice[2], dice[0]
dice[2], dice[5] = dice[5], dice[2]
dice[5], dice[3] = dice[3], dice[5]
else:
dice[0], dice[4] = dice[4], dice[0]
dice[4], dice[5] = dice[5], dice[4]
dice[5], dice[1] = dice[1], dice[5]
print(dice[0])
| 0 | null | 27,685,209,314,752 | 201 | 33 |
x = int(input())
h = x // 100
m = x % 100
if 0 <= m <= h * 5:
print(1)
else:
print(0)
|
n=int(input())
def dfs(s):
if len(s)==n:
print(s)
else:
for i in range(ord('a'),max(map(ord,list(s)))+2):
dfs(s+chr(i))
dfs('a')
| 0 | null | 89,541,658,267,288 | 266 | 198 |
from itertools import groupby
n=int(input())
print(len(list(groupby(input()))))
|
n = int(input())
a, b = 0, 0
for i in range(n):
s1, s2 = input().split()
if s1 > s2:
a += 3
elif s1 == s2:
a += 1
b += 1
else:
b += 3
print('{0} {1}'.format(a, b))
| 0 | null | 85,610,393,663,832 | 293 | 67 |
#A
alpha="abcdefghijklmnopqrstuvwxyz"
C=input()
for i in range(len(alpha)):
if alpha[i]==C:
print(alpha[i+1])
|
N = int(input())
S = input()
if N % 2 != 0:
print('No')
exit()
print('Yes') if S[:N//2] == S[N//2:] else print('No')
| 0 | null | 119,480,301,358,880 | 239 | 279 |
#create date: 2020-06-30 22:48
import sys
stdin = sys.stdin
from itertools import product
def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def main():
n = ni()
t = [[-1] * n for _ in range(n)]
for j in range(n):
a = ni()
for i in range(a):
x, y = na()
t[j][x-1] = y
l = list(product([0, 1], repeat=n))
ans = 0
#print(t)
for li in l:
f = True
for i in range(n):
people = li[i]
if people:
for j in range(n):
if t[i][j] == 1 and li[j] == 0:
f = False
if t[i][j] == 0 and li[j] == 1:
f = False
if f:
#print(li, f)
ans = max(ans, sum(li))
print(ans)
if __name__ == "__main__":
main()
|
n = int(input())
m = int(input())
if n!=1 and m!=1:
print(1)
elif n!=2 and m!=2:
print(2)
else:
print(3)
| 0 | null | 116,320,409,862,342 | 262 | 254 |
h, w, k = map(int, input().split())
A =[]
for i in range(h):
a = input()
A.append([a[i] == "#" for i in range(w)])
ans = 0
for bit in range(1 << h):
for tib in range(1 << w):
now = 0
for i in range(h):
for j in range(w):
if(bit >> i) & 1 == 0 and (tib >> j) & 1 == 0 and A[i][j] == True: now += 1
if now == k: ans += 1
print(ans)
|
H, W, K = map(int, input().split())
C = [list(input()) for _ in range(H)]
ans = 0
# ビット探索
for i in range(2**H):
for j in range(2**W):
cnt = 0
for h in range(H):
for w in range(W):
if((i >> h) & 1) == 0 and ((j >> w) & 1) == 0:
if C[h][w] == "#":
cnt += 1
if cnt == K:
ans += 1
print(ans)
| 1 | 8,888,400,137,578 | null | 110 | 110 |
while True:
H,W = list(map(int, input().split()))
if (H == 0) and (W == 0):
break
else:
for n in range(0, H):
s = ""
for m in range(0, W):
s += "#"
print(s)
print("")
|
s = input()
if s in ['hi','hihi','hihihi','hihihihi','hihihihihi']:
print('Yes')
else:
print('No')
| 0 | null | 27,116,565,450,810 | 49 | 199 |
n, k = map(int, input().split())
r, s, p = map(int, input().split())
t = input()
me = ""
ans = 0
for i in range(n):
if t[i] == "r":
if i < k:
me += "p"
ans += p
elif me[i-k] != "p":
me += "p"
ans += p
else:
if t[i-k] == "p":
me += "p"
ans += p
else:
me += "r"
elif t[i] == "s":
if i < k:
me += "r"
ans += r
elif me[i-k] != "r":
me += "r"
ans += r
else:
if t[i-k] == "r":
me += "r"
ans += r
else:
me += "s"
else:
if i < k:
me += "s"
ans += s
elif me[i-k] != "s":
me += "s"
ans += s
else:
if t[i-k] == "s":
me += "s"
ans += s
else:
me += "p"
print(ans)
|
h, n = map(int, input().split())
a = list(map(int, input().split()))
a_sum = sum(a)
if h <= a_sum:
print('Yes')
else:
print('No')
| 0 | null | 92,604,031,884,668 | 251 | 226 |
x,y,a,b,c=map(int,input().split())
p=list(map(int,input().split()))
q=list(map(int,input().split()))
r=list(map(int,input().split()))
p=sorted(p,reverse=True)
q=sorted(q,reverse=True)
r=sorted(r)
box=[]
ans=0
for i in range(x):
box.append(p[i])
for j in range(y):
box.append(q[j])
box = box + r
box=sorted(box,reverse=True)
for k in range(x+y):
ans+=box[k]
print(ans)
|
#!usr/bin/env python3
def string_five_numbers_spliter():
"""Split a given space-separated five numbers in a string into integers
Return five integer values from a given space-separated five integers in a string.
Returns:
Five integer values; namely, w, h, x, y and r
"""
w, h, x, y, r = [int(i) for i in input().split()]
return w, h, x, y, r
def main():
# Given that there are a rectangle and a circle.
# Let w, h, x, y and r be such that:
# w = width of the rectangle
# h = height of thek rectangle
# x = x coordinate for the centre of the circle
# y = y coordinate for the centre of the circle
# r = diameter of the circle
w, h, x, y, r = string_five_numbers_spliter()
if (not (x < 0) and not (y < 0) and
not (x + r < 0) and not (y + r < 0) and
not (x + r > w) and not (y + r > h)):
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| 0 | null | 22,726,363,670,500 | 188 | 41 |
A, B = map(int, input().split())
mul = A * B
print(mul)
|
n, m = map(int, input().split())
if n%2 == 1:
a = 1
b = n+1
ans = []
for i in range(m):
a += 1
b -= 1
ans.append((a, b))
else:
a = 1
b = n+1
S = set()
ans = []
for i in range(m):
a += 1
b -= 1
r = min(b-a, n-(b-a))
if r in S or r == n//2:
b -= 1
r = min(b-a, n-(b-a))
ans.append((a, b))
S.add(r)
for i in range(m):
print(*ans[i])
| 0 | null | 22,420,952,857,562 | 133 | 162 |
# coding: utf-8
#import math
#import numpy
#N = int(input())
def main():
import sys
input = sys.stdin.readline
N, K = map(int,input().split())
A = list(map(int,input().split()))
#K =int(input())
ANS = []
#ANS.append(a)
for i in range(K,N):
if A[i-K] < A[i]:
print("Yes")
else:
print("No")
#ANS.append(a)
#print(ANS)
if __name__ == '__main__':
main()
|
def main():
N, K = map(int, input().split())
*A, = map(int, input().split())
ans = []
for i in range(K, N):
cond = A[i] > A[i - K]
ans.append('Yes' if cond else 'No')
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| 1 | 7,202,553,257,728 | null | 102 | 102 |
from enum import IntEnum
class Direction(IntEnum):
NORTH = 0
EAST = 1
SOUTH = 2
WEST = 3
class Dice:
"""Dice class implements the structure of a dice
having six faces.
"""
def __init__(self, v1, v2, v3, v4, v5, v6):
self.top = 1
self.heading = Direction.NORTH
self.values = [v1, v2, v3, v4, v5, v6]
def to_dice_axis(self, d):
return (d - self.heading) % 4
def to_plain_axis(self, d):
return (self.heading + d) % 4
def roll(self, d):
faces = [[(2, Direction.NORTH), (6, Direction.NORTH),
(6, Direction.WEST), (6, Direction.EAST),
(6, Direction.SOUTH), (5, Direction.SOUTH)],
[(4, Direction.EAST), (4, Direction.NORTH),
(2, Direction.NORTH), (5, Direction.NORTH),
(3, Direction.NORTH), (4, Direction.WEST)],
[(5, Direction.SOUTH), (1, Direction.NORTH),
(1, Direction.EAST), (1, Direction.WEST),
(1, Direction.SOUTH), (2, Direction.NORTH)],
[(3, Direction.WEST), (3, Direction.NORTH),
(5, Direction.NORTH), (2, Direction.NORTH),
(4, Direction.NORTH), (3, Direction.EAST)]]
f, nd = faces[self.to_dice_axis(d)][self.top-1]
self.top = f
self.heading = self.to_plain_axis(nd)
def value(self):
return self.values[self.top-1]
def run():
values = [int(v) for v in input().split()]
dice = Dice(*values)
for d in input():
if d == 'N':
dice.roll(Direction.NORTH)
if d == 'E':
dice.roll(Direction.EAST)
if d == 'S':
dice.roll(Direction.SOUTH)
if d == 'W':
dice.roll(Direction.WEST)
print(dice.value())
if __name__ == '__main__':
run()
|
mask = {'N':(1, 5, 2, 3, 0, 4), 'E':(3, 1, 0, 5, 4, 2), 'S':(4, 0, 2, 3, 5, 1), 'W':(2, 1, 5, 0, 4,3)}
dice = input().split()
for c in input():
dice = [dice[i] for i in mask[c]]
print(dice[0])
| 1 | 227,199,901,150 | null | 33 | 33 |
x = input().split()
print(x.index('0') + 1)
|
l = input().split()
print(l.index("0") + 1)
| 1 | 13,396,744,896,498 | null | 126 | 126 |
N = int(input())
a = 0
for i in range(1,10):
if N%i == 0 and N <= 9*i:
print("Yes")
a = 1
break
if a == 0:
print("No")
|
def eighty_one(a):
for n in range(9, 0, -1):
if a % n == 0:
if a // n > 9:
return False
else:
return True
return False
n = int(input())
if eighty_one(n):
print('Yes')
else:
print('No')
| 1 | 159,819,672,542,280 | null | 287 | 287 |
n, m = map(int, input().split())
c = [int(i) for i in input().split()]
dp = [[-1 for _ in range(m + 1)] for _ in range(n + 1)]
for i in range(1, n + 1):
dp[i][1] = i
for j in range(1, m + 1):
dp[0][j] = 0
# dp[1][j] = 1
for i in range(n + 1):
for j in range(1, m):
if c[j] > i:
dp[i][j + 1] = dp[i][j]
else:
dp[i][j + 1] = min(dp[i][j], dp[i - c[j]][j + 1] + 1)
print(dp[n][m])
|
cost,m,=map(int,input().split())
c=list(map(int,input().split()))
DP=[[10**10 for i in range(60001)] for j in range(21)]
for i in range(m):
DP[i][c[i]]=1
for j in range(60001):
if c[i]>j:
if i==0:
DP[i][j]=0
else:DP[i][j]=DP[i-1][j]
elif j+c[i]<=60000:
DP[i][j]=min(DP[i][j-c[i]]+1,DP[i-1][j])
print(DP[m-1][cost])
| 1 | 136,089,631,270 | null | 28 | 28 |
H, W = map(int, input().split())
S = [list(input()) for h in range(H)]
table = [[0 for w in range(W)] for h in range(H)]
table[0][0] = int(S[0][0]=='#')
for i in range(1, H):
table[i][0] = table[i-1][0] + int(S[i-1][0]=='.' and S[i][0]=='#')
for j in range(1, W):
table[0][j] = table[0][j-1] + int(S[0][j-1]=='.' and S[0][j]=='#')
for i in range(1, H):
for j in range(1, W):
table[i][j] = min(table[i-1][j] + int(S[i-1][j]=='.' and S[i][j]=='#'),
table[i][j-1] + int(S[i][j-1]=='.' and S[i][j]=='#'))
print(table[-1][-1])
|
# coding: utf-8
H, W = list(map(int, input().split()))
S = []
for _ in range(H):
S.append(list(input()))
grid = [[0 for _ in range(W)] for _ in range(H)]
for h in range(1,H):
if S[h-1][0] == '#' and S[h][0] == '.':
grid[h][0] = grid[h-1][0] + 1
else:
grid[h][0] = grid[h-1][0]
for w in range(1,W):
if S[0][w-1] == '#' and S[0][w] == '.':
grid[0][w] = grid[0][w-1] + 1
else:
grid[0][w] = grid[0][w-1]
for w in range(1,W):
for h in range(1,H):
if S[h-1][w] == '#' and S[h][w] == '.':
next_h = grid[h-1][w] + 1
else:
next_h = grid[h-1][w]
if S[h][w-1] == '#' and S[h][w] == '.':
next_w = grid[h][w-1] + 1
else:
next_w = grid[h][w-1]
grid[h][w] = min([next_w, next_h])
if S[H-1][W-1] == '#':
grid[H-1][W-1] += 1
print(grid[H-1][W-1])
| 1 | 49,228,910,057,116 | null | 194 | 194 |
import sys
import math
def IL(): return map(int,sys.stdin.readline().rstrip().split())
def Main():
a,b,n = IL()
x = min(b-1,n)
print(math.floor(a*x/b)-a*math.floor(x/b))
return
if __name__=='__main__':
Main()
|
a,b,n = map(int,input().split())
if b <= n:
k = b-1
else:
k = n
m = int(k*a/b) - a*int(k/b)
print(m)
| 1 | 28,309,894,111,840 | null | 161 | 161 |
str1, str2 = input()*2, input()
if str2 in str1:
print("Yes")
else:
print("No")
|
n=str(input())
a=len(n)
N=list(n)
m=str(input())
A=len(m)
x=0
for i in range(a):
C=[]
for i in range(A):
C.append(N[i])
B=''.join(C)
c=N[0]
if B==m:
x=x+1
N.remove(c)
N.append(c)
if x>0:
print('Yes')
else:
print('No')
| 1 | 1,768,946,992,292 | null | 64 | 64 |
k = input().split()
num = len(k)
for i in range(num):
if k[i] == "0":
print(i+1)
|
x = list(map(int,input().split()))
print(15-x[0]-x[1]-x[2]-x[3]-x[4])
| 1 | 13,485,589,759,072 | null | 126 | 126 |
N=int(input())
*A,=map(int,input().split())
T=[0]*N
for i in range(N):
T[~-A[i]]=i+1
print(*T)
|
n,m,l=map(int,input().split())
a=[list(map(int,input().split(" "))) for i in range(n)]
b=[list(map(int,input().split(" "))) for i in range(m)]
c=[[0]*l for i in range(n)]
for i in range(n):
for j in range(l):
for k in range(m):
c[i][j]=c[i][j]+a[i][k]*b[k][j]
for d in range(n):
print(c[d][0],end="")
for e in range(1,l):
print(" %d"%c[d][e],end="")
print()
| 0 | null | 91,069,448,333,380 | 299 | 60 |
import sys
for line in sys.stdin:
result = 0
a, b = map(int, line.rstrip('\n').split(' '))
x = a + b
while x > 0:
result += 1
x /= 10
print result
|
a = [str(input()) for i in range(2)]
s = a[0]
t = a[1]
s_l = len(s)
S = s + t[s_l]
if S == t:
print('Yes')
else:
print('No')
| 0 | null | 10,710,589,391,740 | 3 | 147 |
def main():
N = int(input())
mod = 10 ** 9 + 7
mod_1 = 1
mod_2 = 1
mod_3 = 1
for _ in range(N):
mod_1 = (mod_1 * 10) % mod
mod_2 = (mod_2 * 9) % mod
mod_3 = (mod_3 * 8) % mod
v = (mod_1 - 2 * mod_2 + mod_3) % mod
print(v)
if __name__ == '__main__':
main()
|
n = int(input())
mod = 10 ** 9 + 7
dp = [[[0 for _ in range(2)] for _ in range(2)] for _ in range(n)]
dp[0][0][0] = 8
dp[0][0][1] = 1
dp[0][1][0] = 1
dp[0][1][1] = 0
for i in range(n-1):
for j in range(2):
dp[i+1][0][0] = (dp[i][0][0] * 8) % mod
dp[i+1][0][1] = (dp[i][0][0] + dp[i][0][1] * 9) % mod
dp[i+1][1][0] = (dp[i][0][0] + dp[i][1][0] * 9) % mod
dp[i+1][1][1] = (dp[i][0][1] + dp[i][1][0] + dp[i][1][1] * 10) % mod
print((dp[-1][-1][-1]) % mod)
| 1 | 3,218,858,597,206 | null | 78 | 78 |
#!/usr/bin/env pypy3
# n,m = map(int,sys.stdin.readline().split())
# a = list(map(int,sys.stdin.readline().split()))
# a = [sys.stdin.readline() for s in range(n)]
# s = sys.stdin.readline().rstrip()
# n = int(sys.stdin.readline())
# d = collections.defaultdict(list)
# h = list() heapify(h)
import math
from functools import reduce
import sys
sys.setrecursionlimit(15000)
n,k = map(int,sys.stdin.readline().split())
dp = [0]*(k+1)
s = 0
#print("nk:",n,k)
l = 0
for x in range(1,k+1)[::-1]:
dp[x] = pow(k//x,n,1000000007)
j = 2
#print(2*x,k+1,x)
for j in range(2*x,k+1,x):
#print("j",x,j,k,n)
dp[x] -= dp[j]
s = (s + (dp[x]*x))%1000000007
#return reduce(math.gcd, numbers)
#sum += gcd(a,b,c)
#print(sum(dp[n-1][j] for j in range(k)))
#print(dp)
print(s)
|
import math
def pow(p,n):
bin_n=bin(n)[2:][::-1]
tmp=p;pn=1
for i in range(len(bin_n)):
if bin_n[i]=="1": pn=(pn*tmp)%mod
tmp=tmp*tmp%mod
return pn
mod=10**9+7
n,k=map(int,input().split())
ans=[0]*(k+1)
for i in range(k,0,-1):
div=set()
for x in range(1,int(i**0.5)+1):
if i%x==0: div.add(x);div.add(i//x)
ans[i]=pow(k//i,n)-sum([ans[j*i] for j in range(k//i,1,-1)])
ans[i]%=mod
print(sum(ans[i]*i for i in range(k+1))%mod)
| 1 | 36,810,331,599,190 | null | 176 | 176 |
a,b=map(int,input().split())
m=min(a,b)
kouyakusuu=1
for i in range(1,m+1):
if a%i==0 and b%i==0:
kouyakusuu=i
print(a*b//kouyakusuu)
|
A,B=map(int,input().split())
ma,mi=0,0
ma=max(A,B)
mi=min(A,B)
if A%B==0 or B%A==0:
print(ma)
else :
for i in range(2,ma+1):
if (ma*i)%mi==0:
print(ma*i)
break
i+=(mi-1)
| 1 | 113,445,390,858,330 | null | 256 | 256 |
def gcd(m, n):
while n:
m, n = n, m % n
return m
def lcm(m, n):
return m // gcd(m, n) * n
for line in open(0).readlines():
a, b = map(int, line.split())
print(gcd(a, b), lcm(a, b))
|
import math
while True:
try:
a, b = [int(i) for i in input().split()]
gcd = math.gcd(a, b)
lcm = a * b // gcd
print(f'{gcd} {lcm}')
except EOFError:
break
| 1 | 602,106,220 | null | 5 | 5 |
a, b, c = map(int,input().split())
time = a/c
if time <= b:
print('Yes')
else:
print('No')
|
X = int(input())
R = 8 - ((X - 400) // 200)
print(R)
| 0 | null | 5,111,107,205,788 | 81 | 100 |
a = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b = [int(input()) for _ in range(n)]
mark = [[False, False, False] for _ in range(3)]
for i in range(3):
for j in range(3):
if a[i][j] in b:mark[i][j] = True
ans = 'No'
for i in range(3):
if all(mark[i]):
ans = 'Yes'
break
for j in range(3):
if mark[0][j] and mark[1][j] and mark[2][j]:
ans = 'Yes'
break
if (mark[0][0] and mark[1][1] and mark[2][2]) or (mark[0][2] and mark[1][1] and mark[2][0]): ans = 'Yes'
print(ans)
|
import numpy as np
A = []
for i in range(3):
b = list(map(int, input().split()))
A.append(b)
N = int(input())
NP_A = np.array(A)
b = []
for n in range(N):
b.append(int(input()))
for n in range(N):
NP_A = np.where(NP_A==b[n], 0, NP_A)
ans = "No"
for i in range(2):
if 0 in NP_A.sum(axis=i):
ans = "Yes"
break
if ans == "Yes":
pass
else:
sum = 0
for i in range(3):
sum += NP_A[i, i]
if sum == 0:
ans = "Yes"
else:
sum = NP_A[0, 2] + NP_A[1, 1] + NP_A[2, 0]
if sum == 0:
ans = "Yes"
print(ans)
| 1 | 59,622,527,638,022 | null | 207 | 207 |
import sys
prime = lambda x: True if x==2 else False if x<2 or not x%2 else pow(2,x-1,x)==1
inp = sys.stdin.readlines()
print(len([prime(e) for e in list(map(int, inp[1:])) if prime(e)==1]))
|
import sys
import math
if __name__ == "__main__":
num = int(sys.stdin.readline().strip())
ans = 0
for i in range(0, num):
n = int(sys.stdin.readline().strip())
flag = False
for j in range(2, int(math.sqrt(n)) + 1):
if n % j == 0:
flag = True
break
if not flag:
ans += 1
print ans
| 1 | 10,967,118,782 | null | 12 | 12 |
n=int(input())
L=sorted(list(map(int,input().split())))
ans=0
for i in range(n):
for j in range(i+1,n):
l=j;r=n
while abs(l-r)>1:
mid=(r+l)//2
if L[i]<L[j]+L[mid] and L[j]<L[i]+L[mid] and L[mid]<L[i]+L[j]:
l=mid
else: r=mid
ans+=l-j
print(ans)
|
from bisect import bisect_left
n = int(input())
a = list(map(int,input().split()))
a.sort()
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
ind = bisect_left(a,a[i]+a[j])
ans += ind-j-1
print(ans)
| 1 | 172,274,345,805,458 | null | 294 | 294 |
def main():
S = input()
N = len(S)
S1 = S[0:(N - 1) // 2]
S2 = S[(N + 3) // 2 - 1:]
if S == S[::-1] and S1 == S1[::-1] and S2 == S2[::-1]:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
|
def main():
s = input()
n = len(s)
rule1 = True
rule2 = True
rule3 = True
for i in range(n):
if s[i] != s[n - 1 - i]:
rule1 = False
break
for i in range(n // 2):
if s[i] != s[n // 2 - 1 - i]:
rule2 = False
break
for i in range(n // 2):
if s[n // 2 + 1 + i] != s[n - 1 - i]:
rule3 = False
break
if rule1 and rule2 and rule3:
ans = "Yes"
else:
ans = "No"
print(ans)
if __name__ == "__main__":
main()
| 1 | 46,220,515,389,800 | null | 190 | 190 |
import sys
def main():
for line in sys.stdin:
a, b = map(int, line.split())
print(len(str(a + b)))
if __name__ == "__main__":
main()
|
import sys
strs = sys.stdin.readlines()
for s in strs:
a, b = map(int, s.split())
print(len(str(a + b)))
| 1 | 95,047,690 | null | 3 | 3 |
# input
N = int(input())
# 約数
def getDivs(n):
divs = [n]
for i in range(2, n):
if i * i > n:
break
if n % i == 0:
divs.append(i)
if i != n//i:
divs.append(n//i)
return divs
# process
if N == 2:
print(1)
else:
pf1 = getDivs(N)
pf2 = getDivs(N-1)
cnt = len(pf2)
for x in pf1:
n = N
while n%x == 0:
n //= x
n %= x
if n == 1:
cnt += 1
# print(pf1)
# print(pf2)
print(cnt)
|
n = int(input())
stmp = list(input())
Q = int(input())
target = ord("a")
s = [ord(stmp[i])-target for i in range(n)]
class BIT:
"""
<Attention> 0-indexed.
query ... return the sum [0 to m]
sum ... return the sum [a to b]
sumall ... return the sum [all]
add ... 'add' number to element (be careful that it doesn't set a value.)
search ... the sum version of bisect.right
output ... return the n-th element
listout ... return the BIT list
"""
def query(self, m):
res = 0
while m > 0:
res += self.bit[m]
m -= m&(-m)
return res
def sum(self, a, b):
return self.query(b)-self.query(a)
def sumall(self):
bitlen = self.bitlen-1
return self.query(bitlen)
def add(self, m, x):
m += 1
bitlen = len(self.bit)
while m <= bitlen-1:
self.bit[m] += x
m += m&(-m)
return
def __init__(self, n):
self.bitlen = n+1
self.bit = [0]*(n+1)
b = [BIT(n) for i in range(26)]
for i in range(n):
b[s[i]].add(i, 1)
for _ in range(Q):
q,qtmpa,qtmpb = input().split()
if q[0] == "1":
qa = int(qtmpa)
t = ord(qtmpb)-target
b[t].add(qa-1, 1)
b[s[qa-1]].add(qa-1, -1)
s[qa-1] = t
else:
ans = 0
qta = int(qtmpa)
qtb = int(qtmpb)
for i in range(26):
if b[i].sum(qta-1, qtb) != 0:
ans += 1
print(ans)
| 0 | null | 51,691,727,631,480 | 183 | 210 |
def check_p(packages, n, trucks, max_p):
i = 0
for _ in range(trucks):
sum = 0
while sum + packages[i] <= max_p:
sum += packages[i]
i += 1
if i == n:
return i
return i
n, k = map(int, input().split())
packages = []
for _ in range(n):
packages.append(int(input()))
left = 0
right = 10 ** 5 * 10 ** 4
while left + 1 < right:
mid = (left + right) // 2
num = check_p(packages, n, k, mid)
if num < n:
left = mid
else:
right = mid
print(right)
|
import sys
n,k = map(int,sys.stdin.readline().split())
T = [int(sys.stdin.readline()) for _ in range(n)]
def check(P):
i = 0
for j in range(k):
s = 0
while (s + T[i] <= P):
s += T[i]
i += 1
if i == n:
return n
return i
left = 0
right = 100000 * 10000
while (right - left > 1):
mid = (left + right)//2
v = check(mid)
if v >= n:
right = mid
else:
left = mid
print(right)
| 1 | 83,601,152,140 | null | 24 | 24 |
from sys import stdin, stdout
import math,sys,heapq
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
from os import path
import bisect as bi
def yes():print('YES')
def no():print('NO')
if (path.exists('input.txt')):
#------------------Sublime--------------------------------------#
sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
def I():return (int(input()))
def In():return(map(int,input().split()))
else:
#------------------PYPY FAst I/o--------------------------------#
def I():return (int(stdin.readline()))
def In():return(map(int,stdin.readline().split()))
def dict(a):
d={}
for x in a:
if d.get(x,-1)!=-1:
d[x]+=1
else:
d[x]=1
return d
def find_gt(a, x):
'Find leftmost value greater than x'
i = bi.bisect_right(a, x)
if i != len(a):
return i
else:
return -1
def main():
try:
a,b,c=In()
k=I()
t1,t2=0,0
if a>=b:
t1=0
while b<=a:
b*=2
t1+=1
if b>=c:
t2=0
while c<=b:
c*=2
t2+=1
#print(a,b,c)
if a<b and b<c:
if t1+t2<=k:
print('Yes')
else:
print('No')
else:
print('No')
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
#for _ in range(I()):main()
for _ in range(1):main()
|
n,a,b = map(int,input().split())
p = pow(10,9)+7
from functools import reduce
def comb(n,k,p):
A = reduce(lambda x,y:x*y%p ,[n-k+1+i for i in range(k)])
B = reduce(lambda x,y:x*y%p ,[i+1 for i in range(k)])
return A*pow(B,p-2,p)%p
print((pow(2,n,p)-comb(n,a,p)-comb(n,b,p)-1)%p)
| 0 | null | 36,484,790,358,560 | 101 | 214 |
from typing import List
def selection_sort(A: List[int]) -> int:
cnt = 0
for i in range(len(A)):
min_j = i
for j in range(i, len(A)):
if A[j] < A[min_j]:
min_j = j
if min_j != i:
cnt += 1
A[i], A[min_j] = A[min_j], A[i]
return cnt
N = int(input())
A = [int(i) for i in input().split()]
cnt = selection_sort(A)
print(' '.join(map(str, A)))
print(cnt)
|
N = int(input())
array = list(map(int, input().split()))
cnt = 0
for i in range(N):
minij = i
for j in range(i, N):
if array[j] < array[minij]:
minij = j
if minij != i:
array[i], array[minij] = array[minij], array[i]
cnt += 1
print(' '.join(map(str, array)))
print( "%d" % (cnt))
| 1 | 21,867,481,702 | null | 15 | 15 |
from collections import defaultdict
s = input()
rests = [0]
n = 0
a = 0
m = 1
c = defaultdict(int)
c[0] += 1
for i in list(s)[::-1]:
n = n + int(i)*m
c[n % 2019] += 1
m = m * 10 % 2019
for v in c.values():
a += v * (v-1) // 2
print(a)
|
s=input()
dic={}
cur=0
power=0
for i in range(0,len(s)+1):
s_int=len(s)-i-1
if cur in dic:
dic[cur]+=1
else:
dic[cur]=1
try:
num=int(s[s_int])
cur+=num*pow(10,power,2019)
cur%=2019
power+=1
except IndexError:
break
res=0
for i in range(len(dic)):
t=dic.popitem()
cc=t[1]
res+=cc*(cc-1)//2
print(res)
| 1 | 31,047,940,876,864 | null | 166 | 166 |
import sys
s = 'ACL'
n = int(sys.stdin.readline().rstrip("\n"))
print(s*n)
|
k = int(input())
l = []
for i in range(k):
l.append('ACL')
ans = ''.join(l)
print(ans)
| 1 | 2,162,988,240,588 | null | 69 | 69 |
N, M = map(int, input().split())
S = input()
if N <= M:
print(N)
exit()
if '1'*M in S:
print(-1)
exit()
from collections import deque
count = deque([])
for k in range(M+1):
if S[k] == '1':
count.append(-1)
else:
count.append(k)
sgn = deque([])
k = 0
while k < N:
k += 1
if S[k] == '0':
sgn.append(M)
else:
d = 0
while k < N:
if S[k] == '1':
k += 1
d += 1
continue
else:
break
while d > 0:
sgn.append(M-d)
d -= 1
sgn.append(M)
now = M
while now < N:
now += 1
a = sgn.popleft()
if S[now] == '1':
count.append(-1)
else:
count.append(a)
count = list(count)
c = 0
ans = ''
while c < N:
ans = str(count[-1-c]) + ' ' + ans
c += count[-1-c]
print(ans)
|
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, M = lr()
S = list(sr())[::-1]
answer = []
count = 0
cur = 0
while True:
next = cur
for i in range(M, 0, -1):
if cur + i > N:
continue
if S[cur+i] == '0':
count += 1
next = cur + i
answer.append(i)
break
else:
continue
if next == cur:
print(-1); exit()
cur = next
if next == N:
break
answer = answer[::-1]
print(*answer)
| 1 | 139,087,162,432,958 | null | 274 | 274 |
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
import sys
sys.setrecursionlimit(10000000)
#mod = 10**9 + 7
#mod = 9982443453
mod = 998244353
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
x = I()
xgcd = gcd(x,360)
xlcm = 360 * x // xgcd
print(xlcm//x)
|
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
X = int(input())
from math import gcd
print(360*X//gcd(360, X)//X)
| 1 | 13,248,061,507,022 | null | 125 | 125 |
#!/usr/bin/env python3
print(len({*open(0).read().split()}) - 1)
|
N = int(input())
BOX = {}
for i in range(N):
S = input()
if S in BOX:
BOX[S] = (BOX[S] + 1)
else:
BOX[S] = 0
MAX = max(BOX.values())
keys = [k for k, v in BOX.items() if v == MAX]
keys = sorted(keys)
for i in range(len(keys)):
print(keys[i])
| 0 | null | 49,806,322,943,482 | 165 | 218 |
n, k = map(int, input().split())
W = []
for _ in range(n):
w = int(input())
W.append(w)
Baggages = W[:]
def _check(tmp_P):
num_track = 1
tmp_sum = 0
for b in Baggages:
if tmp_sum+b <= tmp_P:
tmp_sum += b
else:
num_track += 1
tmp_sum = b
if num_track > k:
return False
return True
def check(P):
i = 0
for _ in range(k):
s = 0
while s+Baggages[i] <= P:
s += Baggages[i]
i += 1
if i >= n:
return True
if i == n:
return True
else:
return False
def binary_search(max_r):
left = 0
right = max_r
while right-left > 1:
mid = (left+right)//2
if check(mid) == True:
right = mid
else:
left = mid
return right
max_p = sum(Baggages)+1
ans = binary_search(max_p)
print(ans)
#print(check(4))
#print(check(5))
#print(check(6))
#print(check(7))
|
# -*- coding: utf_8 -*-
def check(t, n, k, p):
i = 0
for j in range(k):
s = 0
while (s + t[i] <= p):
s += t[i]
i += 1
if i == n:
return n
return i
if __name__ == "__main__":
n, k = [int (x) for x in input().split()]
t = []
for i in range(n):
t.append(int(input()))
start, end = 0, 10000 * 100000
while (end - start > 1):
mid = (start + end) // 2
v = check(t, n, k, mid)
if v >= n:
end = mid
else:
start = mid
print(end)
| 1 | 87,579,384,130 | null | 24 | 24 |
import sys
H, W, K = map(int, sys.stdin.readline().rstrip().split())
grid = [list(sys.stdin.readline().rstrip()) for _ in range(H)]
ans = [[-1] * W for _ in range(H)]
color = 0
for h in range(H):
flag = False
color += 1
for w in range(W):
if grid[h][w] == "#":
if not flag:
flag = True
else:
color += 1
ans[h][w] = color
if not flag:
for w in range(W):
ans[h][w] = -1
color -= 1
for w in range(W):
idx = []
color = -1
for h in range(H):
if ans[h][w] == -1:
if color != -1:
ans[h][w] = color
else:
idx.append(h)
else:
color = ans[h][w]
if idx:
for i in idx:
ans[i][w] = color
idx = []
for a in ans:
print(" ".join(map(str, a)))
|
import numpy as np
def solve():
ret = np.array([[1 for _ in range(W)] for _ in range(H)])
row_groups = np.array([0 for _ in range(H)])
row_group_set = set()
prev_row = 0
for row in range(H):
if '#' in s[row]:
row_groups[prev_row: row + 1] = row
row_group_set.add(row)
prev_row = row + 1
row_groups[prev_row: ] = prev_row - 1
cur_group_num = 1
for row in row_group_set:
prev_col = 0
for col in range(W):
if s[row][col] == '#':
ret[row][prev_col: col + 1] = cur_group_num
cur_group_num += 1
prev_col = col + 1
ret[row][prev_col: ] = cur_group_num - 1
for row, row_group_num in enumerate(row_groups):
if row in row_group_set:
continue
for col in range(W):
ret[row][col] = ret[row_group_num][col]
for row in ret:
print(' '.join(map(str, row.tolist())))
if __name__ == "__main__":
H, W, K = map(int, input().split())
s = []
for row in range(H):
s.append(list(input()))
solve()
| 1 | 143,122,572,262,908 | null | 277 | 277 |
import sys
n,m = map(int,input().split())
#input = sys.stdin.readline
sys.setrecursionlimit(10**9)
list1 = []
s = list(input())
s.reverse()
def maze(mass): #今いるマス、現状の手数
if mass+m >= n:
list1.append(n-mass)
return
for i in range(m,0,-1):
if s[mass+i] == "0":
list1.append(i)
maze(mass+i)
return
elif i == 1:
print(-1)
exit()
maze(0)
list1.reverse()
print(" ".join(map(str,list1)))
|
def solve():
N, X, M = map(int,input().split())
past_a = {X}
A = [X]
ans = prev = X
for i in range(1, min(M,N)):
next_a = prev ** 2 % M
if next_a in past_a:
loop_start = A.index(next_a)
loop_end = i
loop_size = loop_end - loop_start
loop_elem = A[loop_start:loop_end]
rest_n = N-i
ans += rest_n // loop_size * sum(loop_elem)
ans += sum(loop_elem[:rest_n%loop_size])
break
ans += next_a
past_a.add(next_a)
A.append(next_a)
prev = next_a
print(ans)
if __name__ == '__main__':
solve()
| 0 | null | 71,254,823,264,322 | 274 | 75 |
from itertools import combinations
N,M = map(int,input().split())
a=["A" for i in range(0,N)]
b=["B" for i in range(0,M)]
tmp1=(len(list(combinations(a,2))))
tmp2=(len(list(combinations(b,2))))
print(tmp1+tmp2)
|
n,m=map(int,input().split())
if (n>0) and (m>0):
print(int(n*(n-1)/2+m*(m-1)/2))
else:
print(int(max(n,m)*(max(n,m)-1)/2))
| 1 | 45,634,043,753,758 | null | 189 | 189 |
H, W, K = map(int, input().split())
cake = [input() for _ in range(H)]
# 答え
memo = [[0] * W for _ in range(H)]
#print(memo)
# 行にケーキが何個あるか
cake_count_row = [0] * H
for y in range(H):
count = 0
for x in range(W):
if cake[y][x] == "#":
count += 1
cake_count_row[y] = count
# イチゴがある行について色塗り
count = 1
for y in range(H):
first = True
if cake_count_row[y] == 0:
continue
for x in range(W):
if cake[y][x] == "#":
if first:
first = False
else:
count += 1
memo[y][x] = count
count += 1
# イチゴがない行について色塗り
# 上から下に
for y in range(1, H):
if cake_count_row[y] == 0:
for x in range(W):
memo[y][x] = memo[y-1][x]
# 下から上に
for y in range(H-1)[::-1]:
if cake_count_row[y] == 0:
for x in range(W):
memo[y][x] = memo[y+1][x]
# 出力
for i in range(H):
print(" ".join(list(map(str, memo[i]))))
|
s, t = map(str, input().split())
x = t + s
print(x)
| 0 | null | 123,120,818,511,360 | 277 | 248 |
import math
n = int(input())
if n%1000 == 0:
print(0)
else:
print(1000 - n%1000)
|
n,x,y=map(int,input().split())
x,y=x-1,y-1
c=[0 for i in range(n-1)]
for i in range(n):
for j in range(i+1,n):
l=min(j-i,abs(i-x)+abs(j-y)+1)
c[l-1]+=1
for i in range(n-1):
print(c[i])
| 0 | null | 26,136,860,691,760 | 108 | 187 |
if __name__ == "__main__":
N = int(input())
mod = N % 1000
q = N // 1000
if mod != 0:
q += 1
ans = 1000 * q - N
print(ans)
|
import random
name = str(input())
a = len(name)
if 3<= a <= 20:
b = random.randint(0,a-3)
ada_1 = name[b]
ada_2 = name[b+1]
ada_3 = name[b+2]
print(ada_1+ada_2+ada_3)
else:
None
| 0 | null | 11,572,866,633,062 | 108 | 130 |
import math
H = int(input())
W = int(input())
N = int(input())
if H >= W:
print(math.ceil(N / H))
else:
print(math.ceil(N / W))
|
from collections import defaultdict
charnums=defaultdict(int)
N=int(input())
for _ in range(N):
charnums[input()]+=1
ans=[]
m=max(charnums.values())
for key,value in charnums.items():
if value==m:
ans.append(key)
for an in sorted(ans):
print(an)
| 0 | null | 79,520,472,907,402 | 236 | 218 |
values = []
while True:
value = input().split()
if int(value[0]) == 0 and int(value[1]) == 0:
break
else:
values.append(value)
for value in values:
m = int(value[0])
n = int(value[1])
for i in range(m):
row_output = ""
for j in range(n):
if i == 0 or i == m -1:
row_output += "#"
else:
if j == 0 or j == n - 1:
row_output += "#"
else:
row_output += "."
print(row_output)
print()
|
def division(n):
if n < 2:
return []
prime_fac = []
for i in range(2,int(n**0.5)+1):
cnt = 0
while n % i == 0:
n //= i
cnt += 1
if cnt!=0:prime_fac.append((i,cnt))
if n > 1:
prime_fac.append((n,1))
return prime_fac
n = int(input())
div = division(n)
ans = 0
for i,e in div:
b = 1
while b <= e:
e -= b
b += 1
ans += 1
print(ans)
| 0 | null | 8,941,919,375,872 | 50 | 136 |
import math
a, b, x = [int(n) for n in input().split()]
v = a**2 * b /2
#print(v, x)
if v == x:
theta = math.atan(b/a)
elif v > x:
theta = math.atan(a*(b**2)/(2*x))
elif v < x:
theta = math.atan(2/a*(b-x/a**2))
print(math.degrees(theta))
|
x = int(input())
prlist = []
n = 2
sosuu = 0
answer = 0
while n**2 < x:
for i in prlist:
if n % i == 0:
sosuu = 1
break
if sosuu == 0:
prlist.append(n)
sosuu = 0
n += 1
sosuu = 1
while answer == 0:
for j in prlist:
if x % j == 0:
sosuu = 2
break
if sosuu == 1:
answer = x
sosuu = 1
x += 1
print(answer)
| 0 | null | 134,283,177,198,658 | 289 | 250 |
s = input()
if s.count('A') == 0 or s.count('B') == 0:
print('No')
else:
print('Yes')
|
from collections import defaultdict, deque
import sys, heapq, bisect, math, itertools, string, queue, copy, time
from fractions import gcd
import numpy as np
sys.setrecursionlimit(10**8)
INF = float('inf')
MOD = 10**9+7
EPS = 10**-7
s = input()
if s == 'AAA' or s == 'BBB':
ans = 'No'
else:
ans = 'Yes'
print(ans)
| 1 | 54,811,773,030,898 | null | 201 | 201 |
h,w,k=map(int,input().split())
b=[input()for _ in range(h)]
ans=[w*[0]for _ in range(h)]
f=[1]*h
j=-1
bb=[]
for i in range(h):
if "#"in b[i]:
f[i]=0
j=i
if len(bb)==0:continue
for k in bb:ans[k]=ans[j]
bb=[]
else:
if j<0:bb.append(i)
else:ans[i]=ans[j]
a=1
for i in range(h):
if f[i]:continue
fl=False
for j in range(w):
if b[i][j]=="#":
if fl:a+=1
fl=True
ans[i][j]=a
if fl:a+=1
for i in ans:print(*i)
|
import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
IN=lambda : map(int, input().split())
LIN=lambda : list(IN())
mod=1000000007
#+++++
def main():
#a = int(input())
h,w,k = IN()
ss=0
ret=[]
kv=1
for i in range(h):
wd = input()
if ss >= 0 and wd == '.'*w:
ss+=1
elif wd == '.'*w:
al=ret[-1][:]
ret.append(al)
else:
al=[]
stf=True
for c in wd:
if stf and c == '#':
stf = False
elif c == '#':
kv+=1
al.append(kv)
else:
kv+=1
if ss >= 0:
for i in range(ss+1):
ret.append(al)
ss=-1
else:
ret.append(al)
for l in ret:
print(*l)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| 1 | 143,661,937,653,322 | null | 277 | 277 |
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')
|
import heapq
X, Y, A, B, C = map(int, input().split())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
r = list(map(int, input().split()))
p.sort(reverse=True)
q.sort(reverse=True)
p = p[:X]
q = q[:Y]
all_apples = p + q + r
all_apples.sort(reverse=True)
print(sum(all_apples[:X+Y]))
| 0 | null | 34,227,699,151,008 | 152 | 188 |
cnt=0
radi=0
x=int(input())
while True:
cnt+=1
radi+=x
radi%=360
if radi==0:
print(cnt)
break
|
def abc178c():
n = int(input())
print((pow(10, n) - pow(9, n) - pow(9, n) + pow(8, n)) % (pow(10, 9) + 7))
abc178c()
| 0 | null | 8,096,666,701,408 | 125 | 78 |
n=int(input())
A=set()
for i in range(n):
x,y=input().split()
if x == 'insert':
A.add(y)
else:
print('yes'*(y in A)or'no')
|
#alds13c
from collections import deque
class DoubleLinkyList:
def __init__(self):
self.lst=[]
def insert(self,x):
self.lst.insert(0,x)
def delete_x(self,x):
if x in self.lst:
self.lst.pop(self.lst.index(x))
def deleteFirst(self):
self.lst.pop(0)
def deleteLast(self):
self.lst.pop(-1)
n = int(input())
dll = deque()
for i in range(n):
A = input().split(" ")
if A[0] == "insert":
dll.appendleft((A[1]))
#continue
if A[0] == "delete" and A[1] in dll:
dll.remove((A[1]))
if A[0]=="deleteFirst":
dll.popleft()
if A[0]=="deleteLast":
dll.pop()
result = list(dll)
print(" ".join(result))
#print(dll)
| 0 | null | 64,849,101,730 | 23 | 20 |
print((int(input())) ** 3)
|
import sys
x = sys.stdin.readline()
x3 = int(x) * int(x) * int(x)
print x3
| 1 | 274,155,502,280 | null | 35 | 35 |
N = input()
while N != "0":
SUM = 0
for i in N:
SUM += int(i)
print(SUM)
N = input()
|
def main():
N = input()
L = len(N)
K = int(input())
dp = [[0 for _ in range(L + 1)] for _ in range(K + 1)]
dpp = [[0 for _ in range(L + 1)] for _ in range(K + 1)]
dpp[0][0] = 1
for i in range(1, L + 1):
n = int(N[i - 1])
for k in range(K + 1):
# from dpp
kk = k + (1 if n > 0 else 0)
if kk <= K:
dpp[kk][i] = dpp[k][i - 1]
if n > 0:
dp[k][i] += dpp[k][i - 1]
if k + 1 <= K:
dp[k + 1][i] += (n - 1) * dpp[k][i - 1]
# from dp
dp[k][i] += dp[k][i - 1]
if k + 1 <= K:
dp[k + 1][i] += 9 * dp[k][i - 1]
print(dp[K][L] + dpp[K][L])
if __name__ == '__main__':
main()
| 0 | null | 38,653,852,999,014 | 62 | 224 |
H,W,K=map(int,input().split())
S=[input() for i in range(H)]
P=[[0 for i in range(W)] for m in range(H)]
for h in range(H):
if "#" in S[h]:
front=h
break
m=0
x=0
for w in range(W):
if S[front][w]=="#":
m+=1
for z in range(x,w+1):
P[front][z]=m
x=w+1
for z in range(x,W):
P[front][z]=m
for h in range(front-1,-1,-1):
for w in range(W):
P[h][w]=P[h+1][w]
for h in range(front+1,H):
if "#" in S[h]:
x=0
for w in range(W):
if S[h][w]=="#":
m+=1
for z in range(x,w+1):
P[h][z]=m
x=w+1
for z in range(x,W):
P[h][z]=m
else:
for w in range(W):
P[h][w]=P[h-1][w]
for h in range(H):
print(" ".join(list(map(str,P[h]))))
|
def divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n%i == 0:
divisors.append(i)
if i != n//i:
divisors.append(n//i)
return sorted(divisors)
N = int(input())
ans = len(divisors(N-1)) -1
for k in divisors(N)[1:]:
N_ = N
while N_ % k == 0:
N_ = N_//k
if N_ % k == 1:
ans += 1
print(ans)
| 0 | null | 92,844,820,340,808 | 277 | 183 |
money = int(input())
count_div_500, left_after_500 = divmod(money, 500)
count_div_5, left_after_5 = divmod(left_after_500, 5)
print(count_div_500 * 1000 + count_div_5 * 5)
|
X = int(input())
a = X // 500 # 500円硬貨の枚数
X = X % 500 # 端数
b = X // 5 # 5円硬貨の枚数
print(a*1000+b*5)
| 1 | 42,613,935,830,268 | null | 185 | 185 |
import itertools
import math
#print(3 & (1 << 0))
def main():
N = int(input())
items = [i+1 for i in range(N)]
locations=[]
for i in range(N):
locations.append(list(map(int, input().split())))
paths =list(itertools.permutations(items))
sum = 0
for path in paths: # path = [1,2,3,4,5]
for i in range(len(path)-1):
from_idx = path[i] -1
to_idx = path[i+1] -1
xdiff= locations[from_idx][0] - locations[to_idx][0]
ydiff= locations[from_idx][1] - locations[to_idx][1]
sum = sum + math.sqrt(xdiff**2 + ydiff**2)
print( sum / len(paths))
main()
|
N = int(input())
x = [0]*N
y = [0]*N
dist = [[0]*N]*N
ans = 0
for i in range(N):
x[i],y[i]=map(int, input().split())
for i in range(N):
for j in range(N):
dist[i][j]=((x[i]-x[j])**2+(y[i]-y[j])**2)**0.5
ans += dist[i][j]
print(ans/N)
| 1 | 148,440,858,475,300 | null | 280 | 280 |
#!/usr/bin/env python3
val1 = input()
if int(val1) >= 30:
print("Yes")
else:
print("No")
|
print('Yes') if int(input())>=30 else print('No')
| 1 | 5,751,685,943,318 | null | 95 | 95 |
N,M = map(int,input().split())
from collections import deque
g = [[] for _ in range(N)]
for _ in range(M):
a,b = map(int,input().split())
g[a-1].append(b-1)
g[b-1].append(a-1)
dist = [float('inf')]*(N)
ans = [0]*N
dist[0] = 0
q = deque([])
q.append((0,0))
while q:
idx,d = q.popleft()
for nxt in g[idx]:
if d + 1 < dist[nxt]:
ans[nxt] = idx+1
dist[nxt] = d+1
q.append((nxt,d+1))
for i in range(N):
if dist[i]==float('inf'):
print('No');exit()
print('Yes')
for i in range(1,N):
print(ans[i])
|
from collections import*
(n,m),*c = [[*map(int,i.split())]for i in open(0)]
g = [[]for _ in range(n+1)]
for a,b in c:
g[a]+=[b]
g[b]+=[a]
q=deque([1])
r=[0]*(n+1)
while q:
v=q.popleft()
for i in g[v]:
if r[i]==0:
r[i]=v
q.append(i)
print("Yes",*r[2:],sep="\n")
| 1 | 20,625,114,977,082 | null | 145 | 145 |
N, K = map(int, input().split())
A = tuple(map(int, input().split()))
MOD = 10 ** 9 + 7
if K == N:
ans = 1
for x in A:
ans = (ans * x) % MOD
print(ans)
exit()
plus, minus = [], []
for a in A:
if a >= 0:
plus.append(a)
else:
minus.append(a)
plus.sort(reverse=True)
minus.sort()
if not plus:
ans = 1
if K % 2:
# 答えは負値になるので絶対値小さいのを取る
for x in minus[-K:]:
ans = (ans * x) % MOD
else:
# 答えは非負値になるので絶対値大きいのを取る
for x in minus[:K]:
ans = (ans * x) % MOD
print(ans)
exit()
idx = 0
for i in range(2, N, 2):
if K - i < 0:
break
if not len(plus) >= K - i + 2:
idx += 2
continue
if len(minus) >= i:
if minus[i - 2] * minus[i - 1] < plus[K - i + 1] * plus[K - i]:
break
else:
idx += 2
ans = 1
for x in minus[:idx] + plus[:K - idx]:
ans = (ans * x) % MOD
print(ans)
|
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
plus = []
zero = []
minus = []
ans = 1
for k in range(N):
if A[k] > 0:
plus.append(A[k])
elif A[k] < 0:
minus.append(-1 * A[k])
else:
zero.append(A[k])
plus.sort(reverse = True)
minus.sort(reverse = True)
lp = len(plus)
lm = len(minus)
lz = len(zero)
if lz + K > N:
print(0)
exit()
elif lp == 0:
if K % 2 == 1:
if lz > 0:
print(0)
exit()
else:
for k in range(K):
ans = ans * (-1) * minus[- k - 1] % mod
print(ans)
exit()
else:
for k in range(K):
ans = ans * (-1) * minus[k] % mod
print(ans)
exit()
elif lm == 0:
for k in range(K):
ans = ans * plus[k] % mod
print(ans)
exit()
p = 0
m = 0
for k in range(K):
if plus[p] >= minus[m]:
p += 1
if p == lp:
m = K - p
break
else:
m += 1
if m == lm:
p = K - m
break
def main(mp, mm, plus, minus):
mod = 10 ** 9 + 7
ans = 1
for k in range(mp):
ans = ans * plus[k] % mod
for k in range(mm):
ans = ans * (-1) * minus[k] % mod
print(ans)
exit()
if m % 2 == 0:
main(p, m, plus, minus)
else:
if p == lp:
if m != lm:
main(p - 1, m + 1, plus, minus)
else:
if lz > 0:
print(0)
exit()
else:
main(p, m, plus, minus)
elif m == lm:
main(p + 1, m - 1, plus, minus)
elif p == 0:
main(p + 1, m - 1, plus, minus)
else:
if plus[p] * plus[p - 1] > minus[m - 1] * minus[m]:
main(p + 1, m - 1, plus, minus)
else:
main(p - 1, m + 1, plus, minus)
| 1 | 9,431,041,685,852 | null | 112 | 112 |
n = int(input())
#a, b, c, x, y = map(int, input().split())
#al = list(map(int, input().split()))
#al=[list(input()) for i in range(n)]
x = 1
mn = n-1
while x**2 <= n:
if n % x == 0:
y = n//x
mn = min(mn, x+y-2)
x+=1
print(mn)
|
def insertionSort(R, n):
for i in range(1, n):
Now = R[i]
j = i - 1
while j >= 0 and R[j] > Now:
R[j + 1] = R[j]
j = j - 1
R[j + 1] = Now
trace(R, n)
def trace(R, n):
for i in range(n):
print R[i],
print
n = input()
R = map(int, raw_input().split())
trace(R, n)
insertionSort(R, n)
| 0 | null | 80,989,374,041,760 | 288 | 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.