code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
178,025B
⌀ | question_pair_id
float64 27.1M
177,113B
⌀ | code1_group
int64 1
297
| code2_group
int64 1
297
|
|---|---|---|---|---|---|---|
table = []
i = 0
while True:
table.append(int(input()))
if table[i] == 0:
break
i += 1
for num in table:
if num == 0:
break
sum = 0
i = 0
while num != 0:
sum += num % 10
num //= 10
if num == 0:
break
print(sum)
|
import math
N = int(input())
cnt_list = [0] * N
for i in range(1, N + 1):
for j in range(i, N + 1, i):
cnt_list[j - 1] += 1
ans = 0
for h in range(1, N + 1):
ans += h * cnt_list[h -1]
print(ans)
| 0 | null | 6,372,013,800,220 | 62 | 118 |
n, m = map(int, input().split())
c = list(map(int, input().split()))
dp = [float('inf') for _ in range(n + 10001)]
dp[0] = 0
for i in range(n):
for j in c:
dp[i + j] = min(dp[i + j], dp[i] + 1)
print(dp[n])
|
n, m = map(int, input().split())
c = list(map(int, input().split()))
dp = [0] * (n+1)
for i in range(1, n+1):
dpi = 10 ** 9
for j in range(m):
if(i-c[j]>=0):
tmp = dp[i-c[j]] + 1
if(tmp < dpi):
dpi = tmp
dp[i] = dpi
print(dp[n])
| 1 | 139,871,591,552 | null | 28 | 28 |
import math
n = int(input())
x = list(map(float, (input().split())))
y = list(map(float, (input().split())))
l = [0.0]*n
for i in range(n):
l[i] = abs(x[i]-y[i])
print(sum(l))
che = max(l)
for i in range(n):
l[i] = abs(x[i]-y[i])**2
print(math.sqrt(sum(l)))
for i in range(n):
l[i] = abs(x[i]-y[i])**3
print(math.pow(sum(l), 1.0/3.0))
print(che)
|
a,b,c = map(int, input().split())
a_b = a==b
b_c = b==c
a_c = a==c
if a_b and b_c and a_c:
print("No")
elif a_b or b_c or a_c:
print("Yes")
else:
print("No")
| 0 | null | 34,238,619,745,036 | 32 | 216 |
import sys
S = int(sys.stdin.readline())
h = S / 3600
m = (S - h*3600)/60
s = S - h*3600 - m*60
print("%d:%d:%d" % (h,m,s))
|
S = int(input())
h = int(S/3600)
m = int((S-h*3600)/60)
s = int(S-h*3600-m*60)
time = [h, m, s]
time_str = map(str,time)
print(":".join(time_str))
| 1 | 336,313,158,412 | null | 37 | 37 |
import sys
import math
input = sys.stdin.readline
A, B = map(int, input().split())
X = A / 0.08
Y = B/0.1
for i in range(math.floor(min(X, Y)), math.ceil(max(X, Y)) + 1):
if int(i * 0.08) == A and int(i * 0.10) == B:
print(i)
exit()
print(-1)
|
import math
A,B=map(int,input().split())
eight=[]
i=0
ten=[]
for a in range(1,1001):
if math.floor(a*0.08)==A:
eight.append(a)
if math.floor(a*0.1)==B:
ten.append(a)
for a in eight:
if a in ten:
print(a)
i=1
break
if i==0:
print("-1")
| 1 | 56,236,266,114,314 | null | 203 | 203 |
N = int(input())
a = list(map(int,input().split()))
aset = set(a)
if 1 not in aset:
print(-1)
else:
nex = 1
counter = 0
for i in range(N):
if a[i] == nex:
nex += 1
else:
counter += 1
print(counter)
|
N=int(input());A=list(map(int,input().split()));j=1;fg=0
if N==1:
if A[0]==1:print(0)
else: print(-1)
else:
for i in A:
if i==j:j+=1
else:fg+=1
if j>1:print(fg)
else: print(-1)
| 1 | 114,351,494,538,708 | null | 257 | 257 |
from collections import defaultdict
from math import gcd
def main():
mod = 10 ** 9 + 7
worst_iwashi_count = 0
ans = 1
d = defaultdict(int)
N = int(input())
for _ in range(N):
a, b = map(int, input().split())
if a == 0 and b == 0:
worst_iwashi_count += 1
elif a == 0:
d[(0, -1)] += 1
elif b == 0:
d[(1, 0)] += 1
else:
g = gcd(abs(a), abs(b))
if a * b > 0:
d[(abs(a // g), abs(b // g))] += 1
else:
d[(abs(a // g), -abs(b // g))] += 1
done_set = set()
for a, b in list(d):
if (a, b) in done_set:
continue
x = d[(a, b)]
done_set.add((a, b))
if b >= 0:
y = d[(b, -a)]
done_set.add((b, -a))
else:
y = d[(-b, a)]
done_set.add((-b, a))
ans *= 2 ** x + 2 ** y - 1
ans %= mod
ans += worst_iwashi_count - 1
print(ans % mod)
if __name__ == '__main__':
main()
|
N = int(input())
A = list(map(int, input().split()))
s = 0
height = 0
for a in A:
height = max(height, a)
s += height - a
print(s)
| 0 | null | 12,840,876,455,428 | 146 | 88 |
H,W = map(int, input().split())
S = [input() for _ in range(H)]
inf = 10**6
L = [[inf]*W for _ in range(H)]
if S[0][0] == ".":
L[0][0] = 0
else:
L[0][0] = 1
for i in range(H):
for j in range(W):
n1 = inf
n2 = inf
if i > 0:
if S[i-1][j] == "." and S[i][j] == "#":
n1 = L[i-1][j] + 1
else:
n1 = L[i-1][j]
if j > 0:
if S[i][j-1] == "." and S[i][j] == "#":
n2 = L[i][j-1] + 1
else:
n2 = L[i][j-1]
L[i][j] = min(L[i][j], n1, n2)
print(L[-1][-1])
|
n = int(input())
if n%2 == 1:
print(0)
exit()
num = 5
i = 1
ans = 0
while num**i < n:
ans += n//num**i//2
i += 1
print(ans)
| 0 | null | 82,877,283,572,942 | 194 | 258 |
A, B = list(map(float,input().split()))
result = int(A * B)
print(result)
|
#!/usr/bin/env python3
import sys
def solve(A: int, B: int):
print(A*B)
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
solve(A, B)
if __name__ == '__main__':
main()
| 1 | 15,737,469,546,240 | null | 133 | 133 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
S = input()
cnt = 0
mx = 0
for i in range(len(S)):
if (S[i] == 'R'):
cnt += 1
else:
cnt = 0
mx = max(mx, cnt)
print(mx)
if __name__ == '__main__':
main()
|
s = input()
ans = 0
for i in range(3):
if s[i] == "R":
ans = 1
for i in range(2):
if s[i:i+2] == "RR":
ans = 2
if s == "RRR":
ans = 3
print(ans)
| 1 | 4,848,417,476,650 | null | 90 | 90 |
tmp = input().split(" ")
S = int(tmp[0])
W = int(tmp[1])
if S <= W:
print("unsafe")
else:
print("safe")
|
def main():
S, W = list(map(int, input().split()))
print("unsafe" if S <= W else "safe")
pass
if __name__ == '__main__':
main()
| 1 | 29,223,584,429,270 | null | 163 | 163 |
S = input()
l_s = len(S)
cnt = 0
for i in range(0,l_s//2):
if S[i] != S[-i-1]:
cnt += 1
print(cnt)
|
X,Y = map(int,input().split())
MAX_NUM = 10**6 + 1
MOD = 10**9+7
fac = [0 for _ in range(MAX_NUM)]
finv = [0 for _ in range(MAX_NUM)]
inv = [0 for _ in range(MAX_NUM)]
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,MAX_NUM):
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
if (X+Y)%3 != 0:
answer = 0
else:
up = -(X+Y)//3+Y
right = -(X+Y)//3+X
answer = combinations(up+right,up)
print(answer)
| 0 | null | 134,963,940,557,262 | 261 | 281 |
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
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
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N,M,L = IL()
class WarshallFloyd():
def __init__(self, N):
self.N = N
self.d = [[float("inf") for i in range(N)] for i in range(N)]
def add(self, u, v, c, directed=False):
if directed is False:
self.d[u][v] = c
self.d[v][u] = c
else:
self.d[u][v] = c
def WarshallFloyd_search(self):
for k in range(self.N):
for i in range(self.N):
for j in range(self.N):
self.d[i][j] = min(self.d[i][j], self.d[i][k] + self.d[k][j])
hasNegativeCycle = False
for i in range(self.N):
if self.d[i][i] < 0:
hasNegativeCycle = True
break
for i in range(self.N):
self.d[i][i] = 0
return hasNegativeCycle, self.d
W = WarshallFloyd(N)
for _ in range(M):
u,v,c = IL()
if c>L: continue
W.add(u-1,v-1,c)
_,d = W.WarshallFloyd_search()
W = WarshallFloyd(N)
for u in range(N):
for v in range(u+1,N):
if d[u][v] > L: continue
W.add(u,v,1)
_,d = W.WarshallFloyd_search()
Q = I()
for _ in range(Q):
s,t = IL()
if d[s-1][t-1] == INF:
print(-1)
else:
print(d[s-1][t-1]-1)
|
import sys
input = sys.stdin.readline
def main():
N, M, L = map(int, input().split())
dist = [[float('inf')] * N for _ in range(N)]
for _ in range(M):
A, B, C = map(int, input().split())
if C > L:
continue
A -= 1
B -= 1
dist[A][B] = C
dist[B][A] = C
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
e = [[float('inf')] * N for _ in range(N)]
for i in range(N):
for j in range(N):
if dist[i][j] <= L:
e[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
e[i][j] = min(e[i][j], e[i][k] + e[k][j])
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if e[s][t] == float('inf'):
print(-1)
continue
ans = e[s][t]
print(ans-1)
if __name__ == "__main__":
main()
| 1 | 174,147,580,734,622 | null | 295 | 295 |
import math
while True :
n = int(input())
if n==0:
break;
i = list(map(int, input().split(' ')))
avg = sum(i)/n
j = list(map(lambda x: (x-avg)**2, i))
print("{:.5f}".format(math.sqrt(sum(j)/n)))
|
# ABC149
# B Greesy Takahashi
# takはA枚、aokiはB枚、TAKはK回
a, b, k = map(int, input().split())
if k > a:
if k - a > b:
print(0,0)
else:
print(0,b - (k - a))
else:
print(a-k,b)
| 0 | null | 52,505,141,480,280 | 31 | 249 |
A, B, K = map(int, input().split())
if A < K:
K = K - A
A = 0
elif A == K:
A = 0
K = 0
else: # K < A
A = A - K
K = 0
if B < K:
K = K - B
B = 0
elif B == K:
B = 0
K = 0
else: # K < B
B = B - K
K = 0
print(A, B)
|
def function(arg):
xyabc, pa, qb, rc = arg.split('¥n')
X,Y,A,B,C = map(int, xyabc.split())
oishisa_A = list(map(int, pa.split()))
oishisa_B = list(map(int, qb.split()))
oishisa_C = list(map(int, rc.split()))
oishisa_A.sort(reverse=True)
oishisa_A = oishisa_A[:X] # at most X
oishisa_B.sort(reverse=True)
oishisa_B = oishisa_B[:Y] # at most Y
oishisa_C.sort(reverse=True)
oishisa = oishisa_A + oishisa_B + oishisa_C
oishisa.sort(reverse=True)
results = 0
for i in range(X+Y):
results += oishisa[i]
return results
if __name__ == '__main__':
xyabc = input()
pa = input()
qb = input()
rc = input()
print(function(xyabc+'¥n'+pa+'¥n'+qb+'¥n'+rc))
| 0 | null | 74,624,369,973,022 | 249 | 188 |
import sys
import math
n, m, l = map(int, raw_input().split())
A = [[0 for i in xrange(m)] for j in xrange(n)]
B = [[0 for i in xrange(l)] for j in xrange(m)]
for i in xrange(n):
A[i] = map(int, raw_input().split())
for i in xrange(m):
B[i] = map(int, raw_input().split())
for i in xrange(n):
for j in xrange(l):
sm = 0
for k in xrange(m):
sm += A[i][k] * B[k][j]
sys.stdout.write(str(sm))
if j < l-1:
sys.stdout.write(" ")
print
|
n, m, l = [int(s) for s in input().split()]
A = []
B = []
C = [[0 for i in range(l)] for i in range(n)]
for i in range(n):
A.append([int(s) for s in input().split()])
for i in range(m):
B.append([int(s) for s in input().split()])
for i,row in enumerate(C):
for j in range(len(row)):
for k in range(m):
C[i][j] += A[i][k] * B[k][j]
for row in C:
print(' '.join([str(i) for i in row]))
| 1 | 1,443,031,109,930 | null | 60 | 60 |
A, B = map(int, input().split())
for i in range(1001):
if int(i * 0.08) == A and int(i * 0.1) == B:
print(i)
exit()
print(-1)
|
import sys
print('10'[int(sys.stdin.buffer.readline())])
| 0 | null | 29,763,270,923,750 | 203 | 76 |
n, a, b = map(int, input().split())
ret = 0
ret += a*(n//(a+b))
rem = n%(a+b)
ret += min(rem, a)
print(ret)
|
s = input()
ret = s[:3]
print("{}".format(ret))
| 0 | null | 35,161,611,746,360 | 202 | 130 |
r=int(input())
r0=1*1
s1=r*r
s=s1/r0
print('%d'%s)
|
"""
author : halo2halo
date : 9, Jan, 2020
"""
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N = int(readline())
print(int(N**2))
| 1 | 145,912,105,009,060 | null | 278 | 278 |
def solve():
K, X = map(int, input().split())
return "Yes" if K*500 >= X else "No"
print(solve())
|
N, M, X = map(int, input().split())
book_lists = [list(map(int, input().split())) for _ in range(N)]
max_cost = 10**5*12+1
min_cost = max_cost
for i in range(1, 2**N):
score_list = [0 for _ in range(M)]
cost = 0
for j in range(N):
if i >> j & 1:
cost += book_lists[j][0]
for k in range(M):
score_list[k] += book_lists[j][k+1]
if min(score_list) >= X:
min_cost = min(cost, min_cost)
print(min_cost if not min_cost == max_cost else -1)
| 0 | null | 60,283,614,084,060 | 244 | 149 |
S = input()
Q = int(input())
flag = True
from collections import deque
que=deque(S)
for i in range(Q):
a = input().split()
if a[0]=="1":
flag = not flag
else:
f = a[1]
c = a[2]
if f=="1":
if flag:
que.appendleft(c)
else:
que.append(c)
else:
if flag:
que.append(c)
else:
que.appendleft(c)
if not flag:
que.reverse()
print("".join(que))
|
import sys
def input(): return sys.stdin.readline().rstrip()
# ライブラリ参照https://atcoder.jp/contests/practice2/submissions/16580070
class SegmentTree:
__slots__ = ["func", "e", "original_size", "n", "data"]
def __init__(self, length_or_list, func, e):
self.func = func
self.e = e
if isinstance(length_or_list, int):
self.original_size = length_or_list
self.n = 1 << ((length_or_list - 1).bit_length())
self.data = [self.e] * self.n
else:
self.original_size = len(length_or_list)
self.n = 1 << ((self.original_size - 1).bit_length())
self.data = [self.e] * self.n + length_or_list + \
[self.e] * (self.n - self.original_size)
for i in range(self.n-1, 0, -1):
self.data[i] = self.func(self.data[2*i], self.data[2*i+1])
def replace(self, index, value):
index += self.n
self.data[index] = value
index //= 2
while index > 0:
self.data[index] = self.func(
self.data[2*index], self.data[2*index+1])
index //= 2
def folded(self, l, r):
left_folded = self.e
right_folded = self.e
l += self.n
r += self.n
while l < r:
if l % 2:
left_folded = self.func(left_folded, self.data[l])
l += 1
if r % 2:
r -= 1
right_folded = self.func(self.data[r], right_folded)
l //= 2
r //= 2
return self.func(left_folded, right_folded)
def all_folded(self):
return self.data[1]
def __getitem__(self, index):
return self.data[self.n + index]
def max_right(self, l, f):
# assert f(self.e)
if l >= self.original_size:
return self.original_size
l += self.n
left_folded = self.e
while True:
# l //= l & -l
while l % 2 == 0:
l //= 2
if not f(self.func(left_folded, self.data[l])):
while l < self.n:
l *= 2
if f(self.func(left_folded, self.data[l])):
left_folded = self.func(left_folded, self.data[l])
l += 1
return l - self.n
left_folded = self.func(left_folded, self.data[l])
l += 1
if l == l & -l:
break
return self.original_size
# 未verify
def min_left(self, r, f):
# assert f(self.e)
if r == 0:
return 0
r += self.n
right_folded = self.e
while True:
r //= r & -r
if not f(self.func(self.data[r], right_folded)):
while r < self.n:
r = 2 * r + 1
if f(self.func(self.data[r], right_folded)):
right_folded = self.func(self.data[r], right_folded)
r -= 1
return r + 1 - self.n
if r == r & -r:
break
return 0
def orr(x, y):
return x | y
def main():
N = int(input())
S = input()
S = list(map(lambda c: 2**(ord(c) - ord('a')), list(S)))
Q = int(input())
seg = SegmentTree(S, orr, 0)
for _ in range(Q):
num, x, y = input().split()
if num == '1':
seg.replace(int(x)-1, 2**(ord(y) - ord('a')))
else:
bits = seg.folded(int(x)-1, int(y))
print(sum(map(int, list(bin(bits))[2:])))
if __name__ == '__main__':
main()
| 0 | null | 59,643,883,850,518 | 204 | 210 |
print(sum(n for n in range(1+int(input())) if n%3 and n%5))
|
import sys
input = sys.stdin.readline
N = int(input())
ans = 0
for i in range(1,N+1):
if i%3 != 0 and i%5 !=0:
ans += i
print(ans)
| 1 | 35,000,184,785,900 | null | 173 | 173 |
x=int(input())
num1=-((x%100)//-5)
num2=x//100
if num1>num2:
print(0)
else:
print(1)
|
import sys
sys.setrecursionlimit(1000000)
def main():
a, b, c, d = map(int, input().split())
max_ab = max(a, b)
min_ab = min(a,b)
max_cd = max(c,d)
min_cd = min(c,d)
# ab ++
if min_ab >= 0:
# cd ++
if min_cd >= 0:
# ++
print(max_ab * max_cd)
# cd +-
elif max_cd >= 0:
# ++
print(max_ab * max_cd)
# cd --
else:
# +-
print(min_ab * max_cd)
# ab +-
elif max_ab >= 0:
# cd ++
if min_cd >= 0:
# ++
print(max_ab * max_cd)
# cd +-
elif max_cd >= 0:
# ++ or --
print(max(max_ab * max_cd, min_ab * min_cd))
# cd --
else:
# --
print(min_ab * min_cd)
# ab --
else:
# cd ++
if min_cd >= 0:
# -+
print(max_ab * min_cd)
# cd +-
elif max_cd >= 0:
# --
print(min_ab * min_cd)
# cd --
else:
# --
print(min_ab * min_cd)
main()
| 0 | null | 64,929,932,915,120 | 266 | 77 |
n,m = map(int,input().split())
AB = [[] for _ in range(n)]
for i in range(m):
a,b = map(int,input().split())
AB[a-1].append(b-1)
AB[b-1].append(a-1)
visited = set()
ans = [0]*n
stack = [0]
for i in stack:
# このへんあやしい
for j in AB[i]:
if j in visited:
continue
visited.add(j)
ans[j] = i+1
stack.append(j)
# このへんまで
for i in ans[1:]:
if i==0:
print('No')
exit()
print('Yes')
for i in ans[1:]:
print(i)
|
# ABC168D
# https://atcoder.jp/contests/abc168/tasks/abc168_d
n,m=map(int, input().split())
ab=[[]for _ in range(n)]
for i in range(m):
a,b = list(map(int, input().split()))
a,b = a-1, b-1
ab[a].append(b)
ab[b].append(a)
'''
まず両方を追加する考えがなかった。
浅い部屋からも深い部屋からも参照できる。
その代わりに visitedで考えなくて良い部屋を記録している。
部屋１につながっているのはもっとも浅い部屋でそこから考えることがきっかけになる？
'''
#print(ab)
ans = [0]*n
visited={0}
stack=[0]
for i in stack:
'''
現在考えている部屋を stack、そこにつながる部屋 ab[i]として考える。
stack=[0]なので1の部屋から始める。なので深さ1の部屋が ab[i](ab[0])で分かる。
i==0の始めの一周では、ab[i]は深さ１の部屋のリストであり、それぞれの部屋を jとして順番に考える。
(このように深さ1から考えられる＋次に深さ2の部屋を求めるというのが上手くいく)
その現在考えている部屋 i(stackの循環)とそこにつながる部屋 j(abの循環)なので、
部屋 jはより浅い部屋 iを道しるべにすればよい。
しかし、ab[a], ab[b]と両方を追加しているので、浅い部屋も深い部屋も abには含まれている。
浅い部屋から順に考えているので、過去に調べた abの値は無視するために visitedを導入する。たぶん。
'''
for j in ab[i]:
#print(i,j,'----------------------')
if j in visited:
continue
stack.append(j)
visited.add(j)
ans[j]=i+1
#print('stack', stack)
#print('visited', visited)
#print('ans', ans)
check=0
for i in ans[1:]:
if i==0:check==1
if check:
print('No')
else:
print("Yes")
print(*ans[1:])
| 1 | 20,528,607,560,090 | null | 145 | 145 |
def main():
K, X = map(int, input().split())
if 500 * K >= X:
ans = "Yes"
else:
ans = "No"
print(ans)
if __name__ == "__main__":
main()
|
def f_strivore(MOD=10**9 + 7):
K = int(input())
S = input()
length = len(S)
class Combination(object):
"""素数 mod に対する二項係数の計算"""
__slots__ = ['mod', 'fact', 'factinv']
def __init__(self, max_val_arg: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_val_arg + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], -1, mod))
for i in range(max_val_arg, 0, -1):
inv_append((inv[-1] * i) % mod)
self.mod, self.fact, self.factinv = mod, fac, inv[::-1]
def combination(self, n, r):
return (0 if n < 0 or r < 0 or n < r
else self.fact[n] * self.factinv[r] * self.factinv[n - r] % self.mod)
comb = Combination(length + K).combination
f = [1] * (K + 1)
tmp = 1
for n in range(K + 1):
f[n] = (comb(length + n - 1, length - 1) * tmp) % MOD
tmp = (tmp * 25) % MOD
g = [1] * (K + 1)
for n in range(1, K + 1):
g[n] = (f[n] + 26 * g[n - 1]) % MOD
return g[K]
print(f_strivore())
| 0 | null | 55,748,071,091,032 | 244 | 124 |
mod=998244353
class Combination:
def __init__(self, N):
self.fac = [1] * (N + 1)
for i in range(1, N + 1):
self.fac[i] = (self.fac[i - 1] * i) % mod
self.invmod = [1] * (N + 1)
self.invmod[N] = pow(self.fac[N], mod - 2, mod)
for i in range(N, 0, -1):
self.invmod[i - 1] = (self.invmod[i] * i) % mod
def calc(self, n, k): # nCk
return self.fac[n] * self.invmod[k] % mod * self.invmod[n - k] % mod
N,M,K=map(int,input().split())
C=Combination(N)
ans=0
c=[1]*(N)
for i in range(1,N):
c[i]=c[i-1]*(M-1)%mod
for i in range(K+1):
tmp=M*c[N-i-1]*C.calc(N-1,N-i-1)%mod
ans=(ans+tmp)%mod
print(ans)
|
MOD = 998244353
MAX = int(2e5 + 5)
fact = [0] * MAX
invFact = [0] * MAX
def bigmod(a, b):
if b == 0:
return 1
ret = bigmod(a, b // 2)
ret = (ret * ret) % MOD
if b % 2 == 1:
ret = (ret * a) % MOD
return ret
def mod_inverse(a):
return bigmod(a, MOD - 2)
def pre():
global fact, invFact
fact[0] = 1
for i in range(1, MAX):
fact[i] = (fact[i - 1] * i) % MOD
invFact[MAX - 1] = mod_inverse(fact[MAX - 1])
for i in range(MAX - 2, -1, -1):
invFact[i] = (invFact[i + 1] * (i + 1)) % MOD
def ncr(nn, rr):
if nn < 0 or nn < rr or rr < 0:
return 0
return (fact[nn] * invFact[rr] * invFact[nn - rr]) % MOD
pre()
n, m, k = map(int, input().split())
ans = 0
for i in range(k + 1):
ans = (ans + m * bigmod(m - 1, n - 1 - i) * ncr(n - 1, i) ) % MOD
print(ans)
| 1 | 23,246,327,410,208 | null | 151 | 151 |
import queue
N = int(input())
G = []
for _ in range(N):
u, n, *K = map(int, input().split())
G.append((u - 1, [k - 1 for k in K]))
Q = queue.Queue()
Q.put(G[0])
dist = [-1] * N
dist[0] = 0
while not Q.empty():
U = Q.get()
for u in U[1]:
if dist[u] == -1:
Q.put(G[u])
dist[u] = dist[U[0]] + 1
for i, time in enumerate(dist):
print(i + 1, time)
|
import collections
def breadth_first_search(g,check,length):
q = collections.deque()
q.append(1)
check[1] = 1
length[1] = 0
while len(q) != 0:
v = q.popleft()
for u in g[v]:
if check[u] == 0:
check[u] = 1
length[u] = length[v]+1
q.append(u)
return length
def main():
N = int(input())
g = []
g.append([])
for i in range(N):
tmp = input().split()
tmp_ls = []
for i in range(int(tmp[1])):
tmp_ls.append(int(tmp[i+2]))
g.append(tmp_ls)
check = [0]*(N+1)
length = [0]*(N+1)
ans = breadth_first_search(g,check,length)
for i in range(N):
node_num = i+1
if ans[node_num] == 0 and i != 0:
ans[node_num] = -1
print(node_num,ans[node_num])
main()
| 1 | 4,149,822,148 | null | 9 | 9 |
N, *X = map(int, open(0).read().split())
ans = float("inf")
for x in range(min(X), max(X) + 1):
cur = 0
for j in range(N):
cur += (X[j] - x) ** 2
ans = min(ans, cur)
print(ans)
|
def Rally():
# 入力
N = int(input())
X = list(map(int, input().split()))
# リストの最大値と最小値
max_num = max(X)
min_num = min(X)
# Pの座標を移動させて各座標の体力消耗を調べる
min_sum = list()
for P in range(min_num, max_num+1):
sum = 0
for i in range(N):
sum += (X[i] - P)**2
min_sum.append(sum)
# 戻り値
return min(min_sum)
result = Rally()
print(result)
| 1 | 65,254,383,387,700 | null | 213 | 213 |
import math
class Point:
def __init__(self):
self.x = None
self.y = None
def koch(d, p1, p2):
if d == 0:
return
s = Point()
u = Point()
t = Point()
rad = math.radians(60)
s.x = (2 * p1.x + 1 * p2.x) / 3
s.y = (2 * p1.y + 1 * p2.y) / 3
t.x = (1 * p1.x + 2 * p2.x) / 3
t.y = (1 * p1.y + 2 * p2.y) / 3
u.x = (t.x - s.x) * math.cos(rad) - (t.y - s.y) * math.sin(rad) + s.x
u.y = (t.x - s.x) * math.sin(rad) + (t.y - s.y) * math.cos(rad) + s.y
koch(d-1, p1, s)
print(s.x, s.y)
koch(d-1, s, u)
print(u.x, u.y)
koch(d-1, u, t)
print(t.x, t.y)
koch(d-1, t, p2)
def main():
n = int(input())
a = Point()
b = Point()
a.x = 0.0
a.y = 0.0
b.x = 100.0
b.y = 0.0
print(a.x, a.y)
koch(n, a, b)
print(b.x, b.y)
if __name__ == "__main__":
main()
|
def rec(A,n):
if n==0:
return A
else:
return rec(draw(A),n-1)
def draw(A):
l=[]
for i in range(len(A)-1):
a=(A[i+1][0]-A[i][0])/3
b=(A[i+1][1]-A[i][1])/3
u0=(a,b)
u60=(a*(1/2)-b*(3**(1/2)/2),a*(3**(1/2)/2)+b*(1/2))
u300=(a*(1/2)+b*(3**(1/2)/2),-a*(3**(1/2)/2)+b*(1/2))
P=(A[i][0]+u0[0],A[i][1]+u0[1])
Q=(P[0]+u60[0],P[1]+u60[1])
R=(Q[0]+u300[0],Q[1]+u300[1])
l.extend([A[i],P,Q,R])
l.append(A[-1])
return l
n=int(input())
A=[(0.0,0.0),(100.0,0.0)]
B=rec(A,n)
for P in B:
print(f'{P[0]} {P[1]}')
| 1 | 123,204,076,996 | null | 27 | 27 |
n = int(input())
data = list(map(int, input().split()))
for i in range(n):
v = data[i]
j = i - 1
while j >= 0 and data[j] > v:
data[j+1] = data[j]
j -= 1
data[j+1] = v
print(" ".join(map(str, data)))
|
def insertionSort(A,input_num):
for i in range(input_num):
v = A[i]
j = i - 1
while(j >= 0 and A[j] > v):
A[j + 1] = A[j]
j -= 1
A[j + 1] = v
print(*A)
input_num = int(input())
A = list(map(int, input().split()))
insertionSort(A,input_num)
| 1 | 5,867,787,212 | null | 10 | 10 |
square = []
while True:
data = [int(e) for e in input().split()]
if data[0]==0 and data[1]==0:
break
square.append(data)
for i in range(len(square)):
for j in range(square[i][0]):
for k in range(square[i][1]):
print("#", end="")
print()
print()
|
K = int(input())
S = input()
l = list(S)
if len(l) <= K: print(S)
else:
ans = ''
for i in range(K):
ans += l[i]
ans += '...'
print(ans)
| 0 | null | 10,154,127,934,882 | 49 | 143 |
import sys
import re
import queue
import collections
import math
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []
def gcd_list(numbers):
return reduce(gcd, numbers)
def main():
N = i_input()
A = i_list()
d = dict()
max_A = max(A)
count_list = []
MAXN = 10**6+10
sieve = [i for i in range(MAXN+1)]
p = 2
while p*p <= MAXN:
if sieve[p] == p:
for q in range(2*p,MAXN+1,p):
if sieve[q] == q:
sieve[q] = p
p += 1
for i in range(0,max(A)):
count_list.append(0)
for a in A:
tmp = set()
while a > 1:
tmp.add(sieve[a])
a //= sieve[a]
for p in tmp:
count_list[p-1] += 1
if (max(count_list)<=1):
print("pairwise coprime")
elif(gcd_list(A)==1):
print("setwise coprime")
else:
print("not coprime")
return
if __name__ == '__main__':
main()
|
import heapq
X,Y,A,B,C = map(int, input().split())
p_list = sorted([(-v, 'p') for v in map(int, input().split())])
q_list = sorted([(-v, 'q') for v in map(int, input().split())])
r_list = sorted([(-v, 'r') for v in map(int, input().split())])
res = 0
r_cnt = 0
for v, k in heapq.merge(p_list, q_list, r_list):
v = -v
if X+Y-r_cnt == 0:
break
if k == 'p':
if X != 0:
X -= 1
res += v
continue
if k == 'q':
if Y != 0:
Y -= 1
res += v
continue
res += v
r_cnt += 1
print(res)
| 0 | null | 24,347,065,588,390 | 85 | 188 |
import sys
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))
K, X = input_nums()
if 500*K >= X:
print('Yes')
else:
print('No')
|
def main():
K, X = map(int, input().split())
if 500 * K >= X:
ans = "Yes"
else:
ans = "No"
print(ans)
if __name__ == "__main__":
main()
| 1 | 98,550,967,009,122 | null | 244 | 244 |
n,k,s = map(int,input().split())
if s != 10**9:
ans_ls = [s+1] * n
for i in range(k):
ans_ls[i] = s
ans_ls = list(map(str,ans_ls))
else:
ans_ls = [1] * n
for i in range(k):
ans_ls[i] = s
ans_ls = list(map(str,ans_ls))
print(' '.join(ans_ls))
|
a, b = map(int, input().split())
if a > b:
print('safe')
else:
print('unsafe')
| 0 | null | 60,126,973,235,520 | 238 | 163 |
import math
def koch(start, end, n, r):
if n > 0:
#途中の頂点をa, b, cとする
a = [(start[0]*2 + end[0]*1) / 3, (start[1]*2 + end[1]*1) / 3]
c = [(start[0]*1 + end[0]*2) / 3, (start[1]*1 + end[1]*2) / 3]
x = c[0] - a[0]
y = c[1] - a[1]
b = [x * math.cos(math.pi/3) - y * math.sin(math.pi/3) + a[0], x * math.sin(math.pi/3) + y * math.cos(math.pi/3) + a[1]]
koch(start, a, n-1, r)
koch(a, b, n-1, r)
koch(b, c, n-1, r)
koch(c, end, n-1, r)
else:
r.append(start)
n = int(input())
r = []
koch([0, 0], [100, 0], n, r)
r.append([100, 0])
for rr in r:
print(str(rr[0]) + ' ' + str(rr[1]))
|
import math
n = int(input())
class point:
x = 0
y = 0
def kock(k, p1, p2):
s = point()
t = point()
u = point()
if k == 0:
return
s.x = (2*p1.x+p2.x)/3
s.y = (2*p1.y+p2.y)/3
t.x = (p1.x+2*p2.x)/3
t.y = (p1.y+2*p2.y)/3
u.x = (t.x-s.x)*math.cos(math.radians(60))-(t.y-s.y)*math.sin(math.radians(60))+s.x
u.y = (t.x-s.x)*math.sin(math.radians(60))+(t.y-s.y)*math.cos(math.radians(60))+s.y
kock(k-1, p1, s)
print(s.x, s.y)
kock(k-1, s, u)
print(u.x, u.y)
kock(k-1, u, t)
print(t.x, t.y)
kock(k-1, t, p2)
a = point()
b = point()
b.x = 100
print(a.x, a.y)
kock(n, a, b)
print(b.x, b.y)
| 1 | 131,927,658,460 | null | 27 | 27 |
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def lcm(a, b):
return a // gcd(a, b) * b
N, M = map(int, input().split())
A = list(map(int, input().split()))
A = [a//2 for a in A]
while A[0] % 2 == 0:
for i in range(N):
if A[i] % 2 != 0:
print(0)
exit()
A[i] //= 2
M //= 2
for i in range(N):
if A[i] % 2 == 0:
print(0)
exit()
lcm_ = 1
for i in range(N):
lcm_ = lcm(lcm_, A[i])
if M < lcm_:
print(0)
exit()
print((M // lcm_ + 1) // 2)
|
import collections
import itertools
N = int(input())
A = list(map(int, input().split()))
ac = collections.Counter(A)
dp = [0] * (N+1)
dp2 = [0] * (N+1)
total = 0
for no, num in ac.items():
dp[no] = int(num*(num-1)/2)
dp2[no] = dp[no] - (num-1)
total += dp[no]
for k in range(1,N+1):
no = A[k-1]
print(int(total - dp[no] + dp2[no]))
| 0 | null | 74,721,706,928,540 | 247 | 192 |
N,K,S=map(int,input().split())
a=[10**9 if S==1 else S-1]*N
for i in range(K):a[i]=S
print(' '.join(map(str,a)))
|
S = input()
# S のすべての文字を x で置き換えて出力せよ。
answer = ''
for i in range(len(S)):
answer += 'x'
print(answer)
| 0 | null | 82,219,603,841,022 | 238 | 221 |
s = input()
if "B" in s:
print("ARC")
else:
print("ABC")
|
print({'ABC':'ARC', 'ARC':'ABC'}[input()])
| 1 | 24,002,364,708,710 | null | 153 | 153 |
a = int(input())
if(a%2 == 1):
print((a+1)//2)
if(a%2 == 0):
print(a//2)
|
import sys
l = []
for i in sys.stdin:
l.append(i)
for i in range(0,len(l)):
if int(l[i]) == 0:
break
count = 0
for j in range(0,len(l[i])-1):
count += int(l[i][j])
print(count)
| 0 | null | 30,290,271,010,822 | 206 | 62 |
from collections import Counter
n = int(input())
a = list(map(int,input().split()))
ja1 = []
ja2 = []
for i in range(1,n+1):
ja1.append(i-a[i-1])
ja2.append(i+a[i-1])
s = Counter(ja1)
t = Counter(ja2)
su = 0
for i in s.keys():
su += s[i]*t[i]
print(su)
|
X,Y = map(int,input().split())
money = [3*10**5,2*10**5,10**5]
ans = 0
if X == 1 and Y == 1:
ans = 2*money[0] + 4*10**5
print(ans)
else:
if X <= 3:
ans += money[X-1]
if Y <= 3:
ans += money[Y-1]
print(ans)
| 0 | null | 83,457,236,510,560 | 157 | 275 |
import sys
input = sys.stdin.readline
class WarshallFloyd:
def __init__(self,n):
self.v = n
self.d = [[1e100]*n for _ in range(n)]
for i in range(n):
self.d[i][i] = 0
def path(self,x,y,c):
if x == y:
return False
self.d[x][y] = c
self.d[y][x] = c
return True
def build(self):
for k in range(self.v):
for i in range(self.v):
for j in range(self.v):
self.d[i][j] = min(self.d[i][j], self.d[i][k] + self.d[k][j])
n,m,l = map(int,input().split())
wf = WarshallFloyd(n)
for i in range(m):
a,b,c = map(int,input().split())
wf.path(a-1,b-1,c)
wf.build()
d = [[1e100]*n for _ in range(n)]
for i in range(n):
for j in range(n):
if i == j:
d[i][j] = 0
elif wf.d[i][j] <= l:
d[i][j] = 1
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
q = int(input())
for i in range(q):
s,t = map(int,input().split())
ans = d[s-1][t-1]
if ans == 1e100:
print(-1)
else:
print(ans - 1)
|
def main():
n = int(input())
ans = n * (n + 1) - 1 # 1とk 自信
i = 2
while i * i <= n:
num = n // i
min_i = i * i
max_i = i * num
ans += (num - i + 1) * (min_i + max_i) # 自分自身
ans -= min_i
i += 1
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 92,526,060,504,310 | 295 | 118 |
n=int(input())
a=1000
i=1
while n>a:
i=i+1
a=a+1000
print(a-n)
|
import math
a, b, n = map(int, input().split())
k = min(n, b-1)
print(math.floor(a/b*k))
| 0 | null | 18,176,287,925,844 | 108 | 161 |
import sys
import numpy as np
N = input()
print(N[0:3])
|
c = input()
ls = [chr(ord('a') + i) for i in range(26)]
for i in range(len(ls)):
if ls[i] == c:
print(ls[i + 1])
break
| 0 | null | 53,716,628,002,060 | 130 | 239 |
def solve():
H,W,K = [int(i) for i in input().split()]
grids = []
for i in range(H):
row = input()
grids.append(row)
import itertools
rows = list(range(H))
row_combis = set([])
for i in range(H+1):
tmp = itertools.combinations(rows, i)
row_combis |= set(tmp)
columns = list(range(W))
column_combis = set([])
for i in range(W+1):
tmp = itertools.combinations(columns, i)
column_combis |= set(tmp)
ans = 0
for row_combi in row_combis:
for column_combi in column_combis:
num_black = 0
for i in range(H):
for j in range(W):
if i in row_combi:
continue
if j in column_combi:
continue
if grids[i][j] == '#':
num_black += 1
if num_black == K:
ans += 1
print(ans)
if __name__ == "__main__":
solve()
|
import sys
import itertools
input = sys.stdin.readline
def SI(): return str(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
H, W, K = MI()
grid = [SI().rstrip('\n') for _ in range(H)]
n = H + W
ans = 0
for i in itertools.product(range(2),repeat = H):
for j in itertools.product(range(2),repeat = W):
count = 0
for k in range(H):
if i[k] == 1:
continue
for l in range(W):
if j[l] == 1:
continue
if grid[k][l] == "#":
count += 1
if count == K:
ans +=1
print(ans)
main()
| 1 | 8,911,886,688,458 | null | 110 | 110 |
import sys
input = sys.stdin.readline
a = int(input())
print(a + a*a + a*a*a)
|
import sys
import math
import collections
import heapq
import queue
import itertools
import functools
import operator
import time
readline = sys.stdin.readline
IPS = lambda: readline().rstrip()
IP = lambda: int(readline().rstrip())
MP = lambda: map(int, readline().split())
LS = lambda: list(map(int, readline().split()))
def solve():
for _ in range(1):
n = IP()
print(n + n**2 + n**3)
if __name__ == "__main__":
solve()
| 1 | 10,215,293,756,526 | null | 115 | 115 |
x = input()
x = x.split(" ")
width = int(x[0])
height = int(x[1])
area = width * height
perimeter = width * 2 + height * 2
print("{0} {1}".format(area, perimeter))
|
length0 = input()
#print(length0)
length = length0.split()
a = int(length[0])
b = int(length[1])
#print(str(a)+" "+str(b))
area = a*b
per = 2*a+2*b
print(str(area)+" "+str(per))
| 1 | 306,003,623,530 | null | 36 | 36 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 # 出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
ans = 0
for i in range(N-K+1):
ans += A[-1-i]*cmb(N-1-i, K-1, mod)
ans %= mod
ans -= A[i]*cmb(N-1-i, K-1, mod)
ans %= mod
print(ans)
|
n, k = [int(x) for x in input().split()]
a_list = [int(x) for x in input().split()]
a_list.sort()
mod = 10 ** 9 + 7
temp_list = [1] * (n + 1)
for i in range(1, n + 1):
temp_list[i] = i * temp_list[i - 1] % mod
i_temp_list = [1] * (n + 1)
i_temp_list[-1] = pow(temp_list[-1], mod - 2, mod)
for i in range(n, 0, -1):
i_temp_list[i - 1] = i_temp_list[i] * i % mod
y = k - 1
ans = 0
for i in range(k - 1, n):
x = i
num = temp_list[x] * i_temp_list[y] * i_temp_list[x - y] % mod
ans += a_list[i] * num % mod
for i in range(n - k + 1):
x = n - 1 - i
num = temp_list[x] * i_temp_list[y] * i_temp_list[x - y] % mod
ans -= a_list[i] * num % mod
ans %= mod
print(ans)
| 1 | 95,795,007,388,212 | null | 242 | 242 |
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 6)
mod = 10**9+7
cnt = 1
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()
n = k()
s = v()
s1,s2,s3 = set(),set(),set()
for x in s:
for z in s2:
s3.add(z+x)
for y in s1:
s2.add(y+x)
s1.add(x)
print(len(s3))
|
import math
len_a, len_b, deg_C = map(int,input().split(" "))
rad_C = math.radians(deg_C)
#area
S = (1/2) * len_a * len_b * math.sin(rad_C)
#Length
L = len_a + len_b + math.sqrt(len_a ** 2 + len_b ** 2 - 2 * len_a * len_b * math.cos(rad_C))
#height
h = len_b * math.sin(rad_C)
print("{:.5f}\n{:.5f}\n{:.5f}".format(S,L,h))
| 0 | null | 64,150,838,823,040 | 267 | 30 |
import sys
import time
t = time.time()
n = int(input())
a = list(map(int, input().split(' ')))
b = list(range(n))
b.sort(key=lambda x: -a[x])
# print("b after:", b)
# print(list(map(lambda x:a[x],b)))
# print(time.time()-t)
cache = [[-1 for x in range(n)] for y in range(n)]
# print(cache)
def dfs(left, right):
if left > right:
return 0
if cache[left][right] != -1:
return cache[left][right]
which = n-(right-left+1)
ans1 = dfs(left+1, right)+abs(left-b[which])*a[b[which]]
ans2 = dfs(left, right-1)+abs(right-b[which])*a[b[which]]
cache[left][right] = max(ans1, ans2)
return cache[left][right]
sys.setrecursionlimit(2010)
print(dfs(0, n-1))
|
n=int(input())
a=list(enumerate(map(int,input().split())))
a.sort(key=lambda x: -x[1])
dp=[[0]*(n+1) for i in range(n+1)]
for idx,ix in enumerate(a):
i,x=ix
for j in range(idx+1):
dp[j+1][idx-j]=max(dp[j+1][idx-j],dp[j][idx-j]+(i-j)*x)
dp[j][idx-j+1]=max(dp[j][idx-j+1],dp[j][idx-j]+((n-1-(idx-j))-i)*x)
print(max([dp[i][n-i] for i in range(n+1)]))
| 1 | 33,621,634,418,010 | null | 171 | 171 |
import math
import collections
import fractions
import itertools
import functools
import operator
import bisect
def solve():
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ruia, ruib = [0], [0]
for i in range(n): ruia.append(a[i]+ruia[i])
for i in range(m): ruib.append(b[i]+ruib[i])
ans = 0
j = m
for i in range(n+1):
if ruia[i] > k:
break
while(ruib[j]>k-ruia[i]):
j -= 1
ans = max(ans, i+j)
print(ans)
return 0
if __name__ == "__main__":
solve()
|
n="0"+input()
k=int(input())
dp=[[[0]*5,[0]*5] for _ in range(len(n))]
dp[0][1][0]=1
for i in range(1,len(n)):
x=int(n[i])
for j in range(4):
if dp[i-1][1][j]:
dp[i][1][j+(x!=0)]=1
if x>1:
dp[i][0][j+1]+=(x-1)
dp[i][0][j]+=1
elif x==1:
dp[i][0][j]+=1
if dp[i-1][0][j]:
dp[i][0][j]+=dp[i-1][0][j]
dp[i][0][j+1]+=(dp[i-1][0][j]*9)
dp[i][0][0]=1
print(dp[-1][0][k]+dp[-1][1][k])
| 0 | null | 43,261,896,103,712 | 117 | 224 |
while True:
C = input()
if C == "-":
break
count = int(input())
shuffle = [int(input()) for i in range(count)]
for h in shuffle:
C = C[h:] + C[:h]
print(C)
|
s = input().rstrip()
p = input().rstrip()
line = s + s
print("Yes") if p in line else print("No")
| 0 | null | 1,812,577,324,884 | 66 | 64 |
d=int(input()) #365
c=list(map(int,input().split()))
s=[]
for i in range(d):
s.append(list(map(int,input().split())))
ll=[0 for i in range(26)]
l=[]
ans=[]
for i in range(d):
for j in range(26):
ll[j]+=1
m=-(10**10)
for j in range(26):
t=s[i][j]+ll[j]*c[j]
if m<t:
m=t
tt=j
l.append(ll[tt])
ans.append(tt)
ll[tt]=0
print("\n".join(map(lambda x:str(x+1),ans)))
|
D = int(input())
C = [int(T) for T in input().split()]
S = [[] for TD in range(0,D)]
for TD in range(0,D):
S[TD] = [int(T) for T in input().split()]
for TD in range(0,D):
print(S[TD].index(max(S[TD]))+1)
| 1 | 9,668,191,496,558 | null | 113 | 113 |
from itertools import accumulate
n,m,k = map(int,input().split())
deskA = list(map(int,input().split()))
deskB = list(map(int,input().split()))
cumA = [0] + list(accumulate(deskA))
cumB = [0] + list(accumulate(deskB))
ans = 0
j = m
for i in range(n+1):
if cumA[i] > k:
continue
while cumA[i] + cumB[j] > k:
j -= 1
ans = max(i+j,ans)
print(ans)
|
n, m, k = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
a = [0 for i in range(n+1)]
b = [0 for j in range(m+1)]
for i in range(n):
a[i+1] = a[i]+A[i]
for j in range(m):
b[j+1] = b[j]+B[j]
j = m
res = 0
for i in range(n+1):
if a[i] > k:
break
while k - a[i] < b[j]:
j -= 1
res = max(res, i+j)
print(res)
| 1 | 10,852,521,690,780 | null | 117 | 117 |
k = int(input())
a, b = map(int, input().split())
if a <= k <= b or k <= b/2:
print('OK')
else:
print('NG')
|
K = int(input())
[A, B] = [int(i) for i in input().split()]
for num in range(A, B+1):
if num % K == 0:
print("OK")
exit()
print("NG")
| 1 | 26,501,454,278,908 | null | 158 | 158 |
import math
def main():
MOD = 10 ** 9 + 7
N = int(input())
A = list(map(int, input().split(' ')))
# 答えは sum(lcm(A) / A)
L = 1
for a in A:
L = L * a // math.gcd(L, a)
ans = 0
for a in A:
ans += L * pow(a, MOD - 2, MOD)
ans %= MOD
print(ans)
if __name__ == '__main__':
main()
|
n=int(input())
a=list(map(int,input().split()))+[0]
b=[0]*(n+1)
b[0]=1-a[0]
r=sum(a)-a[0]-a[1]
for i in range(1,n+1):
b[i]=min(r,b[i-1]*2-a[i])
r-=a[i+1]
if any(i<0 for i in b):print(-1)
else:print(sum(a)+sum(b))
| 0 | null | 53,396,993,980,260 | 235 | 141 |
A, B, K = list(map(int, input().split()))
A -= K
if A < 0:
B += A
A = 0
if B < 0:
B = 0
print(A, B)
|
a, b, k = map(int,input().split())
# for i in range(k):
# if a >= 1:
# a -= 1
# elif b >= 1:
# b -= 1
# else:
# continue
tmp = min(k, a)
a -= tmp
k -= tmp
b = max(0, b - k)
print(a, b)
| 1 | 104,095,648,739,430 | null | 249 | 249 |
S = input()
print(S[0:3:1])
|
n=int(input())
S=[int(i) for i in input().split()]
q=int(input())
T=[int(i) for i in input().split()]
def solve(i,m,n,S):
if sum(S)<m:
return False
if m==0:
return True
elif i>=n:
return False
res=solve(i+1,m,n,S) or solve(i+1,m-S[i],n,S)
return res
for i in range(q):
attempt=solve(0,T[i],n,S)
if attempt:
print("yes")
else:
print("no")
| 0 | null | 7,358,831,306,850 | 130 | 25 |
r, c = list(map(int, input().split()))
A = []
for i in range(r):
A.append(list(map(int, input().split())))
A[i].append(sum(A[i]))
A.append([])
for j in range(c):
A[r].append(sum(A[i][j] for i in range(r)))
A[r].append(sum(A[r]))
for i in range(r + 1):
print(" ".join(list(map(str, A[i]))))
|
N = int(input())
A = list(map(int, input().split()))
# N日目の最大の所持金
dp = [1000] + [0] * (N-1)
for i in range(1, N):
dp[i] = dp[i-1]
for j in range(i):
# j日に買える最大の株数
max_unit = dp[j] // A[j]
# その場合の所持金の変化
money = dp[j] + (A[i]-A[j])*max_unit
dp[i] = max(money, dp[i])
print(dp[-1])
| 0 | null | 4,355,503,072,978 | 59 | 103 |
#coding:utf-8
import math
def isPrime(n):
if n == 2:
return True
elif n % 2 == 0:
return False
else:
for i in range(3,math.ceil(math.sqrt(n))+1,2):
if n % i == 0:
return False
return True
n = int(input())
c = 0
for i in range(n):
if isPrime(int(input())):
c += 1
print(c)
|
n=int(input())
c=0
for _ in range(n):
x=int(input())
if x==2:c+=1
elif pow(2,x-1,x)==1:c+=1
print(c)
| 1 | 9,688,097,592 | null | 12 | 12 |
if(str(input()).islower()):
print("a")
else:
print("A")
|
alp = input()
if alp==alp.upper() :
print("A")
else :
print("a")
| 1 | 11,286,286,127,688 | null | 119 | 119 |
def check(n,k):
r=[]
while n>0:
r.append(n%k)
n//=k
return len(r)
n,k=map(int,input().split())
print(check(n,k))
|
N, K = map(int, input().split())
ans = 0
num = 1
while num <= N:
num *= K
ans += 1
print(ans)
| 1 | 64,391,324,822,750 | null | 212 | 212 |
def main():
import math
s = int(input())
mod = 10**9+7
c = s//3
ans = 0
for i in range(1,c+1):
l = s - i*3
ans += (math.factorial(l+i-1)//math.factorial(l)//math.factorial(i-1)) % mod
print(ans%mod)
if __name__ == "__main__":
main()
|
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
N, M = map(int, input().split())
if N == M:
print('Yes')
else:
print('No')
if __name__ == '__main__':
solve()
| 0 | null | 43,232,544,163,040 | 79 | 231 |
import sys
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def main():
n = I()
A = LI()
sub = [0]*n
for a in A:
sub[a-1] += 1
for s in sub:
print(s)
if __name__ == '__main__':
main()
|
N,K,S = map(int,input().split())
A = [S]*K
if S == 10**9:
A.extend([1]*(N-K))
else:
A.extend([10**9]*(N-K))
print(*A, sep = " ")
| 0 | null | 61,634,922,622,770 | 169 | 238 |
n = int(input())
a = list(map(int,input().split()))
b = a[0]
x = 0
for i in range(1,n):
if a[i] > b:
b = a[i]
else:
x += b-a[i]
print(x)
|
import sys
sys.setrecursionlimit(10000000)
def dfs(s):
if len(s)==11:
return
if s!="":
a.append(int(s))
for c in "0123456789":
if s=="" and c=="0":continue
if s!="":
if abs(ord(c)-ord(s[-1]))<=1:
dfs(s+c)
else:
dfs(s+c)
k=int(input())
a=[]
dfs("")
a=list(set(a))
a.sort()
print(a[k-1])
| 0 | null | 22,343,053,036,640 | 88 | 181 |
import collections
h,w,m = map(int,input().split())
gyou = [0 for i in range(h)]
retu = [0 for i in range(w)]
l = []
for i in range(m):
y,x = map(int,input().split())
gyou[y-1] += 1
retu[x-1] += 1
l.append((y-1,x-1))
ymax = max(gyou)
xmax = max(retu)
c_ymax = gyou.count(ymax)
c_xmax = retu.count(xmax)
ans = ymax + xmax
c = 0
for y,x in l:
if gyou[y] == ymax and retu[x] == xmax:
c += 1
if c == c_ymax*c_xmax:
print(ans-1)
else:
print(ans)
|
H, W, M, *HW = map(int, open(0).read().split())
HW = list(zip(*[iter(HW)] * 2))
A = [0] * (H + 1)
B = [0] * (W + 1)
for h, w in HW:
A[h] += 1
B[w] += 1
a = max(A)
b = max(B)
cnt = A.count(a) * B.count(b) - len([0 for h, w in HW if A[h] == a and B[w] == b])
print(a + b - (cnt == 0))
| 1 | 4,707,596,555,820 | null | 89 | 89 |
T=input()
print(T.replace("?","D"))
|
s = input()
prev = 'D'
ans = []
for i in s:
if(i=='P' or i=='D'):
prev=i
ans.append(i)
else:
ans.append('D')
print(''.join(ans))
| 1 | 18,433,760,805,622 | null | 140 | 140 |
A, B, H, M = map(int, input().split())
import math
H_angle =(M * math.pi) / 30
M_angle = (60 * H + M) * math.pi / 360
H_x, H_y = (A * math.cos(H_angle), A * math.sin(H_angle))
M_x, M_y = (B * math.cos(M_angle), B * math.sin(M_angle))
d = math.sqrt((H_x - M_x) ** 2 + (H_y - M_y) ** 2)
print(d)
|
import math
a, b, h, m = map(int, input().split())
st = (60*h+m)/360*math.pi
lt = m/30*math.pi
sx = a*math.sin(st)
sy = a*math.cos(st)
lx = b*math.sin(lt)
ly = b*math.cos(lt)
print(math.sqrt((lx-sx)**2+(ly-sy)**2))
| 1 | 20,029,922,232,030 | null | 144 | 144 |
k = int(input())
def make_lunlun(lunlun_lst):
ret_lunlun = []
for num in lunlun_lst:
num_str = str(num)
if num_str[-1] != "0":
num_tmp = num_str + str(int(num_str[-1]) - 1)
ret_lunlun.append(int(num_tmp))
if num_str[-1] != "9":
num_tmp = num_str + str(int(num_str[-1]) + 1)
ret_lunlun.append(int(num_tmp))
num_tmp = num_str + num_str[-1]
ret_lunlun.append(int(num_tmp))
return ret_lunlun
lunlun_lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
while 1:
if len(lunlun_lst) < k:
k -= len(lunlun_lst)
lunlun_lst = make_lunlun(lunlun_lst)
else:
lunlun_lst.sort()
print(lunlun_lst[k - 1])
break
|
from collections import deque
def main():
k = int(input())
d = deque(list(range(1, 10)))
ans = 0
for _ in range(k):
ans = d.popleft()
if ans % 10 != 0:
d.append(10 * ans + (ans % 10) - 1)
d.append(10 * ans + (ans % 10))
if ans % 10 != 9:
d.append(10 * ans + (ans % 10) + 1)
print(ans)
if __name__ == '__main__':
main()
| 1 | 40,058,932,499,190 | null | 181 | 181 |
N = int(input())
A = [int(a) for a in input().split()]
if N % 2 == 0:
x, y, px, py = 0, 0, 0, -1<<100
for a in A:
x, y, px, py = px+a, max(x, py+a), x, y
print(max(x, y))
else:
x, y, z, px, py, pz = 0, 0, 0, 0, -1<<100, -1<<100
for a in A:
x, y, z, px, py, pz = px+a, max(x, py+a), max(y, pz+a), x, y, z
print(max(y, z))
|
# Serval vs Monster
H, A = map(int, input().split())
ans = (H // A) + min(1, H % A)
print(ans)
| 0 | null | 57,257,514,402,268 | 177 | 225 |
N,K = map(int,input().split())
R,S,P = map(int,input().split())
dp = []
order = input()
def jcount(x):
if x=='r':
ans = P
elif x=='s':
ans = R
else:
ans = S
return ans
counter = 0
for i in range(N):
if i < K:
counter += jcount(order[i])
dp.append(order[i])
elif order[i] != dp[i-K]:
counter += jcount(order[i])
dp.append(order[i])
else:
dp.append('x')
print(counter)
|
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())
def LLI(n): return [list(map(int, input().split())) for _ in range(n)]
n,k = MI()
R,S,P = MI()
T = input()
li = [[] for _ in range(k)]
for i in range(len(T)):
j = i%k
li[j].append(T[i])
score = 0
for i in range(k):
prev = "-1"
for j in range(len(li[i])):
if li[i][j] == "r":
if prev == "p":
prev = "-1"
else:
score += P
prev = "p"
if li[i][j] == "s":
if prev == "r":
prev = "-1"
else:
score += R
prev = "r"
if li[i][j] == "p":
if prev == "s":
prev = "-1"
else:
score += S
prev = "s"
print(score)
| 1 | 107,237,822,566,398 | null | 251 | 251 |
n,x,y=map(int,input().split())
l=[]
for i in range(n-1):
for j in range(i+1,n):
d1=j-i
d2=abs((x-1)-i)+abs(j-(y-1))+1
d=min(d1,d2)
l.append(d)
import collections
c=collections.Counter(l)
for kk in range(1,n):
print(c[kk])
|
from collections import deque
n = int(input())
M = [[0]*n for _ in range(n)]
d = [-1]*n
st = [0]*n
for _ in range(n):
i = [int(i) for i in input().split()]
u = i[0]
k = i[1]
V = i[2:]
for v in V: M[u-1][v-1] = 1
def bfs(s):
Q = deque()
Q.append(s)
st[s] = 1
d[s] = 0
while Q:
u = Q.popleft()
for v in range(n):
if M[u][v] and st[v] == 0:
st[v] = 1
Q.append(v)
d[v] = d[u]+1
st[u] = 2
return
bfs(0)
for i in range(n): print(i+1,d[i])
| 0 | null | 21,942,686,138,140 | 187 | 9 |
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
S, W = LI()
if S <= W:
print("unsafe")
else:
print("safe")
|
n,m=map(int,input().split())
if(n>m):
print("safe")
else:
print("unsafe")
| 1 | 29,146,601,832,804 | null | 163 | 163 |
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 # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
m1,d1 = readInts()
m2,d2 = readInts()
print('1' if m1 != m2 else '0')
|
def resolve():
n,k = map(int,input().split())
ans = 0
while n!=0:
n = n//k
ans += 1
print(ans)
resolve()
| 0 | null | 94,391,374,279,680 | 264 | 212 |
n, k = map(int, input().split())
A = set([])
for i in range(k):
d = input()
A = A | set(map(int, input().split()))
ans = 0
for i in range(n):
if i+1 not in A:
ans += 1
print(ans)
|
n=int(input())
a=list(map(int,input().split()))
MOD= 10**9 + 7
toki = [0]*(n+1)
shigi=0
toki[0] = sum(a)-a[0]
for i in range(1, n-1):
toki[i] = toki[i-1]-a[i]
for i in range(n-1):
shigi += (a[i] * toki[i])
print(shigi%MOD)
| 0 | null | 14,247,584,385,410 | 154 | 83 |
import numpy as np
D = int(input())
c = np.array( list(map(int, input().split())) )
#
s = [[] for i in range(D)]
for i in range(D):
s[i] = np.array( list(map(int, input().split())) )
#
v = 0
cc = np.array( [0]*26 )
last = np.array( [-1]*26 )
for d in range(D):
cc += c
av = s[d] - sum( cc ) + cc
av2 = av + cc*min((D-d-1),13)
m = max(av2)
for t in range(26):
if av2[t] == m:
cc[t] = 0
v += av[t]
print(t+1)
break
#
#print( v )
|
import sys
import numpy as np
from numba import njit
@njit('(i8[:],)', cache=True)
def solve(inp):
def bitree_sum(bit, t, i):
s = 0
while i > 0:
s += bit[t, i]
i ^= i & -i
return s
def bitree_add(bit, n, t, i, x):
while i <= n:
bit[t, i] += x
i += i & -i
def bitree_lower_bound(bit, n, d, t, x):
sum_ = 0
pos = 0
for i in range(d, -1, -1):
k = pos + (1 << i)
if k <= n and sum_ + bit[t, k] < x:
sum_ += bit[t, k]
pos += 1 << i
return pos + 1
def initial_score(d, ccc, sss):
bit_n = d + 3
bit = np.zeros((26, bit_n), dtype=np.int64)
INF = 10 ** 18
for t in range(26):
bitree_add(bit, bit_n, t, bit_n - 1, INF)
ttt = np.zeros(d, dtype=np.int64)
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
best_t = 0
best_diff = -INF
costs = ccc * (i - last)
costs_sum = costs.sum()
for t in range(26):
tmp_diff = sss[i, t] - costs_sum + costs[t]
if best_diff < tmp_diff:
best_t = t
best_diff = tmp_diff
ttt[i] = best_t
last[best_t] = i
score += best_diff
bitree_add(bit, bit_n, best_t, i + 2, 1)
return bit, score, ttt
def calculate_score(d, ccc, sss, ttt):
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
t = ttt[i]
last[t] = i
score += sss[i, t] - (ccc * (i - last)).sum()
return score
def pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd = np.random.randint(0, d)
ct = np.random.randint(0, 26)
while ttt[cd] == ct:
ct = np.random.randint(0, 26)
diff = 0
t = ttt[cd]
k = bitree_sum(bit, t, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, t, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, t, k + 1) - 2
b = ccc[t]
diff -= b * (cd - c) * (e - cd)
diff -= sss[cd, t]
k = bitree_sum(bit, ct, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct, k) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct, k + 1) - 2
b = ccc[ct]
diff += b * (cd - c) * (e - cd)
diff += sss[cd, ct]
if diff > permissible:
bitree_add(bit, bit_n, t, cd + 2, -1)
bitree_add(bit, bit_n, ct, cd + 2, 1)
ttt[cd] = ct
else:
diff = 0
return diff
def swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd1 = np.random.randint(0, d - 1)
cd2 = cd1 + 1
ct1 = ttt[cd1]
ct2 = ttt[cd2]
if ct1 == ct2:
return 0
diff = 0
k = bitree_sum(bit, ct1, cd1 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct1, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct1, k + 1) - 2
diff += ccc[ct1] * (e + c - cd1 - cd2)
k = bitree_sum(bit, ct2, cd2 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct2, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct2, k + 1) - 2
diff -= ccc[ct2] * (e + c - cd1 - cd2)
diff -= sss[cd1, ct1] + sss[cd2, ct2]
diff += sss[cd1, ct2] + sss[cd2, ct1]
if diff > permissible:
bitree_add(bit, bit_n, ct1, cd1 + 2, -1)
bitree_add(bit, bit_n, ct1, cd2 + 2, 1)
bitree_add(bit, bit_n, ct2, cd1 + 2, 1)
bitree_add(bit, bit_n, ct2, cd2 + 2, -1)
ttt[cd1] = ct2
ttt[cd2] = ct1
else:
diff = 0
return diff
d = inp[0]
ccc = inp[1:27]
sss = np.zeros((d, 26), dtype=np.int64)
for r in range(d):
sss[r] = inp[27 + r * 26:27 + (r + 1) * 26]
bit, score, ttt = initial_score(d, ccc, sss)
bit_n = d + 3
bit_d = int(np.log2(bit_n))
loop = 4 * 10 ** 6
permissible_min = -3000.0
method_border = 0.5
best_score = score
best_ttt = ttt.copy()
for lp in range(loop):
permissible = (1 - lp / loop) * permissible_min
if np.random.random() < method_border:
diff = pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
else:
diff = swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
score += diff
# print(lp, score, calculate_score(d, ccc, sss, ttt))
if score > best_score:
best_score = score
best_ttt = ttt.copy()
return best_ttt + 1
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print('\n'.join(map(str, ans)))
| 1 | 9,687,138,987,448 | null | 113 | 113 |
N = input()
ans = 'ABC' if N == 'ARC' else 'ARC'
print(ans)
|
print( ['ABC','ARC'][str(input()) == 'ABC'] )
| 1 | 24,133,009,771,062 | null | 153 | 153 |
n,m = map(int,input().split())
h = list(map(int,input().split()))
r = ['t'] * n
for i in range(m):
x,y = map(int,input().split())
if h[x-1] > h[y-1]:
r[y-1] = 'f'
elif h[x-1] < h[y-1]:
r[x-1] = 'f'
else:
r[y-1] = 'f'
r[x-1] = 'f'
s = 0
for i in range(n):
if r[i] == 't':
s += 1
print(s)
|
n, m = map(int, input().split())
h = list(map(int, input().split()))
d = [1] * n
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
if h[a] > h[b]:
d[b] = 0
elif h[b] > h[a]:
d[a] = 0
else:
d[a] = 0
d[b] = 0
print(sum(d))
| 1 | 25,000,211,807,040 | null | 155 | 155 |
a = input()
if a.isupper():
print("A")
else: print("a")
|
print("A" if input().isupper() else "a")
| 1 | 11,221,626,114,062 | null | 119 | 119 |
def gcd(a, b):
if a==0:
return b
else:
return gcd(b%a, a)
X = int(input())
LCM = X*360/gcd(360, X)
print(int(LCM/X))
#a, b = map(int, input().split())
#print(gcd(a, b))
|
X=int(input())
cnt=0
for i in range(1,10**7):
cnt+=X
if cnt%360==0:
print(i)
break
| 1 | 13,216,407,589,268 | null | 125 | 125 |
X, Y = map(int, input().split())
if Y % 2 == 1:
print("No")
exit(0)
if 0 <= 2 * X - Y / 2 <= X:
print("Yes")
else:
print("No")
|
a,b,c,d = map(int, input().split())
max_list = [a*c,a*d,b*c,b*d]
max_list = sorted(max_list, reverse=True)
print(max_list[0])
| 0 | null | 8,399,558,200,462 | 127 | 77 |
N,R = list(map(int,input().split()))
ans=R
if N < 10:
ans += 100*(10-N)
print(ans)
|
N = int(input())
S = input()
r,g,b = S.count('R'),S.count('G'),S.count('B')
#rgbでr,g,bがすべて異なる組み合わせ数
total = r*g*b
# そこからj-i=k-jの組み合わせを引く
for i in range(0,N-2):
for j in range(i+1,N-1):
k = 2*j-i
if k >= N: break;
if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
total-=1
# flg = [[[0 for i in range(N)] for j in range(N)] for k in range(N)]
print(total)
| 0 | null | 49,900,024,174,588 | 211 | 175 |
n,x,y=map(int,input().split())
x-=1
y-=1
half=(x+y)//2
ans=[0]*n
for i in range(n):
for j in range(i,n):
if i<=x:
if j<=half:
ans[j-i]+=1
else:
ans[x-i+1+abs(y-j)]+=1
elif x<i and i<=y:
ans[min(j-i,i-x+1+abs(y-j))]+=1
else:
ans[j-i]+=1
for i in range(1,n):
print(ans[i])
|
n,x,y=map(int,input().split())
ans=[0]*n
tree=[[] for _ in range(n)]
for i in range(1,n):
tree[i-1].append(i)
tree[i].append(i-1)
tree[x-1].append(y-1)
tree[y-1].append(x-1)
from collections import deque
ans=[0]*n
for i in range(n):
checked=[-1]*n
stack=deque([i])
checked[i]=0
while len(stack)>0:
tmp=stack.popleft()
for item in tree[tmp]:
if checked[item]==-1:
checked[item]=checked[tmp]+1
stack.append(item)
for item in checked:
ans[item]+=1
for item in ans[1:]:
print(item//2)
| 1 | 44,038,476,402,838 | null | 187 | 187 |
def modpow(a, n, p):
if n == 0:
return 1
elif n == 1:
return a % p
if n % 2 == 1:
return (a * modpow(a, n-1, p)) % p
tmp = modpow(a, n//2, p)
return (tmp * tmp) % p
def modfactrial(a, p):
ret = 1
for i in range(a, 1, -1):
ret = ret * i % p
return ret
def main():
mod = 10 ** 9 + 7
n, a, b = map(int, input().split())
# まずは繰り返し2乗法によって全部の組み合わせを求める
# すべての組み合わせは、花を選ぶ/選ばないで組み合わせを決めれる
ans = (modpow(2, n, mod) - 1) % mod
# a本選んだときの数を引く
c_a = 1
for i in range(n, n-a, -1):
c_a *= i
c_a %= mod
c_a *= modpow(modfactrial(a, mod), mod-2, mod)
ans -= c_a
ans %= mod
# b本選んだときの数を引く
c_b = 1
for i in range(n, n-b, -1):
c_b *= i
c_b %= mod
c_b *= modpow(modfactrial(b, mod), mod-2, mod)
ans -= c_b
ans %= mod
print(ans)
if __name__ == "__main__":
main()
|
n, a, b = map(int, input().split())
mod = 10**9+7
ans = pow(2, n, mod)-1
modp = mod # 素数であることが前提
max_r = 10 ** 7 # 必要分だけ用意する 10**7が限度
factinv = [1, 1] + [0]*max_r # factinv[n] = ((n!)^(-1) mod modp)
inv = [0, 1] + [0]*max_r # factinv 計算用
fact = {}
def cmb(n, r, p):
assert n < p, 'n is less than modp'
assert r < max_r, 'n in less than max_n'
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
if (n, r) in fact:
return fact[(n, r)] * factinv[r] % p
else:
f = 1
for i in range(n, n-r, -1):
f = f * i % p
fact[(n, r)] = f
return f * factinv[r] % p
for i in range(2, max_r + 1):
inv[i] = (-inv[modp % i] * (modp // i)) % modp
factinv[i] = (factinv[i-1] * inv[i]) % modp
ans-=cmb(n, a, mod)
ans-=cmb(n, b, mod)
print(ans%mod)
| 1 | 66,155,413,390,502 | null | 214 | 214 |
p, q = 0, 1
for x in map(int, input()):
p, q = min(p + x, q + 10 - x), min(p + x + 1, q + 9 - x)
print(p)
|
import sys
def input():
return sys.stdin.readline().rstrip()
def main():
N = list(map(int,input()))
count = 0
S = len(N)
flag = 0
for i in range(S):
temp = flag + N[-1 - i]
if temp > 5:
count += 10 - temp
flag = 1
elif temp ==5 and i !=S-1 and N[-1-i-1]>=5:
count+=temp
flag=1
else:
count += temp
flag = 0
print(count + flag)
if __name__ == "__main__":
main()
| 1 | 71,005,317,985,572 | null | 219 | 219 |
N,K = map(int,input().split())
mod = 10**9+7
ans = [0]*(K+1)
result = 0
for i in range(K,0,-1):
c = K//i
ans[i] += pow(c,N,mod)
for j in range(i,K+1,i):
if i != j:
ans[i] -= ans[j]
result += i*ans[i] % mod
print(result%mod)
|
N, K = [int(n) for n in input().split()]
NUM = 1000000007
def modpow(a, b): # (a ** b) % NUM
ans = 1
while b != 0:
if b % 2 == 1:
ans *= a
ans %= NUM
a = a * a
a %= NUM
b //= 2
return ans
C = [0 for _ in range(K+1)]
for d in range(K):
k = K - d # K ... 1
L = K // k
C[k] = modpow(L, N) # A = 1*k ... L*k
for l in range(2, L+1):
C[k] -= C[l*k]
if C[k] < 0:
C[k] += NUM
C[k] %= NUM
ans = 0
for k in range(1, K+1):
ans += k * C[k]
ans %= NUM
print(ans)
| 1 | 36,837,279,333,276 | null | 176 | 176 |
n,m=map(int,input().split())
left=m//2
right=(m+1)//2
for i in range(left):
print(i+1,2*left+1-i)
for i in range(right):
print(2*left+1+i+1,2*left+1+2*right-i)
|
N = input()
sum = 0
for i in range(10):
sum += N.count(str(i)) * i
print('Yes' if sum%9 == 0 else 'No')
| 0 | null | 16,433,016,992,548 | 162 | 87 |
n = int(input())
s = input()
print(sum([1 for i in range(n-2) if s[i:i+3] == 'ABC']))
|
n = int(input())
s = list(input().split('ABC'))
print(len(s) - 1)
| 1 | 99,448,903,257,630 | null | 245 | 245 |
S=input()
if(S.isupper()):
print('A')
else:
print('a')
|
alp =['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
a = str(input())
if a in alp:
print('A')
else:
print('a')
| 1 | 11,292,182,647,002 | null | 119 | 119 |
import re
S = input()
print(re.sub('[a-z]', 'x',S))
|
l = len(input())
print('x'*l)
| 1 | 72,918,044,089,926 | null | 221 | 221 |
t = int(input())
print(t+t**2+t**3)
|
N = int(input())
print(N+N*N+N*N*N)
| 1 | 10,289,134,069,732 | null | 115 | 115 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 # 出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
ans = 0
for i in range(N-K+1):
ans += A[-1-i]*cmb(N-1-i, K-1, mod)
ans %= mod
ans -= A[i]*cmb(N-1-i, K-1, mod)
ans %= mod
print(ans)
|
N,K = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
MOD = 10**9+7
MAXN = N+5
fac = [1,1] + [0]*MAXN
finv = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def comb(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
ans = 0
for i in range(N-K+1):
c = comb(N-1-i,K-1)
ans += (A[-i-1] - A[i]) * c
ans %= MOD
print(ans)
| 1 | 95,767,269,538,282 | null | 242 | 242 |
import sys
s = sys.stdin.readline().rstrip()
s += s
pstr = sys.stdin.readline().rstrip()
if pstr in s:
print( "Yes" )
else:
print( "No" )
|
N = int(input())
A = 2*list(map(int, input().split()))
A.sort()
print(sum(A[N:-1]))
| 0 | null | 5,489,971,892,420 | 64 | 111 |
if int(input()) % 9 == 0:
print("Yes")
else:
print("No")
|
n = list(input())
tmp = 0
for i in n:
tmp += int(i) % 9
ans = "Yes" if tmp % 9 == 0 else "No"
print(ans)
| 1 | 4,394,730,309,588 | null | 87 | 87 |
N,X,M = [int(a) for a in input().split()]
amari = [0]*M
i = 1
A = X
amari[A] = i
l = [X]
ichi = i
while i<=M:
i += 1
A = A**2 % M
if amari[A]: i += M
else:
amari[A] = i
l.append(A)
if i==N: i = M+1
else:
if i>M+1: ni = i-M - amari[A]
else: ni = 0
#for j in range(M):
# if amari[j]: print(j, amari[j])
#print(i,len(l))
ichi = len(l) - ni
#print(l)
if ni:
ni_times, san = divmod((N - ichi), ni)
#print(ichi, '%d*%d'%(ni,ni_times), san)
print(sum(l[:ichi]) +
sum(l[ichi:])*ni_times +
sum(l[ichi:ichi+san]))
else:
#print(ichi, '%d*%d'%(ni,ni_times), san)
print(sum(l))
|
S = 0
N,D = input().split()
N = int(N)
D = int(D)
X = [0]*N
Y = [0]*N
for i in range(N):
X[i],Y[i] = map(int, input().split())
if ((X[i])**2 + (Y[i])**2) <= (D)**2:
S = S + 1
print(S)
| 0 | null | 4,359,233,340,772 | 75 | 96 |
n = int(input())
cn= 1
an= [1]
i = 1
while cn < n / 4:
an.append(cn*3+1)
cn=cn*3+1
an.sort(reverse=True)
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,an):
cnt=0
m = len(an)
g = an
for i in an:
cnt += insertionSort(a,n,i)
return cnt
x=[]
for i in range(n):
x.append(int(input()))
print(len(an))
print(" ".join([str(i) for i in an]))
y= shellSort(x,n,an)
print(y)
for i in range(n):
print(x[i])
|
def insertion_sort(numbers, n, g):
"""insertion sort method
(only elements whose distance is larger than g are the target)
Args:
numbers: list of elements to be sorted
n: len(numbers)
g: distance
Returns:
partially sorted list, counter
"""
counter = 0
copied_instance = []
for data in numbers:
copied_instance.append(data)
for i in range(g, n):
target = copied_instance[i]
j = i - g
while j >= 0 and target < copied_instance[j]:
copied_instance[j + g] = copied_instance[j]
j -= g
counter += 1
copied_instance[j + g] = target
return copied_instance, counter
def shell_sort(numbers, n, key=lambda x: x):
"""shell sort method
Args:
numbers: list of elements to be sorted
n: len(numbers)
Returns:
sorted numbers, used G, swapped number
"""
counter = 0
copied_instance = []
for data in numbers:
copied_instance.append(data)
G = [1]
g = 4
while g < len(numbers):
G.append(g)
g = g * 3 + 1
G = G[::-1]
for g in G:
copied_instance, num = insertion_sort(copied_instance, n, g)
counter += num
return copied_instance, G, counter
length = int(raw_input())
numbers = []
counter = 0
while counter < length:
numbers.append(int(raw_input()))
counter += 1
numbers, G, counter = shell_sort(numbers, length)
print(len(G))
print(" ".join([str(x) for x in G]))
print(counter)
for n in numbers:
print(str(n))
| 1 | 28,538,772,570 | null | 17 | 17 |
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
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)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def f(a):
b = [0]*(n+1)
for i in range(n):
l = max(0,i-a[i])
r = min(n,i+a[i]+1)
b[l] += 1
b[r] -= 1
for i in range(n):
b[i+1] += b[i]
return b[:n]
n,k = LI()
a = LI()
while k:
if sum(a) == n**2:
break
a = f(a)
k -= 1
print(*a)
return
#Solve
if __name__ == "__main__":
solve()
|
n,k=map(int,input().split())
a=list(map(int,input().split()))
for _ in range(min(k,41)):
b=[0]*(n+1)
for i in range(n):
l=max(0,i-a[i])
r=min(n,i+a[i]+1)
b[l]+=1
b[r]-=1
for i in range(n-1):
b[i+1]+=b[i]
a=b[:n]
print(*a)
| 1 | 15,481,833,118,630 | null | 132 | 132 |
from decimal import Decimal
def main():
a, b = input().split(" ")
a = int(a)
b = Decimal(b)
print(int(a*b))
if __name__ == "__main__":
main()
|
N,A,B = map(int,input().split())
p = N // (A+B)
q = N % (A+B)
if q > A:
r = A
else:
r = q
print(A * p + r)
| 0 | null | 35,951,760,085,398 | 135 | 202 |
text = input()
times = int(input())
for i in range(times):
function = input().split()
word = text[int(function[1]):int(function[2])+1]
if function[0] == "print":
print(word)
elif function[0] == "reverse":
word_reverse = word[::-1]
text = text[:int(function[1])] + word_reverse + text[int(function[2])+1:]
elif function[0] == "replace":
text = text[:int(function[1])] + function[3] + text[int(function[2])+1:]
|
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP1_9_D
def reverse(s, a, b):
s1 = s[0:a]
s2 = s[a:b+1]
s2 = s2[::-1]
s3 = s[b+1:len(string)]
return s1 + s2 + s3
def replace(s, a, b, p):
s1 = s[0:a]
s2 = p
s3 = s[b+1:len(string)]
return s1 + s2 + s3
string = input()
q = int(input())
for _ in range(q):
c = input().split()
if c[0] == "print":
print(string[int(c[1]):int(c[2])+1])
if c[0] == "reverse":
string = reverse(string, int(c[1]), int(c[2]))
if c[0] == "replace":
string = replace(string, int(c[1]), int(c[2]), c[3])
| 1 | 2,076,864,583,566 | null | 68 | 68 |
# coding: utf-8
# Here your code !
import sys
import collections
#import numpy
import statistics
import unittest
def calculate_standard_deviation():
lines = sys.stdin.readlines()
data = []
i = 0
while(i < len(lines)):
if(int(lines[i].rstrip()) == 0) :
break
else:
data.append([ int(score) for score in lines[i+1].rstrip().split() ])
i += 2
for scores in data:
mean = statistics.mean(scores)
print(statistics.pstdev(scores))
# print(numpy.std(scores))
def __input_error():
print("input error")
return -1
class __TestValueClass(unittest.TestCase):
def testEqual(self,func,tuples):
self.testFunction(self.assertEqual,func,tuples)
def testFunction(self,assertfunc,func,tuples):
#tuples[index] = ([*arguments of func], compared value)
for item in tuples:
try:
if isinstance(item[0], collections.Iterable):
assertfunc(func(*item[0]),item[1])
else:
assertfunc(func(item[0]),item[1])
except Exception as msg:
swidth = 15
print("="*50)
print("-- Assertion Error in '" + func.__name__ + "' --")
print("arguments".ljust(swidth)+":",item[0])
print("compared value".ljust(swidth)+":",item[1])
print("message".ljust(swidth)+":")
print(msg)
sys.exit()
print(func.__name__,": succeeded")
#test
if __name__ == "__main__" :
calculate_standard_deviation()
# test = __TestValueClass()
|
#coding: UTF-8
import statistics as st
while True:
N = int(input())
if N == 0:
break
buf = list(map(float, input().split()))
sd = st.pstdev(buf)
print("%.8f"%sd)
| 1 | 187,969,804,932 | null | 31 | 31 |
#Breadth First Search
n=int(input())
V=[]
a=[1]
for i in range(n):
V.append([int(i) for i in input().split()])
a.append(0)
V=sorted(V,key=lambda x:x[0])
print('1 0')
d=1
c=0
w=[0]
p=[]
while c<n and w!=[]:
i=0
y=[]
# print(c)
while c<n and i<len(w):
j=2
while j<2+V[w[i]][1] and c<n:
if a[V[w[i]][j]-1]==0:
# print(a)
a[V[w[i]][j]-1]=1
p.append([V[w[i]][j],d])
c+=1
y.append(V[w[i]][j]-1)
j+=1
i+=1
w=y
d+=1
p=sorted(p, key=lambda x:x[0])
#print(p)
i=2
j=0
while i <=n and j<len(p):
while p[j][0]>i:
print(str(i) +" -1")
i+=1
print(str(p[j][0])+" "+str(p[j][1]))
i+=1
j+=1
while i<=n:
print(str(i)+" -1")
i+=1
|
import queue
def bfs(g, s=1):
global q
dist = [-1] * len(g)
dist[1] = 0
q = queue.Queue()
q.put(s)
while not q.empty():
v = q.get()
if not G[v][1]:
continue
for vi in G[v][2:]:
if dist[vi] >= 0:
continue
q.put(vi)
dist[vi] = dist[v] + 1
return dist
n = int(input())
G = [None]
for i in range(n):
G.append(list(map(int, input().split())))
d = bfs(G)
for i in range(1, n + 1):
print('%d %d' % (i, d[i]))
| 1 | 4,278,469,404 | null | 9 | 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.